rugged 1.0.0 → 1.2.0

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

@@ -54,6 +54,7 @@ int git_credential_userpass(
 
 /* Deprecated credential functions */
 
+#ifndef GIT_DEPRECATE_HARD
 int git_cred_userpass(
 	git_credential **out,
 	const char *url,
@@ -64,3 +65,4 @@ int git_cred_userpass(
 	return git_credential_userpass(out, url, user_from_url,
 		allowed_types, payload);
 }
+#endif

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

@@ -327,7 +327,7 @@ static int _git_close(git_smart_subtransport *subtransport)
 {
 	git_subtransport *t = (git_subtransport *) subtransport;
 
-	assert(!t->current_stream);
+	GIT_ASSERT(!t->current_stream);
 
 	GIT_UNUSED(t);
 
@@ -338,8 +338,6 @@ static void _git_free(git_smart_subtransport *subtransport)
 {
 	git_subtransport *t = (git_subtransport *) subtransport;
 
-	assert(!t->current_stream);
-
 	git__free(t);
 }
 

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

@@ -14,7 +14,6 @@
 #include "buffer.h"
 #include "net.h"
 #include "netops.h"
-#include "global.h"
 #include "remote.h"
 #include "git2/sys/credential.h"
 #include "smart.h"
@@ -105,6 +104,11 @@ static int apply_url_credentials(
 	const char *username,
 	const char *password)
 {
+	GIT_ASSERT_ARG(username);
+
+	if (!password)
+		password = "";
+
 	if (allowed_types & GIT_CREDENTIAL_USERPASS_PLAINTEXT)
 		return git_credential_userpass_plaintext_new(cred, username, password);
 
@@ -139,8 +143,7 @@ static int handle_auth(
 	/* Start with URL-specified credentials, if there were any. */
 	if ((allowed_credtypes & GIT_CREDENTIAL_USERPASS_PLAINTEXT) &&
 	    !server->url_cred_presented &&
-	    server->url.username &&
-	    server->url.password) {
+	    server->url.username) {
 		error = apply_url_credentials(&server->cred, allowed_credtypes, server->url.username, server->url.password);
 		server->url_cred_presented = 1;
 
@@ -159,7 +162,7 @@ static int handle_auth(
 
 	if (error > 0) {
 		git_error_set(GIT_ERROR_HTTP, "%s authentication required but no callback set", server_type);
-		error = -1;
+		error = GIT_EAUTH;
 	}
 
 	if (!error)
@@ -176,7 +179,7 @@ GIT_INLINE(int) handle_remote_auth(
 
 	if (response->server_auth_credtypes == 0) {
 		git_error_set(GIT_ERROR_HTTP, "server requires authentication that we do not support");
-		return -1;
+		return GIT_EAUTH;
 	}
 
 	/* Otherwise, prompt for credentials. */
@@ -198,7 +201,7 @@ GIT_INLINE(int) handle_proxy_auth(
 
 	if (response->proxy_auth_credtypes == 0) {
 		git_error_set(GIT_ERROR_HTTP, "proxy requires authentication that we do not support");
-		return -1;
+		return GIT_EAUTH;
 	}
 
 	/* Otherwise, prompt for credentials. */
@@ -256,7 +259,7 @@ static int handle_response(
 	} else if (response->status == GIT_HTTP_STATUS_UNAUTHORIZED ||
 	           response->status == GIT_HTTP_STATUS_PROXY_AUTHENTICATION_REQUIRED) {
 		git_error_set(GIT_ERROR_HTTP, "unexpected authentication failure");
-		return -1;
+		return GIT_EAUTH;
 	}
 
 	if (response->status != GIT_HTTP_STATUS_OK) {
@@ -287,7 +290,6 @@ static int lookup_proxy(
 {
 	const char *proxy;
 	git_remote *remote;
-	bool use_ssl;
 	char *config = NULL;
 	int error = 0;
 
@@ -301,9 +303,8 @@ static int lookup_proxy(
 
 	case GIT_PROXY_AUTO:
 		remote = transport->owner->owner;
-		use_ssl = !strcmp(transport->server.url.scheme, "https");
 
-		error = git_remote__get_http_proxy(remote, use_ssl, &config);
+		error = git_remote__http_proxy(&config, remote, &transport->server.url);
 
 		if (error || !config)
 			goto done;
@@ -413,11 +414,11 @@ static int http_stream_read(
 
 	if (stream->state == HTTP_STATE_SENDING_REQUEST) {
 		git_error_set(GIT_ERROR_HTTP, "too many redirects or authentication replays");
-		error = -1;
+		error = GIT_ERROR; /* not GIT_EAUTH, because the exact cause is unclear */
 		goto done;
 	}
 
-	assert (stream->state == HTTP_STATE_RECEIVING_RESPONSE);
+	GIT_ASSERT(stream->state == HTTP_STATE_RECEIVING_RESPONSE);
 
 	error = git_http_client_read_body(transport->http_client, buffer, buffer_size);
 
@@ -551,11 +552,11 @@ static int http_stream_write(
 	if (stream->state == HTTP_STATE_NONE) {
 		git_error_set(GIT_ERROR_HTTP,
 		              "too many redirects or authentication replays");
-		error = -1;
+		error = GIT_ERROR; /* not GIT_EAUTH because the exact cause is unclear */
 		goto done;
 	}
 
-	assert(stream->state == HTTP_STATE_SENDING_REQUEST);
+	GIT_ASSERT(stream->state == HTTP_STATE_SENDING_REQUEST);
 
 	error = git_http_client_send_body(transport->http_client, buffer, len);
 
@@ -589,7 +590,7 @@ static int http_stream_read_response(
 		    (error = handle_response(&complete, stream, &response, false)) < 0)
 		    goto done;
 
-		assert(complete);
+		GIT_ASSERT(complete);
 		stream->state = HTTP_STATE_RECEIVING_RESPONSE;
 	}
 
@@ -638,7 +639,8 @@ static int http_action(
 	const http_service *service;
 	int error;
 
-	assert(out && t);
+	GIT_ASSERT_ARG(out);
+	GIT_ASSERT_ARG(t);
 
 	*out = NULL;
 
@@ -721,7 +723,7 @@ int git_smart_subtransport_http(git_smart_subtransport **out, git_transport *own
 
 	GIT_UNUSED(param);
 
-	assert(out);
+	GIT_ASSERT_ARG(out);
 
 	transport = git__calloc(sizeof(http_subtransport), 1);
 	GIT_ERROR_CHECK_ALLOC(transport);

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

@@ -9,6 +9,7 @@
 #define INCLUDE_transports_http_h__
 
 #include "buffer.h"
+#include "settings.h"
 #include "httpclient.h"
 
 #define GIT_HTTP_REPLAY_MAX 15

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

@@ -10,7 +10,6 @@
 #include "http_parser.h"
 #include "vector.h"
 #include "trace.h"
-#include "global.h"
 #include "httpclient.h"
 #include "http.h"
 #include "auth.h"
@@ -146,7 +145,8 @@ bool git_http_response_is_redirect(git_http_response *response)
 
 void git_http_response_dispose(git_http_response *response)
 {
-	assert(response);
+	if (!response)
+		return;
 
 	git__free(response->content_type);
 	git__free(response->location);
@@ -400,7 +400,7 @@ static int on_body(http_parser *parser, const char *buf, size_t len)
 		return 0;
 	}
 
-	assert(ctx->output_size >= ctx->output_written);
+	GIT_ASSERT(ctx->output_size >= ctx->output_written);
 
 	max_len = min(ctx->output_size - ctx->output_written, len);
 	max_len = min(max_len, INT_MAX);
@@ -445,7 +445,7 @@ GIT_INLINE(int) client_write_request(git_http_client *client)
 				      0);
 }
 
-const char *name_for_method(git_http_method method)
+static const char *name_for_method(git_http_method method)
 {
 	switch (method) {
 	case GIT_HTTP_METHOD_GET:
@@ -597,7 +597,7 @@ static int apply_credentials(
 			free_auth_context(server);
 	} else if (!token.size) {
 		git_error_set(GIT_ERROR_HTTP, "failed to respond to authentication challenge");
-		error = -1;
+		error = GIT_EAUTH;
 		goto done;
 	}
 
@@ -631,6 +631,26 @@ GIT_INLINE(int) apply_proxy_credentials(
 	                         request->proxy_credentials);
 }
 
+static int puts_host_and_port(git_buf *buf, git_net_url *url, bool force_port)
+{
+	bool ipv6 = git_net_url_is_ipv6(url);
+
+	if (ipv6)
+		git_buf_putc(buf, '[');
+
+	git_buf_puts(buf, url->host);
+
+	if (ipv6)
+		git_buf_putc(buf, ']');
+
+	if (force_port || !git_net_url_is_default_port(url)) {
+		git_buf_putc(buf, ':');
+		git_buf_puts(buf, url->port);
+	}
+
+	return git_buf_oom(buf) ? -1 : 0;
+}
+
 static int generate_connect_request(
 	git_http_client *client,
 	git_http_request *request)
@@ -641,14 +661,17 @@ static int generate_connect_request(
 	git_buf_clear(&client->request_msg);
 	buf = &client->request_msg;
 
-	git_buf_printf(buf, "CONNECT %s:%s HTTP/1.1\r\n",
-	               client->server.url.host, client->server.url.port);
+	git_buf_puts(buf, "CONNECT ");
+	puts_host_and_port(buf, &client->server.url, true);
+	git_buf_puts(buf, " HTTP/1.1\r\n");
 
 	git_buf_puts(buf, "User-Agent: ");
 	git_http__user_agent(buf);
 	git_buf_puts(buf, "\r\n");
 
-	git_buf_printf(buf, "Host: %s\r\n", client->proxy.url.host);
+	git_buf_puts(buf, "Host: ");
+	puts_host_and_port(buf, &client->server.url, true);
+	git_buf_puts(buf, "\r\n");
 
 	if ((error = apply_proxy_credentials(buf, client, request) < 0))
 		return -1;
@@ -658,6 +681,11 @@ static int generate_connect_request(
 	return git_buf_oom(buf) ? -1 : 0;
 }
 
+static bool use_connect_proxy(git_http_client *client)
+{
+    return client->proxy.url.host && !strcmp(client->server.url.scheme, "https");
+}
+
 static int generate_request(
 	git_http_client *client,
 	git_http_request *request)
@@ -666,7 +694,8 @@ static int generate_request(
 	size_t i;
 	int error;
 
-	assert(client && request);
+	GIT_ASSERT_ARG(client);
+	GIT_ASSERT_ARG(request);
 
 	git_buf_clear(&client->request_msg);
 	buf = &client->request_msg;
@@ -686,11 +715,8 @@ static int generate_request(
 	git_http__user_agent(buf);
 	git_buf_puts(buf, "\r\n");
 
-	git_buf_printf(buf, "Host: %s", request->url->host);
-
-	if (!git_net_url_is_default_port(request->url))
-		git_buf_printf(buf, ":%s", request->url->port);
-
+	git_buf_puts(buf, "Host: ");
+	puts_host_and_port(buf, request->url, false);
 	git_buf_puts(buf, "\r\n");
 
 	if (request->accept)
@@ -713,7 +739,8 @@ static int generate_request(
 		git_buf_printf(buf, "Expect: 100-continue\r\n");
 
 	if ((error = apply_server_credentials(buf, client, request)) < 0 ||
-	    (error = apply_proxy_credentials(buf, client, request)) < 0)
+	    (!use_connect_proxy(client) &&
+			(error = apply_proxy_credentials(buf, client, request)) < 0))
 		return error;
 
 	if (request->custom_headers) {
@@ -843,7 +870,10 @@ static int setup_hosts(
 {
 	int ret, diff = 0;
 
-	assert(client && request && request->url);
+	GIT_ASSERT_ARG(client);
+	GIT_ASSERT_ARG(request);
+
+	GIT_ASSERT(request->url);
 
 	if ((ret = server_setup_from_url(&client->server, request->url)) < 0)
 		return ret;
@@ -898,7 +928,7 @@ static int proxy_connect(
 	int error;
 
 	if (!client->proxy_connected || !client->keepalive) {
-		git_trace(GIT_TRACE_DEBUG, "Connecting to proxy %s:%s",
+		git_trace(GIT_TRACE_DEBUG, "Connecting to proxy %s port %s",
 			  client->proxy.url.host, client->proxy.url.port);
 
 		if ((error = server_create_stream(&client->proxy)) < 0 ||
@@ -923,7 +953,7 @@ static int proxy_connect(
 	    (error = git_http_client_skip_body(client)) < 0)
 		goto done;
 
-	assert(client->state == DONE);
+	GIT_ASSERT(client->state == DONE);
 
 	if (response.status == GIT_HTTP_STATUS_PROXY_AUTHENTICATION_REQUIRED) {
 		save_early_response(client, &response);
@@ -1003,8 +1033,7 @@ static int http_client_connect(
 	reset_parser(client);
 
 	/* Reconnect to the proxy if necessary. */
-	use_proxy = client->proxy.url.host &&
-	            !strcmp(client->server.url.scheme, "https");
+	use_proxy = use_connect_proxy(client);
 
 	if (use_proxy) {
 		if (!client->proxy_connected || !client->keepalive ||
@@ -1019,7 +1048,7 @@ static int http_client_connect(
 			goto on_error;
 	}
 
-	git_trace(GIT_TRACE_DEBUG, "Connecting to remote %s:%s",
+	git_trace(GIT_TRACE_DEBUG, "Connecting to remote %s port %s",
 	          client->server.url.host, client->server.url.port);
 
 	if ((error = server_connect(client)) < 0)
@@ -1038,6 +1067,7 @@ on_error:
 
 GIT_INLINE(int) client_read(git_http_client *client)
 {
+	http_parser_context *parser_context = client->parser.data;
 	git_stream *stream;
 	char *buf = client->read_buf.ptr + client->read_buf.size;
 	size_t max_len;
@@ -1054,6 +1084,9 @@ GIT_INLINE(int) client_read(git_http_client *client)
 	max_len = client->read_buf.asize - client->read_buf.size;
 	max_len = min(max_len, INT_MAX);
 
+	if (parser_context->output_size)
+		max_len = min(max_len, parser_context->output_size);
+
 	if (max_len == 0) {
 		git_error_set(GIT_ERROR_HTTP, "no room in output buffer");
 		return -1;
@@ -1116,11 +1149,6 @@ GIT_INLINE(int) client_read_and_parse(git_http_client *client)
 		return -1;
 	}
 
-	if (parser->upgrade) {
-		git_error_set(GIT_ERROR_HTTP, "server requested upgrade");
-		return -1;
-	}
-
 	if (ctx->parse_status == PARSE_STATUS_ERROR) {
 		client->connected = 0;
 		return ctx->error ? ctx->error : -1;
@@ -1139,7 +1167,7 @@ GIT_INLINE(int) client_read_and_parse(git_http_client *client)
 		 * final byte when paused in a callback.  Consume that byte.
 		 * https://github.com/nodejs/http-parser/issues/97
 		 */
-		assert(client->read_buf.size > parsed_len);
+		GIT_ASSERT(client->read_buf.size > parsed_len);
 
 		http_parser_pause(parser, 0);
 
@@ -1191,7 +1219,7 @@ static void complete_response_body(git_http_client *client)
 	/* If we're not keeping alive, don't bother. */
 	if (!client->keepalive) {
 		client->connected = 0;
-		return;
+		goto done;
 	}
 
 	parser_context.client = client;
@@ -1205,6 +1233,9 @@ static void complete_response_body(git_http_client *client)
 		git_error_clear();
 		client->connected = 0;
 	}
+
+done:
+	git_buf_clear(&client->read_buf);
 }
 
 int git_http_client_send_request(
@@ -1214,7 +1245,8 @@ int git_http_client_send_request(
 	git_http_response response = {0};
 	int error = -1;
 
-	assert(client && request);
+	GIT_ASSERT_ARG(client);
+	GIT_ASSERT_ARG(request);
 
 	/* If the client did not finish reading, clean up the stream. */
 	if (client->state == READING_BODY)
@@ -1285,7 +1317,7 @@ int git_http_client_send_body(
 	git_buf hdr = GIT_BUF_INIT;
 	int error;
 
-	assert(client);
+	GIT_ASSERT_ARG(client);
 
 	/* If we're waiting for proxy auth, don't sending more requests. */
 	if (client->state == HAS_EARLY_RESPONSE)
@@ -1302,7 +1334,7 @@ int git_http_client_send_body(
 	server = &client->server;
 
 	if (client->request_body_len) {
-		assert(buffer_len <= client->request_body_remain);
+		GIT_ASSERT(buffer_len <= client->request_body_remain);
 
 		if ((error = stream_write(server, buffer, buffer_len)) < 0)
 			goto done;
@@ -1325,7 +1357,8 @@ static int complete_request(git_http_client *client)
 {
 	int error = 0;
 
-	assert(client && client->state == SENDING_BODY);
+	GIT_ASSERT_ARG(client);
+	GIT_ASSERT(client->state == SENDING_BODY);
 
 	if (client->request_body_len && client->request_body_remain) {
 		git_error_set(GIT_ERROR_HTTP, "truncated write");
@@ -1345,7 +1378,8 @@ int git_http_client_read_response(
 	http_parser_context parser_context = {0};
 	int error;
 
-	assert(response && client);
+	GIT_ASSERT_ARG(response);
+	GIT_ASSERT_ARG(client);
 
 	if (client->state == SENDING_BODY) {
 		if ((error = complete_request(client)) < 0)
@@ -1367,8 +1401,11 @@ int git_http_client_read_response(
 
 	git_http_response_dispose(response);
 
-	git_vector_free_deep(&client->server.auth_challenges);
-	git_vector_free_deep(&client->proxy.auth_challenges);
+	if (client->current_server == PROXY) {
+		git_vector_free_deep(&client->proxy.auth_challenges);
+	} else if(client->current_server == SERVER) {
+		git_vector_free_deep(&client->server.auth_challenges);
+	}
 
 	client->state = READING_RESPONSE;
 	client->keepalive = 0;
@@ -1382,7 +1419,7 @@ int git_http_client_read_response(
 			goto done;
 	}
 
-	assert(client->state == READING_BODY || client->state == DONE);
+	GIT_ASSERT(client->state == READING_BODY || client->state == DONE);
 
 done:
 	git_buf_dispose(&parser_context.parse_header_name);
@@ -1419,18 +1456,23 @@ int git_http_client_read_body(
 	client->parser.data = &parser_context;
 
 	/*
-	 * Clients expect to get a non-zero amount of data from us.
-	 * With a sufficiently small buffer, one might only read a chunk
-	 * length.  Loop until we actually have data to return.
+	 * Clients expect to get a non-zero amount of data from us,
+	 * so we either block until we have data to return, until we
+	 * hit EOF or there's an error.  Do this in a loop, since we
+	 * may end up reading only some stream metadata (like chunk
+	 * information).
 	 */
 	while (!parser_context.output_written) {
 		error = client_read_and_parse(client);
 
 		if (error <= 0)
 			goto done;
+
+		if (client->state == DONE)
+			break;
 	}
 
-	assert(parser_context.output_written <= INT_MAX);
+	GIT_ASSERT(parser_context.output_written <= INT_MAX);
 	error = (int)parser_context.output_written;
 
 done:
@@ -1466,7 +1508,7 @@ int git_http_client_skip_body(git_http_client *client)
 			              "unexpected data handled in callback");
 			error = -1;
 		}
-	} while (!error);
+	} while (error >= 0 && client->state != DONE);
 
 	if (error < 0)
 		client->connected = 0;
@@ -1484,7 +1526,7 @@ int git_http_client_new(
 {
 	git_http_client *client;
 
-	assert(out);
+	GIT_ASSERT_ARG(out);
 
 	client = git__calloc(1, sizeof(git_http_client));
 	GIT_ERROR_CHECK_ALLOC(client);