rugged 0.17.0.b7 → 0.18.0.b1

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

@@ -1,31 +1,35 @@
 /*
- * Copyright (C) 2009-2012 the libgit2 contributors
+ * 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 <stdlib.h>
+#ifndef GIT_WINHTTP
+
 #include "git2.h"
 #include "http_parser.h"
-
-#include "transport.h"
-#include "common.h"
-#include "netops.h"
 #include "buffer.h"
-#include "pkt.h"
-#include "refs.h"
-#include "pack.h"
-#include "fetch.h"
-#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)
+#include "netops.h"
+#include "smart.h"
+
+static const char *prefix_http = "http://";
+static const char *prefix_https = "https://";
+static const char *upload_pack_service = "upload-pack";
+static const char *upload_pack_ls_service_url = "/info/refs?service=git-upload-pack";
+static const char *upload_pack_service_url = "/git-upload-pack";
+static const char *receive_pack_service = "receive-pack";
+static const char *receive_pack_ls_service_url = "/info/refs?service=git-receive-pack";
+static const char *receive_pack_service_url = "/git-receive-pack";
+static const char *get_verb = "GET";
+static const char *post_verb = "POST";
+static const char *basic_authtype = "Basic";
+
+#define OWNING_SUBTRANSPORT(s) ((http_subtransport *)(s)->parent.subtransport)
+
+#define PARSE_ERROR_GENERIC	-1
+#define PARSE_ERROR_REPLAY	-2
+
+#define CHUNK_SIZE	4096
 
 enum last_cb {
 	NONE,
@@ -33,53 +37,132 @@ enum last_cb {
 	VALUE
 };
 
+typedef enum {
+	GIT_HTTP_AUTH_BASIC = 1,
+} http_authmechanism_t;
+
 typedef struct {
-	git_transport parent;
-	http_parser_settings settings;
-	git_buf buf;
-	int error;
-	int transfer_finished :1,
-		ct_found :1,
-		ct_finished :1,
-		pack_ready :1;
-	enum last_cb last_cb;
-	http_parser parser;
-	char *content_type;
-	char *path;
+	git_smart_subtransport_stream parent;
+	const char *service;
+	const char *service_url;
+	char *redirect_url;
+	const char *verb;
+	char *chunk_buffer;
+	unsigned chunk_buffer_len;
+	unsigned sent_request : 1,
+		received_response : 1,
+		chunked : 1,
+		redirect_count : 3;
+} http_stream;
+
+typedef struct {
+	git_smart_subtransport parent;
+	transport_smart *owner;
+	gitno_socket socket;
+	const char *path;
 	char *host;
 	char *port;
-	char *service;
-	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,
-                       const char *service, ssize_t content_length, int ls)
+	char *user_from_url;
+	char *pass_from_url;
+	git_cred *cred;
+	git_cred *url_cred;
+	http_authmechanism_t auth_mechanism;
+	unsigned connected : 1,
+		use_ssl : 1;
+
+	/* Parser structures */
+	http_parser parser;
+	http_parser_settings settings;
+	gitno_buffer parse_buffer;
+	git_buf parse_header_name;
+	git_buf parse_header_value;
+	char parse_buffer_data[2048];
+	char *content_type;
+	char *location;
+	git_vector www_authenticate;
+	enum last_cb last_cb;
+	int parse_error;
+	unsigned parse_finished : 1;
+} http_subtransport;
+
+typedef struct {
+	http_stream *s;
+	http_subtransport *t;
+
+	/* Target buffer details from read() */
+	char *buffer;
+	size_t buf_size;
+	size_t *bytes_read;
+} parser_context;
+
+static int apply_basic_credential(git_buf *buf, git_cred *cred)
 {
-	if (path == NULL) /* Is 'git fetch http://host.com/' valid? */
-		path = "/";
+	git_cred_userpass_plaintext *c = (git_cred_userpass_plaintext *)cred;
+	git_buf raw = GIT_BUF_INIT;
+	int error = -1;
+
+	git_buf_printf(&raw, "%s:%s", c->username, c->password);
+
+	if (git_buf_oom(&raw) ||
+		git_buf_puts(buf, "Authorization: Basic ") < 0 ||
+		git_buf_put_base64(buf, git_buf_cstr(&raw), raw.size) < 0 ||
+		git_buf_puts(buf, "\r\n") < 0)
+		goto on_error;
+
+	error = 0;
+
+on_error:
+	if (raw.size)
+		memset(raw.ptr, 0x0, raw.size);
+
+	git_buf_free(&raw);
+	return error;
+}
+
+static int gen_request(
+	git_buf *buf,
+	http_stream *s,
+	size_t content_length)
+{
+	http_subtransport *t = OWNING_SUBTRANSPORT(s);
+
+	if (!t->path)
+		t->path = "/";
+
+	/* If we were redirected, make sure to respect that here */
+	if (s->redirect_url)
+		git_buf_printf(buf, "%s %s HTTP/1.1\r\n", s->verb, s->redirect_url);
+	else
+		git_buf_printf(buf, "%s %s%s HTTP/1.1\r\n", s->verb, t->path, s->service_url);
 
-	if (ls) {
-		git_buf_printf(buf, "%s %s/info/refs?service=git-%s HTTP/1.1\r\n", op, path, service);
-	} else {
-		git_buf_printf(buf, "%s %s/git-%s HTTP/1.1\r\n", op, path, service);
-	}
 	git_buf_puts(buf, "User-Agent: git/1.0 (libgit2 " LIBGIT2_VERSION ")\r\n");
-	git_buf_printf(buf, "Host: %s\r\n", host);
-	if (content_length > 0) {
-		git_buf_printf(buf, "Accept: application/x-git-%s-result\r\n", service);
-		git_buf_printf(buf, "Content-Type: application/x-git-%s-request\r\n", service);
-		git_buf_printf(buf, "Content-Length: %"PRIuZ "\r\n", content_length);
-	} else {
+	git_buf_printf(buf, "Host: %s\r\n", t->host);
+
+	if (s->chunked || content_length > 0) {
+		git_buf_printf(buf, "Accept: application/x-git-%s-result\r\n", s->service);
+		git_buf_printf(buf, "Content-Type: application/x-git-%s-request\r\n", s->service);
+
+		if (s->chunked)
+			git_buf_puts(buf, "Transfer-Encoding: chunked\r\n");
+		else
+			git_buf_printf(buf, "Content-Length: %"PRIuZ "\r\n", content_length);
+	} else
 		git_buf_puts(buf, "Accept: */*\r\n");
+
+	/* Apply credentials to the request */
+	if (t->cred && t->cred->credtype == GIT_CREDTYPE_USERPASS_PLAINTEXT &&
+		t->auth_mechanism == GIT_HTTP_AUTH_BASIC &&
+		apply_basic_credential(buf, t->cred) < 0)
+		return -1;
+
+	/* Use url-parsed basic auth if username and password are both provided */
+	if (!t->cred && t->user_from_url && t->pass_from_url) {
+		if (!t->url_cred &&
+			 git_cred_userpass_plaintext_new(&t->url_cred, t->user_from_url, t->pass_from_url) < 0)
+			return -1;
+		if (apply_basic_credential(buf, t->url_cred) < 0) return -1;
 	}
+
 	git_buf_puts(buf, "\r\n");
 
 	if (git_buf_oom(buf))
@@ -88,538 +171,783 @@ static int gen_request(git_buf *buf, const char *path, const char *host, const c
 	return 0;
 }
 
-static int send_request(transport_http *t, const char *service, void *data, ssize_t content_length, int ls)
+static int parse_unauthorized_response(
+	git_vector *www_authenticate,
+	int *allowed_types,
+	http_authmechanism_t *auth_mechanism)
 {
-#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;
+	unsigned i;
+	char *entry;
+
+	git_vector_foreach(www_authenticate, i, entry) {
+		if (!strncmp(entry, basic_authtype, 5) &&
+			(entry[5] == '\0' || entry[5] == ' ')) {
+			*allowed_types |= GIT_CREDTYPE_USERPASS_PLAINTEXT;
+			*auth_mechanism = GIT_HTTP_AUTH_BASIC;
+		}
 	}
 
+	return 0;
+}
 
-	if (gitno_send((git_transport *) t, request.ptr, request.size, 0) < 0)
-		goto cleanup;
+static int on_header_ready(http_subtransport *t)
+{
+	git_buf *name = &t->parse_header_name;
+	git_buf *value = &t->parse_header_value;
 
-	if (content_length) {
-		if (gitno_send((git_transport *) t, data, content_length, 0) < 0)
-			goto cleanup;
+	if (!strcasecmp("Content-Type", git_buf_cstr(name))) {
+		if (!t->content_type) {
+			t->content_type = git__strdup(git_buf_cstr(value));
+			GITERR_CHECK_ALLOC(t->content_type);
+		}
 	}
+	else if (!strcmp("WWW-Authenticate", git_buf_cstr(name))) {
+		char *dup = git__strdup(git_buf_cstr(value));
+		GITERR_CHECK_ALLOC(dup);
 
-	error = 0;
+		git_vector_insert(&t->www_authenticate, dup);
+	}
+	else if (!strcasecmp("Location", git_buf_cstr(name))) {
+		if (!t->location) {
+			t->location= git__strdup(git_buf_cstr(value));
+			GITERR_CHECK_ALLOC(t->location);
+		}
+	}
 
-cleanup:
-	git_buf_free(&request);
-	return error;
+	return 0;
+}
+
+static int on_header_field(http_parser *parser, const char *str, size_t len)
+{
+	parser_context *ctx = (parser_context *) parser->data;
+	http_subtransport *t = ctx->t;
+
+	/* Both parse_header_name and parse_header_value are populated
+	 * and ready for consumption */
+	if (VALUE == t->last_cb)
+		if (on_header_ready(t) < 0)
+			return t->parse_error = PARSE_ERROR_GENERIC;
+
+	if (NONE == t->last_cb || VALUE == t->last_cb)
+		git_buf_clear(&t->parse_header_name);
+
+	if (git_buf_put(&t->parse_header_name, str, len) < 0)
+		return t->parse_error = PARSE_ERROR_GENERIC;
+
+	t->last_cb = FIELD;
+	return 0;
+}
+
+static int on_header_value(http_parser *parser, const char *str, size_t len)
+{
+	parser_context *ctx = (parser_context *) parser->data;
+	http_subtransport *t = ctx->t;
 
-#else
-	wchar_t *verb;
-	wchar_t url[GIT_WIN_PATH], ct[GIT_WIN_PATH];
+	assert(NONE != t->last_cb);
+
+	if (FIELD == t->last_cb)
+		git_buf_clear(&t->parse_header_value);
+
+	if (git_buf_put(&t->parse_header_value, str, len) < 0)
+		return t->parse_error = PARSE_ERROR_GENERIC;
+
+	t->last_cb = VALUE;
+	return 0;
+}
+
+static int on_headers_complete(http_parser *parser)
+{
+	parser_context *ctx = (parser_context *) parser->data;
+	http_subtransport *t = ctx->t;
+	http_stream *s = ctx->s;
 	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;
+	/* Both parse_header_name and parse_header_value are populated
+	 * and ready for consumption. */
+	if (VALUE == t->last_cb)
+		if (on_header_ready(t) < 0)
+			return t->parse_error = PARSE_ERROR_GENERIC;
 
-	git__utf8_to_16(url, GIT_WIN_PATH, git_buf_cstr(&buf));
+	/* Check for an authentication failure. */
+	if (parser->status_code == 401 &&
+		get_verb == s->verb &&
+		t->owner->cred_acquire_cb) {
+		int allowed_types = 0;
 
-	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;
-	}
+		if (parse_unauthorized_response(&t->www_authenticate,
+			&allowed_types, &t->auth_mechanism) < 0)
+			return t->parse_error = PARSE_ERROR_GENERIC;
 
-	git_buf_clear(&buf);
-	if (git_buf_printf(&buf, "Content-Type: application/x-git-%s-request", service) < 0)
-		goto on_error;
+		if (allowed_types &&
+			(!t->cred || 0 == (t->cred->credtype & allowed_types))) {
 
-	git__utf8_to_16(ct, GIT_WIN_PATH, git_buf_cstr(&buf));
+			if (t->owner->cred_acquire_cb(&t->cred,
+					t->owner->url,
+					t->user_from_url,
+					allowed_types,
+					t->owner->cred_acquire_payload) < 0)
+				return PARSE_ERROR_GENERIC;
 
-	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;
+			assert(t->cred);
+
+			/* Successfully acquired a credential. */
+			return t->parse_error = PARSE_ERROR_REPLAY;
+		}
 	}
 
-	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;
+	/* Check for a redirect.
+	 * Right now we only permit a redirect to the same hostname. */
+	if ((parser->status_code == 301 ||
+		 parser->status_code == 302 ||
+		 (parser->status_code == 303 && get_verb == s->verb) ||
+		 parser->status_code == 307) &&
+		t->location) {
+
+		if (s->redirect_count >= 7) {
+			giterr_set(GITERR_NET, "Too many redirects");
+			return t->parse_error = PARSE_ERROR_GENERIC;
+		}
+
+		if (t->location[0] != '/') {
+			giterr_set(GITERR_NET, "Only relative redirects are supported");
+			return t->parse_error = PARSE_ERROR_GENERIC;
 		}
+
+		/* Set the redirect URL on the stream. This is a transfer of
+		 * ownership of the memory. */
+		if (s->redirect_url)
+			git__free(s->redirect_url);
+
+		s->redirect_url = t->location;
+		t->location = NULL;
+
+		t->connected = 0;
+		s->redirect_count++;
+
+		return t->parse_error = PARSE_ERROR_REPLAY;
 	}
 
-	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;
+	/* Check for a 200 HTTP status code. */
+	if (parser->status_code != 200) {
+		giterr_set(GITERR_NET,
+			"Unexpected HTTP status code: %d",
+			parser->status_code);
+		return t->parse_error = PARSE_ERROR_GENERIC;
 	}
 
-	ret = WinHttpReceiveResponse(t->request, NULL);
-	if (ret == FALSE) {
-		giterr_set(GITERR_OS, "Failed to receive response");
-		goto on_error;
+	/* The response must contain a Content-Type header. */
+	if (!t->content_type) {
+		giterr_set(GITERR_NET, "No Content-Type header in response");
+		return t->parse_error = PARSE_ERROR_GENERIC;
 	}
 
-	return 0;
+	/* The Content-Type header must match our expectation. */
+	if (get_verb == s->verb)
+		git_buf_printf(&buf,
+			"application/x-git-%s-advertisement",
+			ctx->s->service);
+	else
+		git_buf_printf(&buf,
+			"application/x-git-%s-result",
+			ctx->s->service);
+
+	if (git_buf_oom(&buf))
+		return t->parse_error = PARSE_ERROR_GENERIC;
+
+	if (strcmp(t->content_type, git_buf_cstr(&buf))) {
+		git_buf_free(&buf);
+		giterr_set(GITERR_NET,
+			"Invalid Content-Type: %s",
+			t->content_type);
+		return t->parse_error = PARSE_ERROR_GENERIC;
+	}
 
-on_error:
 	git_buf_free(&buf);
-	if (t->request)
-		WinHttpCloseHandle(t->request);
-	t->request = NULL;
-	return -1;
-#endif
+
+	return 0;
 }
 
-static int do_connect(transport_http *t)
+static int on_message_complete(http_parser *parser)
 {
-#ifndef GIT_WINHTTP
-	if (t->parent.connected && http_should_keep_alive(&t->parser))
-		return 0;
+	parser_context *ctx = (parser_context *) parser->data;
+	http_subtransport *t = ctx->t;
 
-	if (gitno_connect((git_transport *) t, t->host, t->port) < 0)
-		return -1;
-
-	t->parent.connected = 1;
+	t->parse_finished = 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);
+static int on_body_fill_buffer(http_parser *parser, const char *str, size_t len)
+{
+	parser_context *ctx = (parser_context *) parser->data;
+	http_subtransport *t = ctx->t;
 
-	if (t->session == NULL) {
-		giterr_set(GITERR_OS, "Failed to init WinHTTP");
-		goto on_error;
+	if (ctx->buf_size < len) {
+		giterr_set(GITERR_NET, "Can't fit data in the buffer");
+		return t->parse_error = PARSE_ERROR_GENERIC;
 	}
 
-	git__utf8_to_16(host, GIT_WIN_PATH, t->host);
+	memcpy(ctx->buffer, str, len);
+	*(ctx->bytes_read) += len;
+	ctx->buffer += len;
+	ctx->buf_size -= len;
 
-	if (git__strtol32(&port, t->port, NULL, 10) < 0)
-		goto on_error;
+	return 0;
+}
 
-	t->connection = WinHttpConnect(t->session, host, port, 0);
-	if (t->connection == NULL) {
-		giterr_set(GITERR_OS, "Failed to connect to host");
-		goto on_error;
-	}
+static void clear_parser_state(http_subtransport *t)
+{
+	unsigned i;
+	char *entry;
 
-	t->parent.connected = 1;
-	return 0;
+	http_parser_init(&t->parser, HTTP_RESPONSE);
+	gitno_buffer_setup(&t->socket,
+		&t->parse_buffer,
+		t->parse_buffer_data,
+		sizeof(t->parse_buffer_data));
 
-on_error:
-	if (t->session) {
-		WinHttpCloseHandle(t->session);
-		t->session = NULL;
-	}
-	return -1;
-#endif
-}
+	t->last_cb = NONE;
+	t->parse_error = 0;
+	t->parse_finished = 0;
 
-/*
- * The HTTP parser is streaming, so we need to wait until we're in the
- * field handler before we can be sure that we can store the previous
- * value. Right now, we only care about the
- * Content-Type. on_header_{field,value} should be kept generic enough
- * to work for any request.
- */
+	git_buf_free(&t->parse_header_name);
+	git_buf_init(&t->parse_header_name, 0);
 
-static const char *typestr = "Content-Type";
+	git_buf_free(&t->parse_header_value);
+	git_buf_init(&t->parse_header_value, 0);
 
-static int on_header_field(http_parser *parser, const char *str, size_t len)
+	git__free(t->content_type);
+	t->content_type = NULL;
+
+	git__free(t->location);
+	t->location = NULL;
+
+	git_vector_foreach(&t->www_authenticate, i, entry)
+		git__free(entry);
+
+	git_vector_free(&t->www_authenticate);
+}
+
+static int write_chunk(gitno_socket *socket, const char *buffer, size_t len)
 {
-	transport_http *t = (transport_http *) parser->data;
-	git_buf *buf = &t->buf;
-
-	if (t->last_cb == VALUE && t->ct_found) {
-		t->ct_finished = 1;
-		t->ct_found = 0;
-		t->content_type = git__strdup(git_buf_cstr(buf));
-		GITERR_CHECK_ALLOC(t->content_type);
-		git_buf_clear(buf);
-	}
+	git_buf buf = GIT_BUF_INIT;
 
-	if (t->ct_found) {
-		t->last_cb = FIELD;
-		return 0;
+	/* Chunk header */
+	git_buf_printf(&buf, "%X\r\n", (unsigned)len);
+
+	if (git_buf_oom(&buf))
+		return -1;
+
+	if (gitno_send(socket, buf.ptr, buf.size, 0) < 0) {
+		git_buf_free(&buf);
+		return -1;
 	}
 
-	if (t->last_cb != FIELD)
-		git_buf_clear(buf);
+	git_buf_free(&buf);
 
-	git_buf_put(buf, str, len);
-	t->last_cb = FIELD;
+	/* Chunk body */
+	if (len > 0 && gitno_send(socket, buffer, len, 0) < 0)
+		return -1;
 
-	return git_buf_oom(buf);
+	/* Chunk footer */
+	if (gitno_send(socket, "\r\n", 2, 0) < 0)
+		return -1;
+
+	return 0;
 }
 
-static int on_header_value(http_parser *parser, const char *str, size_t len)
+static int http_connect(http_subtransport *t)
 {
-	transport_http *t = (transport_http *) parser->data;
-	git_buf *buf = &t->buf;
+	int flags = 0;
 
-	if (t->ct_finished) {
-		t->last_cb = VALUE;
+	if (t->connected &&
+		http_should_keep_alive(&t->parser) &&
+		http_body_is_final(&t->parser))
 		return 0;
-	}
 
-	if (t->last_cb == VALUE)
-		git_buf_put(buf, str, len);
+	if (t->socket.socket)
+		gitno_close(&t->socket);
+
+	if (t->use_ssl) {
+		int tflags;
 
-	if (t->last_cb == FIELD && !strcmp(git_buf_cstr(buf), typestr)) {
-		t->ct_found = 1;
-		git_buf_clear(buf);
-		git_buf_put(buf, str, len);
+		if (t->owner->parent.read_flags(&t->owner->parent, &tflags) < 0)
+			return -1;
+
+		flags |= GITNO_CONNECT_SSL;
+
+		if (GIT_TRANSPORTFLAGS_NO_CHECK_CERT & tflags)
+			flags |= GITNO_CONNECT_SSL_NO_CHECK_CERT;
 	}
 
-	t->last_cb = VALUE;
+	if (gitno_connect(&t->socket, t->host, t->port, flags) < 0)
+		return -1;
 
-	return git_buf_oom(buf);
+	t->connected = 1;
+	return 0;
 }
 
-static int on_headers_complete(http_parser *parser)
+static int http_stream_read(
+	git_smart_subtransport_stream *stream,
+	char *buffer,
+	size_t buf_size,
+	size_t *bytes_read)
 {
-	transport_http *t = (transport_http *) parser->data;
-	git_buf *buf = &t->buf;
+	http_stream *s = (http_stream *)stream;
+	http_subtransport *t = OWNING_SUBTRANSPORT(s);
+	parser_context ctx;
+	size_t bytes_parsed;
 
-	/* The content-type is text/plain for 404, so don't validate */
-	if (parser->status_code == 404) {
-		git_buf_clear(buf);
-		return 0;
+replay:
+	*bytes_read = 0;
+
+	assert(t->connected);
+
+	if (!s->sent_request) {
+		git_buf request = GIT_BUF_INIT;
+
+		clear_parser_state(t);
+
+		if (gen_request(&request, s, 0) < 0) {
+			giterr_set(GITERR_NET, "Failed to generate request");
+			return -1;
+		}
+
+		if (gitno_send(&t->socket, request.ptr, request.size, 0) < 0) {
+			git_buf_free(&request);
+			return -1;
+		}
+
+		git_buf_free(&request);
+
+		s->sent_request = 1;
 	}
 
-	if (t->content_type == NULL) {
-		t->content_type = git__strdup(git_buf_cstr(buf));
-		if (t->content_type == NULL)
-			return t->error = -1;
+	if (!s->received_response) {
+		if (s->chunked) {
+			assert(s->verb == post_verb);
+
+			/* Flush, if necessary */
+			if (s->chunk_buffer_len > 0 &&
+				write_chunk(&t->socket, s->chunk_buffer, s->chunk_buffer_len) < 0)
+				return -1;
+
+			s->chunk_buffer_len = 0;
+
+			/* Write the final chunk. */
+			if (gitno_send(&t->socket, "0\r\n\r\n", 5, 0) < 0)
+				return -1;
+		}
+
+		s->received_response = 1;
 	}
 
-	git_buf_clear(buf);
-	git_buf_printf(buf, "application/x-git-%s-advertisement", t->service);
-	if (git_buf_oom(buf))
-		return t->error = -1;
+	while (!*bytes_read && !t->parse_finished) {
+		t->parse_buffer.offset = 0;
 
-	if (strcmp(t->content_type, git_buf_cstr(buf)))
-		return t->error = -1;
+		if (gitno_recv(&t->parse_buffer) < 0)
+			return -1;
 
-	git_buf_clear(buf);
-	return 0;
-}
+		/* This call to http_parser_execute will result in invocations of the
+		 * on_* family of callbacks. The most interesting of these is
+		 * on_body_fill_buffer, which is called when data is ready to be copied
+		 * into the target buffer. We need to marshal the buffer, buf_size, and
+		 * bytes_read parameters to this callback. */
+		ctx.t = t;
+		ctx.s = s;
+		ctx.buffer = buffer;
+		ctx.buf_size = buf_size;
+		ctx.bytes_read = bytes_read;
 
-static int on_message_complete(http_parser *parser)
-{
-	transport_http *t = (transport_http *) parser->data;
+		/* Set the context, call the parser, then unset the context. */
+		t->parser.data = &ctx;
+
+		bytes_parsed = http_parser_execute(&t->parser,
+			&t->settings,
+			t->parse_buffer.data,
+			t->parse_buffer.offset);
+
+		t->parser.data = NULL;
+
+		/* If there was a handled authentication failure, then parse_error
+		 * will have signaled us that we should replay the request. */
+		if (PARSE_ERROR_REPLAY == t->parse_error) {
+			s->sent_request = 0;
+
+			if (http_connect(t) < 0)
+				return -1;
 
-	t->transfer_finished = 1;
+			goto replay;
+		}
+
+		if (t->parse_error < 0)
+			return -1;
 
-	if (parser->status_code == 404) {
-		giterr_set(GITERR_NET, "Remote error: %s", git_buf_cstr(&t->buf));
-		t->error = -1;
+		if (bytes_parsed != t->parse_buffer.offset) {
+			giterr_set(GITERR_NET,
+				"HTTP parser error: %s",
+				http_errno_description((enum http_errno)t->parser.http_errno));
+			return -1;
+		}
 	}
 
 	return 0;
 }
 
-static int on_body_fill_buffer(http_parser *parser, const char *str, size_t len)
+static int http_stream_write_chunked(
+	git_smart_subtransport_stream *stream,
+	const char *buffer,
+	size_t len)
 {
-	git_transport *transport = (git_transport *) parser->data;
-	transport_http *t = (transport_http *) parser->data;
-	gitno_buffer *buf = &transport->buffer;
+	http_stream *s = (http_stream *)stream;
+	http_subtransport *t = OWNING_SUBTRANSPORT(s);
 
-	if (buf->len - buf->offset < len) {
-		giterr_set(GITERR_NET, "Can't fit data in the buffer");
-		return t->error = -1;
+	assert(t->connected);
+
+	/* Send the request, if necessary */
+	if (!s->sent_request) {
+		git_buf request = GIT_BUF_INIT;
+
+		clear_parser_state(t);
+
+		if (gen_request(&request, s, 0) < 0) {
+			giterr_set(GITERR_NET, "Failed to generate request");
+			return -1;
+		}
+
+		if (gitno_send(&t->socket, request.ptr, request.size, 0) < 0) {
+			git_buf_free(&request);
+			return -1;
+		}
+
+		git_buf_free(&request);
+
+		s->sent_request = 1;
+	}
+
+	if (len > CHUNK_SIZE) {
+		/* Flush, if necessary */
+		if (s->chunk_buffer_len > 0) {
+			if (write_chunk(&t->socket, s->chunk_buffer, s->chunk_buffer_len) < 0)
+				return -1;
+
+			s->chunk_buffer_len = 0;
+		}
+
+		/* Write chunk directly */
+		if (write_chunk(&t->socket, buffer, len) < 0)
+			return -1;
 	}
+	else {
+		/* Append as much to the buffer as we can */
+		int count = min(CHUNK_SIZE - s->chunk_buffer_len, len);
+
+		if (!s->chunk_buffer)
+			s->chunk_buffer = git__malloc(CHUNK_SIZE);
+
+		memcpy(s->chunk_buffer + s->chunk_buffer_len, buffer, count);
+		s->chunk_buffer_len += count;
+		buffer += count;
+		len -= count;
 
-	memcpy(buf->data + buf->offset, str, len);
-	buf->offset += len;
+		/* Is the buffer full? If so, then flush */
+		if (CHUNK_SIZE == s->chunk_buffer_len) {
+			if (write_chunk(&t->socket, s->chunk_buffer, s->chunk_buffer_len) < 0)
+				return -1;
+
+			s->chunk_buffer_len = 0;
+
+			if (len > 0) {
+				memcpy(s->chunk_buffer, buffer, len);
+				s->chunk_buffer_len = len;
+			}
+		}
+	}
 
 	return 0;
 }
 
-static int http_recv_cb(gitno_buffer *buf)
+static int http_stream_write_single(
+	git_smart_subtransport_stream *stream,
+	const char *buffer,
+	size_t len)
 {
-	git_transport *transport = (git_transport *) buf->cb_data;
-	transport_http *t = (transport_http *) transport;
-	size_t old_len;
-	char buffer[2048];
-#ifdef GIT_WINHTTP
-	DWORD recvd;
-#else
-	gitno_buffer inner;
-	int error;
-#endif
-
-	if (t->transfer_finished)
-		return 0;
+	http_stream *s = (http_stream *)stream;
+	http_subtransport *t = OWNING_SUBTRANSPORT(s);
+	git_buf request = GIT_BUF_INIT;
 
-#ifndef GIT_WINHTTP
-	gitno_buffer_setup(transport, &inner, buffer, sizeof(buffer));
+	assert(t->connected);
 
-	if ((error = gitno_recv(&inner)) < 0)
+	if (s->sent_request) {
+		giterr_set(GITERR_NET, "Subtransport configured for only one write");
 		return -1;
-
-	old_len = buf->offset;
-	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;
+	clear_parser_state(t);
+
+	if (gen_request(&request, s, len) < 0) {
+		giterr_set(GITERR_NET, "Failed to generate request");
+		return -1;
 	}
 
-	memcpy(buf->data + buf->offset, buffer, recvd);
-	buf->offset += recvd;
-#endif
+	if (gitno_send(&t->socket, request.ptr, request.size, 0) < 0)
+		goto on_error;
+
+	if (len && gitno_send(&t->socket, buffer, len, 0) < 0)
+		goto on_error;
+
+	git_buf_free(&request);
+	s->sent_request = 1;
 
-	return (int)(buf->offset - old_len);
+	return 0;
+
+on_error:
+	git_buf_free(&request);
+	return -1;
 }
 
-/* Set up the gitno_buffer so calling gitno_recv() grabs data from the HTTP response */
-static void setup_gitno_buffer(git_transport *transport)
+static void http_stream_free(git_smart_subtransport_stream *stream)
 {
-	transport_http *t = (transport_http *) transport;
+	http_stream *s = (http_stream *)stream;
 
-	/* 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;
-	memset(&t->settings, 0x0, sizeof(http_parser_settings));
-	t->settings.on_header_field = on_header_field;
-	t->settings.on_header_value = on_header_value;
-	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
+	if (s->chunk_buffer)
+		git__free(s->chunk_buffer);
+
+	if (s->redirect_url)
+		git__free(s->redirect_url);
 
-	gitno_buffer_setup_callback(transport, &transport->buffer, t->buffer, sizeof(t->buffer), http_recv_cb, t);
+	git__free(s);
 }
 
-static int http_connect(git_transport *transport, int direction)
+static int http_stream_alloc(http_subtransport *t,
+	git_smart_subtransport_stream **stream)
 {
-	transport_http *t = (transport_http *) transport;
-	int ret;
-	git_buf request = GIT_BUF_INIT;
-	const char *service = "upload-pack";
-	const char *url = t->parent.url, *prefix_http = "http://", *prefix_https = "https://";
-	const char *default_port;
-	git_pkt *pkt;
+	http_stream *s;
 
-	if (direction == GIT_DIR_PUSH) {
-		giterr_set(GITERR_NET, "Pushing over HTTP is not implemented");
+	if (!stream)
 		return -1;
-	}
 
-	t->parent.direction = direction;
+	s = git__calloc(sizeof(http_stream), 1);
+	GITERR_CHECK_ALLOC(s);
 
-	if (!git__prefixcmp(url, prefix_http)) {
-		url = t->parent.url + strlen(prefix_http);
-		default_port = "80";
-	}
+	s->parent.subtransport = &t->parent;
+	s->parent.read = http_stream_read;
+	s->parent.write = http_stream_write_single;
+	s->parent.free = http_stream_free;
 
-	if (!git__prefixcmp(url, prefix_https)) {
-		url += strlen(prefix_https);
-		default_port = "443";
-	}
+	*stream = (git_smart_subtransport_stream *)s;
+	return 0;
+}
 
-	t->path = strchr(url, '/');
+static int http_uploadpack_ls(
+	http_subtransport *t,
+	git_smart_subtransport_stream **stream)
+{
+	http_stream *s;
 
-	if ((ret = gitno_extract_host_and_port(&t->host, &t->port, url, default_port)) < 0)
-		goto cleanup;
+	if (http_stream_alloc(t, stream) < 0)
+		return -1;
 
-	t->service = git__strdup(service);
-	GITERR_CHECK_ALLOC(t->service);
+	s = (http_stream *)*stream;
 
-	if ((ret = do_connect(t)) < 0)
-		goto cleanup;
+	s->service = upload_pack_service;
+	s->service_url = upload_pack_ls_service_url;
+	s->verb = get_verb;
 
-	if ((ret = send_request(t, "upload-pack", NULL, 0, 1)) < 0)
-		goto cleanup;
+	return 0;
+}
 
-	setup_gitno_buffer(transport);
-	if ((ret = git_protocol_store_refs(transport, 2)) < 0)
-		goto cleanup;
+static int http_uploadpack(
+	http_subtransport *t,
+	git_smart_subtransport_stream **stream)
+{
+	http_stream *s;
 
-	pkt = git_vector_get(&transport->refs, 0);
-	if (pkt == NULL || pkt->type != GIT_PKT_COMMENT) {
-		giterr_set(GITERR_NET, "Invalid HTTP response");
-		return t->error = -1;
-	} else {
-		/* Remove the comment pkt from the list */
-		git_vector_remove(&transport->refs, 0);
-		git__free(pkt);
-	}
+	if (http_stream_alloc(t, stream) < 0)
+		return -1;
 
-	if (git_protocol_detect_caps(git_vector_get(&transport->refs, 0), &transport->caps) < 0)
-		return t->error = -1;
+	s = (http_stream *)*stream;
 
-cleanup:
-	git_buf_free(&request);
-	git_buf_clear(&t->buf);
+	s->service = upload_pack_service;
+	s->service_url = upload_pack_service_url;
+	s->verb = post_verb;
 
-	return ret;
+	return 0;
 }
 
-static int http_negotiation_step(struct git_transport *transport, void *data, size_t len)
+static int http_receivepack_ls(
+	http_subtransport *t,
+	git_smart_subtransport_stream **stream)
 {
-	transport_http *t = (transport_http *) transport;
-	int ret;
+	http_stream *s;
 
-	/* First, send the data as a HTTP POST request */
-	if ((ret = do_connect(t)) < 0)
+	if (http_stream_alloc(t, stream) < 0)
 		return -1;
 
-	if (send_request(t, "upload-pack", data, len, 0) < 0)
-		return -1;
+	s = (http_stream *)*stream;
 
-	/* Then we need to set up the buffer to grab data from the HTTP response */
-	setup_gitno_buffer(transport);
+	s->service = receive_pack_service;
+	s->service_url = receive_pack_ls_service_url;
+	s->verb = get_verb;
 
 	return 0;
 }
 
-static int http_close(git_transport *transport)
+static int http_receivepack(
+	http_subtransport *t,
+	git_smart_subtransport_stream **stream)
 {
-#ifndef GIT_WINHTTP
-	if (gitno_ssl_teardown(transport) < 0)
-		return -1;
+	http_stream *s;
 
-	if (gitno_close(transport->socket) < 0) {
-		giterr_set(GITERR_OS, "Failed to close the socket: %s", strerror(errno));
+	if (http_stream_alloc(t, stream) < 0)
 		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
+	s = (http_stream *)*stream;
 
-	transport->connected = 0;
+	/* Use Transfer-Encoding: chunked for this request */
+	s->chunked = 1;
+	s->parent.write = http_stream_write_chunked;
+
+	s->service = receive_pack_service;
+	s->service_url = receive_pack_service_url;
+	s->verb = post_verb;
 
 	return 0;
 }
 
-
-static void http_free(git_transport *transport)
+static int http_action(
+	git_smart_subtransport_stream **stream,
+	git_smart_subtransport *subtransport,
+	const char *url,
+	git_smart_service_t action)
 {
-	transport_http *t = (transport_http *) transport;
-	git_vector *refs = &transport->refs;
-	git_vector *common = &transport->common;
-	unsigned int i;
-	git_pkt *p;
-
-#ifdef GIT_WIN32
-	/* cleanup the WSA context. note that this context
-	 * can be initialized more than once with WSAStartup(),
-	 * and needs to be cleaned one time for each init call
-	 */
-	WSACleanup();
-#endif
-
-	git_vector_foreach(refs, i, p) {
-		git_pkt_free(p);
+	http_subtransport *t = (http_subtransport *)subtransport;
+	const char *default_port = NULL;
+	int ret;
+
+	if (!stream)
+		return -1;
+
+	if (!t->host || !t->port || !t->path) {
+		if (!git__prefixcmp(url, prefix_http)) {
+			url = url + strlen(prefix_http);
+			default_port = "80";
+		}
+
+		if (!git__prefixcmp(url, prefix_https)) {
+			url += strlen(prefix_https);
+			default_port = "443";
+			t->use_ssl = 1;
+		}
+
+		if (!default_port)
+			return -1;
+
+		if ((ret = gitno_extract_url_parts(&t->host, &t->port,
+						&t->user_from_url, &t->pass_from_url, url, default_port)) < 0)
+			return ret;
+
+		t->path = strchr(url, '/');
 	}
-	git_vector_free(refs);
-	git_vector_foreach(common, i, p) {
-		git_pkt_free(p);
+
+	if (http_connect(t) < 0)
+		return -1;
+
+	switch (action)
+	{
+		case GIT_SERVICE_UPLOADPACK_LS:
+			return http_uploadpack_ls(t, stream);
+
+		case GIT_SERVICE_UPLOADPACK:
+			return http_uploadpack(t, stream);
+
+		case GIT_SERVICE_RECEIVEPACK_LS:
+			return http_receivepack_ls(t, stream);
+
+		case GIT_SERVICE_RECEIVEPACK:
+			return http_receivepack(t, stream);
 	}
-	git_vector_free(common);
-	git_buf_free(&t->buf);
-	git__free(t->content_type);
-	git__free(t->host);
-	git__free(t->port);
-	git__free(t->service);
-	git__free(t->parent.url);
-	git__free(t);
+
+	*stream = NULL;
+	return -1;
 }
 
-int git_transport_http(git_transport **out)
+static int http_close(git_smart_subtransport *subtransport)
 {
-	transport_http *t;
+	http_subtransport *t = (http_subtransport *) subtransport;
 
-	t = git__malloc(sizeof(transport_http));
-	GITERR_CHECK_ALLOC(t);
+	clear_parser_state(t);
 
-	memset(t, 0x0, sizeof(transport_http));
+	if (t->socket.socket) {
+		gitno_close(&t->socket);
+		memset(&t->socket, 0x0, sizeof(gitno_socket));
+	}
 
-	t->parent.connect = http_connect;
-	t->parent.negotiation_step = http_negotiation_step;
-	t->parent.close = http_close;
-	t->parent.free = http_free;
-	t->parent.rpc = 1;
+	if (t->cred) {
+		t->cred->free(t->cred);
+		t->cred = NULL;
+	}
 
-	if (git_vector_init(&t->parent.refs, 16, NULL) < 0) {
-		git__free(t);
-		return -1;
+	if (t->url_cred) {
+		t->url_cred->free(t->url_cred);
+		t->url_cred = NULL;
 	}
 
-#ifdef GIT_WIN32
-	/* on win32, the WSA context needs to be initialized
-	 * before any socket calls can be performed */
-	if (WSAStartup(MAKEWORD(2,2), &t->wsd) != 0) {
-		http_free((git_transport *) t);
-		giterr_set(GITERR_OS, "Winsock init failed");
-		return -1;
+	if (t->host) {
+		git__free(t->host);
+		t->host = NULL;
+	}
+
+	if (t->port) {
+		git__free(t->port);
+		t->port = NULL;
+	}
+
+	if (t->user_from_url) {
+		git__free(t->user_from_url);
+		t->user_from_url = NULL;
+	}
+
+	if (t->pass_from_url) {
+		git__free(t->pass_from_url);
+		t->pass_from_url = NULL;
 	}
-#endif
 
-	*out = (git_transport *) t;
 	return 0;
 }
 
-int git_transport_https(git_transport **out)
+static void http_free(git_smart_subtransport *subtransport)
 {
-#if defined(GIT_SSL) || defined(GIT_WINHTTP)
-	transport_http *t;
-	if (git_transport_http((git_transport **)&t) < 0)
+	http_subtransport *t = (http_subtransport *) subtransport;
+
+	http_close(subtransport);
+
+	git__free(t);
+}
+
+int git_smart_subtransport_http(git_smart_subtransport **out, git_transport *owner)
+{
+	http_subtransport *t;
+
+	if (!out)
 		return -1;
 
-	t->parent.use_ssl = 1;
-	t->parent.check_cert = 1;
-	*out = (git_transport *) t;
+	t = git__calloc(sizeof(http_subtransport), 1);
+	GITERR_CHECK_ALLOC(t);
 
-	return 0;
-#else
-	GIT_UNUSED(out);
+	t->owner = (transport_smart *)owner;
+	t->parent.action = http_action;
+	t->parent.close = http_close;
+	t->parent.free = http_free;
 
-	giterr_set(GITERR_NET, "HTTPS support not available");
-	return -1;
-#endif
+	t->settings.on_header_field = on_header_field;
+	t->settings.on_header_value = on_header_value;
+	t->settings.on_headers_complete = on_headers_complete;
+	t->settings.on_body = on_body_fill_buffer;
+	t->settings.on_message_complete = on_message_complete;
+
+	*out = (git_smart_subtransport *) t;
+	return 0;
 }
+
+#endif /* !GIT_WINHTTP */