[thirdparty/git.git] / http.c

#include "http.h"

int data_received;
int active_requests = 0;

#ifdef USE_CURL_MULTI
static int max_requests = -1;
static CURLM *curlm;
#endif
#ifndef NO_CURL_EASY_DUPHANDLE
static CURL *curl_default;
#endif
char curl_errorstr[CURL_ERROR_SIZE];

static int curl_ssl_verify = -1;
static const char *ssl_cert = NULL;
#if LIBCURL_VERSION_NUM >= 0x070902
static const char *ssl_key = NULL;
#endif
#if LIBCURL_VERSION_NUM >= 0x070908
static const char *ssl_capath = NULL;
#endif
static const char *ssl_cainfo = NULL;
static long curl_low_speed_limit = -1;
static long curl_low_speed_time = -1;
static int curl_ftp_no_epsv = 0;
static char *curl_http_proxy = NULL;

static struct curl_slist *pragma_header;

static struct active_request_slot *active_queue_head = NULL;

size_t fread_buffer(void *ptr, size_t eltsize, size_t nmemb, void *buffer_)
{
	size_t size = eltsize * nmemb;
	struct buffer *buffer = buffer_;

	if (size > buffer->buf.len - buffer->posn)
		size = buffer->buf.len - buffer->posn;
	memcpy(ptr, buffer->buf.buf + buffer->posn, size);
	buffer->posn += size;

	return size;
}

size_t fwrite_buffer(const void *ptr, size_t eltsize, size_t nmemb, void *buffer_)
{
	size_t size = eltsize * nmemb;
	struct strbuf *buffer = buffer_;

	strbuf_add(buffer, ptr, size);
	data_received++;
	return size;
}

size_t fwrite_null(const void *ptr, size_t eltsize, size_t nmemb, void *strbuf)
{
	data_received++;
	return eltsize * nmemb;
}

static void finish_active_slot(struct active_request_slot *slot);

#ifdef USE_CURL_MULTI
static void process_curl_messages(void)
{
	int num_messages;
	struct active_request_slot *slot;
	CURLMsg *curl_message = curl_multi_info_read(curlm, &num_messages);

	while (curl_message != NULL) {
		if (curl_message->msg == CURLMSG_DONE) {
			int curl_result = curl_message->data.result;
			slot = active_queue_head;
			while (slot != NULL &&
			       slot->curl != curl_message->easy_handle)
				slot = slot->next;
			if (slot != NULL) {
				curl_multi_remove_handle(curlm, slot->curl);
				slot->curl_result = curl_result;
				finish_active_slot(slot);
			} else {
				fprintf(stderr, "Received DONE message for unknown request!\n");
			}
		} else {
			fprintf(stderr, "Unknown CURL message received: %d\n",
				(int)curl_message->msg);
		}
		curl_message = curl_multi_info_read(curlm, &num_messages);
	}
}
#endif

static int http_options(const char *var, const char *value, void *cb)
{
	if (!strcmp("http.sslverify", var)) {
		if (curl_ssl_verify == -1) {
			curl_ssl_verify = git_config_bool(var, value);
		}
		return 0;
	}

	if (!strcmp("http.sslcert", var)) {
		if (ssl_cert == NULL)
			return git_config_string(&ssl_cert, var, value);
		return 0;
	}
#if LIBCURL_VERSION_NUM >= 0x070902
	if (!strcmp("http.sslkey", var)) {
		if (ssl_key == NULL)
			return git_config_string(&ssl_key, var, value);
		return 0;
	}
#endif
#if LIBCURL_VERSION_NUM >= 0x070908
	if (!strcmp("http.sslcapath", var)) {
		if (ssl_capath == NULL)
			return git_config_string(&ssl_capath, var, value);
		return 0;
	}
#endif
	if (!strcmp("http.sslcainfo", var)) {
		if (ssl_cainfo == NULL)
			return git_config_string(&ssl_cainfo, var, value);
		return 0;
	}

#ifdef USE_CURL_MULTI
	if (!strcmp("http.maxrequests", var)) {
		if (max_requests == -1)
			max_requests = git_config_int(var, value);
		return 0;
	}
#endif

	if (!strcmp("http.lowspeedlimit", var)) {
		if (curl_low_speed_limit == -1)
			curl_low_speed_limit = (long)git_config_int(var, value);
		return 0;
	}
	if (!strcmp("http.lowspeedtime", var)) {
		if (curl_low_speed_time == -1)
			curl_low_speed_time = (long)git_config_int(var, value);
		return 0;
	}

	if (!strcmp("http.noepsv", var)) {
		curl_ftp_no_epsv = git_config_bool(var, value);
		return 0;
	}
	if (!strcmp("http.proxy", var)) {
		if (curl_http_proxy == NULL) {
			if (!value)
				return config_error_nonbool(var);
			curl_http_proxy = xstrdup(value);
		}
		return 0;
	}

	/* Fall back on the default ones */
	return git_default_config(var, value, cb);
}

static CURL* get_curl_handle(void)
{
	CURL* result = curl_easy_init();

	if (!curl_ssl_verify) {
		curl_easy_setopt(result, CURLOPT_SSL_VERIFYPEER, 0);
		curl_easy_setopt(result, CURLOPT_SSL_VERIFYHOST, 0);
	} else {
		/* Verify authenticity of the peer's certificate */
		curl_easy_setopt(result, CURLOPT_SSL_VERIFYPEER, 1);
		/* The name in the cert must match whom we tried to connect */
		curl_easy_setopt(result, CURLOPT_SSL_VERIFYHOST, 2);
	}

#if LIBCURL_VERSION_NUM >= 0x070907
	curl_easy_setopt(result, CURLOPT_NETRC, CURL_NETRC_OPTIONAL);
#endif

	if (ssl_cert != NULL)
		curl_easy_setopt(result, CURLOPT_SSLCERT, ssl_cert);
#if LIBCURL_VERSION_NUM >= 0x070902
	if (ssl_key != NULL)
		curl_easy_setopt(result, CURLOPT_SSLKEY, ssl_key);
#endif
#if LIBCURL_VERSION_NUM >= 0x070908
	if (ssl_capath != NULL)
		curl_easy_setopt(result, CURLOPT_CAPATH, ssl_capath);
#endif
	if (ssl_cainfo != NULL)
		curl_easy_setopt(result, CURLOPT_CAINFO, ssl_cainfo);
	curl_easy_setopt(result, CURLOPT_FAILONERROR, 1);

	if (curl_low_speed_limit > 0 && curl_low_speed_time > 0) {
		curl_easy_setopt(result, CURLOPT_LOW_SPEED_LIMIT,
				 curl_low_speed_limit);
		curl_easy_setopt(result, CURLOPT_LOW_SPEED_TIME,
				 curl_low_speed_time);
	}

	curl_easy_setopt(result, CURLOPT_FOLLOWLOCATION, 1);

	if (getenv("GIT_CURL_VERBOSE"))
		curl_easy_setopt(result, CURLOPT_VERBOSE, 1);

	curl_easy_setopt(result, CURLOPT_USERAGENT, GIT_USER_AGENT);

	if (curl_ftp_no_epsv)
		curl_easy_setopt(result, CURLOPT_FTP_USE_EPSV, 0);

	if (curl_http_proxy)
		curl_easy_setopt(result, CURLOPT_PROXY, curl_http_proxy);

	return result;
}

void http_init(struct remote *remote)
{
	char *low_speed_limit;
	char *low_speed_time;

	curl_global_init(CURL_GLOBAL_ALL);

	if (remote && remote->http_proxy)
		curl_http_proxy = xstrdup(remote->http_proxy);

	pragma_header = curl_slist_append(pragma_header, "Pragma: no-cache");

#ifdef USE_CURL_MULTI
	{
		char *http_max_requests = getenv("GIT_HTTP_MAX_REQUESTS");
		if (http_max_requests != NULL)
			max_requests = atoi(http_max_requests);
	}

	curlm = curl_multi_init();
	if (curlm == NULL) {
		fprintf(stderr, "Error creating curl multi handle.\n");
		exit(1);
	}
#endif

	if (getenv("GIT_SSL_NO_VERIFY"))
		curl_ssl_verify = 0;

	ssl_cert = getenv("GIT_SSL_CERT");
#if LIBCURL_VERSION_NUM >= 0x070902
	ssl_key = getenv("GIT_SSL_KEY");
#endif
#if LIBCURL_VERSION_NUM >= 0x070908
	ssl_capath = getenv("GIT_SSL_CAPATH");
#endif
	ssl_cainfo = getenv("GIT_SSL_CAINFO");

	low_speed_limit = getenv("GIT_HTTP_LOW_SPEED_LIMIT");
	if (low_speed_limit != NULL)
		curl_low_speed_limit = strtol(low_speed_limit, NULL, 10);
	low_speed_time = getenv("GIT_HTTP_LOW_SPEED_TIME");
	if (low_speed_time != NULL)
		curl_low_speed_time = strtol(low_speed_time, NULL, 10);

	git_config(http_options, NULL);

	if (curl_ssl_verify == -1)
		curl_ssl_verify = 1;

#ifdef USE_CURL_MULTI
	if (max_requests < 1)
		max_requests = DEFAULT_MAX_REQUESTS;
#endif

	if (getenv("GIT_CURL_FTP_NO_EPSV"))
		curl_ftp_no_epsv = 1;

#ifndef NO_CURL_EASY_DUPHANDLE
	curl_default = get_curl_handle();
#endif
}

void http_cleanup(void)
{
	struct active_request_slot *slot = active_queue_head;

	while (slot != NULL) {
		struct active_request_slot *next = slot->next;
		if (slot->curl != NULL) {
#ifdef USE_CURL_MULTI
			curl_multi_remove_handle(curlm, slot->curl);
#endif
			curl_easy_cleanup(slot->curl);
		}
		free(slot);
		slot = next;
	}
	active_queue_head = NULL;

#ifndef NO_CURL_EASY_DUPHANDLE
	curl_easy_cleanup(curl_default);
#endif

#ifdef USE_CURL_MULTI
	curl_multi_cleanup(curlm);
#endif
	curl_global_cleanup();

	curl_slist_free_all(pragma_header);
	pragma_header = NULL;

	if (curl_http_proxy) {
		free(curl_http_proxy);
		curl_http_proxy = NULL;
	}
}

struct active_request_slot *get_active_slot(void)
{
	struct active_request_slot *slot = active_queue_head;
	struct active_request_slot *newslot;

#ifdef USE_CURL_MULTI
	int num_transfers;

	/* Wait for a slot to open up if the queue is full */
	while (active_requests >= max_requests) {
		curl_multi_perform(curlm, &num_transfers);
		if (num_transfers < active_requests) {
			process_curl_messages();
		}
	}
#endif

	while (slot != NULL && slot->in_use) {
		slot = slot->next;
	}
	if (slot == NULL) {
		newslot = xmalloc(sizeof(*newslot));
		newslot->curl = NULL;
		newslot->in_use = 0;
		newslot->next = NULL;

		slot = active_queue_head;
		if (slot == NULL) {
			active_queue_head = newslot;
		} else {
			while (slot->next != NULL) {
				slot = slot->next;
			}
			slot->next = newslot;
		}
		slot = newslot;
	}

	if (slot->curl == NULL) {
#ifdef NO_CURL_EASY_DUPHANDLE
		slot->curl = get_curl_handle();
#else
		slot->curl = curl_easy_duphandle(curl_default);
#endif
	}

	active_requests++;
	slot->in_use = 1;
	slot->local = NULL;
	slot->results = NULL;
	slot->finished = NULL;
	slot->callback_data = NULL;
	slot->callback_func = NULL;
	curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, pragma_header);
	curl_easy_setopt(slot->curl, CURLOPT_ERRORBUFFER, curl_errorstr);
	curl_easy_setopt(slot->curl, CURLOPT_CUSTOMREQUEST, NULL);
	curl_easy_setopt(slot->curl, CURLOPT_READFUNCTION, NULL);
	curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, NULL);
	curl_easy_setopt(slot->curl, CURLOPT_UPLOAD, 0);
	curl_easy_setopt(slot->curl, CURLOPT_HTTPGET, 1);

	return slot;
}

int start_active_slot(struct active_request_slot *slot)
{
#ifdef USE_CURL_MULTI
	CURLMcode curlm_result = curl_multi_add_handle(curlm, slot->curl);
	int num_transfers;

	if (curlm_result != CURLM_OK &&
	    curlm_result != CURLM_CALL_MULTI_PERFORM) {
		active_requests--;
		slot->in_use = 0;
		return 0;
	}

	/*
	 * We know there must be something to do, since we just added
	 * something.
	 */
	curl_multi_perform(curlm, &num_transfers);
#endif
	return 1;
}

#ifdef USE_CURL_MULTI
struct fill_chain {
	void *data;
	int (*fill)(void *);
	struct fill_chain *next;
};

static struct fill_chain *fill_cfg = NULL;

void add_fill_function(void *data, int (*fill)(void *))
{
	struct fill_chain *new = malloc(sizeof(*new));
	struct fill_chain **linkp = &fill_cfg;
	new->data = data;
	new->fill = fill;
	new->next = NULL;
	while (*linkp)
		linkp = &(*linkp)->next;
	*linkp = new;
}

void fill_active_slots(void)
{
	struct active_request_slot *slot = active_queue_head;

	while (active_requests < max_requests) {
		struct fill_chain *fill;
		for (fill = fill_cfg; fill; fill = fill->next)
			if (fill->fill(fill->data))
				break;

		if (!fill)
			break;
	}

	while (slot != NULL) {
		if (!slot->in_use && slot->curl != NULL) {
			curl_easy_cleanup(slot->curl);
			slot->curl = NULL;
		}
		slot = slot->next;
	}
}

void step_active_slots(void)
{
	int num_transfers;
	CURLMcode curlm_result;

	do {
		curlm_result = curl_multi_perform(curlm, &num_transfers);
	} while (curlm_result == CURLM_CALL_MULTI_PERFORM);
	if (num_transfers < active_requests) {
		process_curl_messages();
		fill_active_slots();
	}
}
#endif

void run_active_slot(struct active_request_slot *slot)
{
#ifdef USE_CURL_MULTI
	long last_pos = 0;
	long current_pos;
	fd_set readfds;
	fd_set writefds;
	fd_set excfds;
	int max_fd;
	struct timeval select_timeout;
	int finished = 0;

	slot->finished = &finished;
	while (!finished) {
		data_received = 0;
		step_active_slots();

		if (!data_received && slot->local != NULL) {
			current_pos = ftell(slot->local);
			if (current_pos > last_pos)
				data_received++;
			last_pos = current_pos;
		}

		if (slot->in_use && !data_received) {
			max_fd = 0;
			FD_ZERO(&readfds);
			FD_ZERO(&writefds);
			FD_ZERO(&excfds);
			select_timeout.tv_sec = 0;
			select_timeout.tv_usec = 50000;
			select(max_fd, &readfds, &writefds,
			       &excfds, &select_timeout);
		}
	}
#else
	while (slot->in_use) {
		slot->curl_result = curl_easy_perform(slot->curl);
		finish_active_slot(slot);
	}
#endif
}

static void closedown_active_slot(struct active_request_slot *slot)
{
	active_requests--;
	slot->in_use = 0;
}

void release_active_slot(struct active_request_slot *slot)
{
	closedown_active_slot(slot);
	if (slot->curl) {
#ifdef USE_CURL_MULTI
		curl_multi_remove_handle(curlm, slot->curl);
#endif
		curl_easy_cleanup(slot->curl);
		slot->curl = NULL;
	}
#ifdef USE_CURL_MULTI
	fill_active_slots();
#endif
}

static void finish_active_slot(struct active_request_slot *slot)
{
	closedown_active_slot(slot);
	curl_easy_getinfo(slot->curl, CURLINFO_HTTP_CODE, &slot->http_code);

	if (slot->finished != NULL)
		(*slot->finished) = 1;

	/* Store slot results so they can be read after the slot is reused */
	if (slot->results != NULL) {
		slot->results->curl_result = slot->curl_result;
		slot->results->http_code = slot->http_code;
	}

	/* Run callback if appropriate */
	if (slot->callback_func != NULL) {
		slot->callback_func(slot->callback_data);
	}
}

void finish_all_active_slots(void)
{
	struct active_request_slot *slot = active_queue_head;

	while (slot != NULL)
		if (slot->in_use) {
			run_active_slot(slot);
			slot = active_queue_head;
		} else {
			slot = slot->next;
		}
}

static inline int needs_quote(int ch)
{
	if (((ch >= 'A') && (ch <= 'Z'))
			|| ((ch >= 'a') && (ch <= 'z'))
			|| ((ch >= '0') && (ch <= '9'))
			|| (ch == '/')
			|| (ch == '-')
			|| (ch == '.'))
		return 0;
	return 1;
}

static inline int hex(int v)
{
	if (v < 10) return '0' + v;
	else return 'A' + v - 10;
}

static char *quote_ref_url(const char *base, const char *ref)
{
	const char *cp;
	char *dp, *qref;
	int len, baselen, ch;

	baselen = strlen(base);
	len = baselen + 2; /* '/' after base and terminating NUL */
	for (cp = ref; (ch = *cp) != 0; cp++, len++)
		if (needs_quote(ch))
			len += 2; /* extra two hex plus replacement % */
	qref = xmalloc(len);
	memcpy(qref, base, baselen);
	dp = qref + baselen;
	*(dp++) = '/';
	for (cp = ref; (ch = *cp) != 0; cp++) {
		if (needs_quote(ch)) {
			*dp++ = '%';
			*dp++ = hex((ch >> 4) & 0xF);
			*dp++ = hex(ch & 0xF);
		}
		else
			*dp++ = ch;
	}
	*dp = 0;

	return qref;
}

int http_fetch_ref(const char *base, struct ref *ref)
{
	char *url;
	struct strbuf buffer = STRBUF_INIT;
	struct active_request_slot *slot;
	struct slot_results results;
	int ret;

	url = quote_ref_url(base, ref->name);
	slot = get_active_slot();
	slot->results = &results;
	curl_easy_setopt(slot->curl, CURLOPT_FILE, &buffer);
	curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite_buffer);
	curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, NULL);
	curl_easy_setopt(slot->curl, CURLOPT_URL, url);
	if (start_active_slot(slot)) {
		run_active_slot(slot);
		if (results.curl_result == CURLE_OK) {
			strbuf_rtrim(&buffer);
			if (buffer.len == 40)
				ret = get_sha1_hex(buffer.buf, ref->old_sha1);
			else if (!prefixcmp(buffer.buf, "ref: ")) {
				ref->symref = xstrdup(buffer.buf + 5);
				ret = 0;
			} else
				ret = 1;
		} else {
			ret = error("Couldn't get %s for %s\n%s",
				    url, ref->name, curl_errorstr);
		}
	} else {
		ret = error("Unable to start request");
	}

	strbuf_release(&buffer);
	free(url);
	return ret;
}
Commit	Line	Data
29508e1e NH	1	#include "http.h"
	2
	3	int data_received;
	4	int active_requests = 0;
	5
	6	#ifdef USE_CURL_MULTI
cc3530e8 MH	7	static int max_requests = -1;
cc3530e8 MH	8	static CURLM *curlm;
29508e1e NH	9	#endif
29508e1e NH	10	#ifndef NO_CURL_EASY_DUPHANDLE
cc3530e8	11	static CURL *curl_default;
29508e1e NH	12	#endif
	13	char curl_errorstr[CURL_ERROR_SIZE];
	14
cc3530e8	15	static int curl_ssl_verify = -1;
7ef8ea70	16	static const char *ssl_cert = NULL;
29508e1e	17	#if LIBCURL_VERSION_NUM >= 0x070902
7ef8ea70	18	static const char *ssl_key = NULL;
29508e1e NH	19	#endif
29508e1e NH	20	#if LIBCURL_VERSION_NUM >= 0x070908
7ef8ea70	21	static const char *ssl_capath = NULL;
29508e1e	22	#endif
7ef8ea70	23	static const char *ssl_cainfo = NULL;
cc3530e8 MH	24	static long curl_low_speed_limit = -1;
	25	static long curl_low_speed_time = -1;
	26	static int curl_ftp_no_epsv = 0;
	27	static char *curl_http_proxy = NULL;
29508e1e	28
cc3530e8	29	static struct curl_slist *pragma_header;
29508e1e	30
cc3530e8	31	static struct active_request_slot *active_queue_head = NULL;
29508e1e	32
f444e528	33	size_t fread_buffer(void ptr, size_t eltsize, size_t nmemb, void buffer_)
29508e1e NH	34	{
29508e1e NH	35	size_t size = eltsize * nmemb;
f444e528 JH	36	struct buffer *buffer = buffer_;
f444e528 JH	37
028c2976 MH	38	if (size > buffer->buf.len - buffer->posn)
	39	size = buffer->buf.len - buffer->posn;
	40	memcpy(ptr, buffer->buf.buf + buffer->posn, size);
29508e1e	41	buffer->posn += size;
028c2976	42
29508e1e NH	43	return size;
	44	}
	45
f444e528	46	size_t fwrite_buffer(const void ptr, size_t eltsize, size_t nmemb, void buffer_)
29508e1e NH	47	{
29508e1e NH	48	size_t size = eltsize * nmemb;
f444e528 JH	49	struct strbuf *buffer = buffer_;
f444e528 JH	50
028c2976	51	strbuf_add(buffer, ptr, size);
29508e1e NH	52	data_received++;
	53	return size;
	54	}
	55
f444e528	56	size_t fwrite_null(const void ptr, size_t eltsize, size_t nmemb, void strbuf)
29508e1e NH	57	{
	58	data_received++;
	59	return eltsize * nmemb;
	60	}
	61
	62	static void finish_active_slot(struct active_request_slot *slot);
	63
	64	#ifdef USE_CURL_MULTI
	65	static void process_curl_messages(void)
	66	{
	67	int num_messages;
	68	struct active_request_slot *slot;
	69	CURLMsg *curl_message = curl_multi_info_read(curlm, &num_messages);
	70
	71	while (curl_message != NULL) {
	72	if (curl_message->msg == CURLMSG_DONE) {
	73	int curl_result = curl_message->data.result;
	74	slot = active_queue_head;
	75	while (slot != NULL &&
	76	slot->curl != curl_message->easy_handle)
	77	slot = slot->next;
	78	if (slot != NULL) {
	79	curl_multi_remove_handle(curlm, slot->curl);
	80	slot->curl_result = curl_result;
	81	finish_active_slot(slot);
	82	} else {
	83	fprintf(stderr, "Received DONE message for unknown request!\n");
	84	}
	85	} else {
	86	fprintf(stderr, "Unknown CURL message received: %d\n",
	87	(int)curl_message->msg);
	88	}
	89	curl_message = curl_multi_info_read(curlm, &num_messages);
	90	}
	91	}
	92	#endif
	93
ef90d6d4	94	static int http_options(const char var, const char value, void *cb)
29508e1e NH	95	{
	96	if (!strcmp("http.sslverify", var)) {
	97	if (curl_ssl_verify == -1) {
	98	curl_ssl_verify = git_config_bool(var, value);
	99	}
	100	return 0;
	101	}
	102
	103	if (!strcmp("http.sslcert", var)) {
7ef8ea70 BH	104	if (ssl_cert == NULL)
7ef8ea70 BH	105	return git_config_string(&ssl_cert, var, value);
29508e1e NH	106	return 0;
	107	}
	108	#if LIBCURL_VERSION_NUM >= 0x070902
	109	if (!strcmp("http.sslkey", var)) {
7ef8ea70 BH	110	if (ssl_key == NULL)
7ef8ea70 BH	111	return git_config_string(&ssl_key, var, value);
29508e1e NH	112	return 0;
	113	}
	114	#endif
	115	#if LIBCURL_VERSION_NUM >= 0x070908
	116	if (!strcmp("http.sslcapath", var)) {
7ef8ea70 BH	117	if (ssl_capath == NULL)
7ef8ea70 BH	118	return git_config_string(&ssl_capath, var, value);
29508e1e NH	119	return 0;
	120	}
	121	#endif
	122	if (!strcmp("http.sslcainfo", var)) {
7ef8ea70 BH	123	if (ssl_cainfo == NULL)
7ef8ea70 BH	124	return git_config_string(&ssl_cainfo, var, value);
29508e1e NH	125	return 0;
	126	}
	127
a6080a0a	128	#ifdef USE_CURL_MULTI
29508e1e NH	129	if (!strcmp("http.maxrequests", var)) {
	130	if (max_requests == -1)
	131	max_requests = git_config_int(var, value);
	132	return 0;
	133	}
	134	#endif
	135
	136	if (!strcmp("http.lowspeedlimit", var)) {
	137	if (curl_low_speed_limit == -1)
	138	curl_low_speed_limit = (long)git_config_int(var, value);
	139	return 0;
	140	}
	141	if (!strcmp("http.lowspeedtime", var)) {
	142	if (curl_low_speed_time == -1)
	143	curl_low_speed_time = (long)git_config_int(var, value);
	144	return 0;
	145	}
	146
3ea099d4 SK	147	if (!strcmp("http.noepsv", var)) {
	148	curl_ftp_no_epsv = git_config_bool(var, value);
	149	return 0;
	150	}
9c5665aa SV	151	if (!strcmp("http.proxy", var)) {
9c5665aa SV	152	if (curl_http_proxy == NULL) {
111dd25f JH	153	if (!value)
	154	return config_error_nonbool(var);
	155	curl_http_proxy = xstrdup(value);
9c5665aa SV	156	}
	157	return 0;
	158	}
3ea099d4	159
29508e1e	160	/* Fall back on the default ones */
ef90d6d4	161	return git_default_config(var, value, cb);
29508e1e NH	162	}
29508e1e NH	163
11979b98 JH	164	static CURL* get_curl_handle(void)
	165	{
	166	CURL* result = curl_easy_init();
	167
a5ccc597 JH	168	if (!curl_ssl_verify) {
	169	curl_easy_setopt(result, CURLOPT_SSL_VERIFYPEER, 0);
	170	curl_easy_setopt(result, CURLOPT_SSL_VERIFYHOST, 0);
	171	} else {
	172	/* Verify authenticity of the peer's certificate */
	173	curl_easy_setopt(result, CURLOPT_SSL_VERIFYPEER, 1);
	174	/* The name in the cert must match whom we tried to connect */
	175	curl_easy_setopt(result, CURLOPT_SSL_VERIFYHOST, 2);
	176	}
	177
11979b98 JH	178	#if LIBCURL_VERSION_NUM >= 0x070907
	179	curl_easy_setopt(result, CURLOPT_NETRC, CURL_NETRC_OPTIONAL);
	180	#endif
	181
	182	if (ssl_cert != NULL)
	183	curl_easy_setopt(result, CURLOPT_SSLCERT, ssl_cert);
	184	#if LIBCURL_VERSION_NUM >= 0x070902
	185	if (ssl_key != NULL)
	186	curl_easy_setopt(result, CURLOPT_SSLKEY, ssl_key);
	187	#endif
	188	#if LIBCURL_VERSION_NUM >= 0x070908
	189	if (ssl_capath != NULL)
	190	curl_easy_setopt(result, CURLOPT_CAPATH, ssl_capath);
	191	#endif
	192	if (ssl_cainfo != NULL)
	193	curl_easy_setopt(result, CURLOPT_CAINFO, ssl_cainfo);
	194	curl_easy_setopt(result, CURLOPT_FAILONERROR, 1);
	195
	196	if (curl_low_speed_limit > 0 && curl_low_speed_time > 0) {
	197	curl_easy_setopt(result, CURLOPT_LOW_SPEED_LIMIT,
	198	curl_low_speed_limit);
	199	curl_easy_setopt(result, CURLOPT_LOW_SPEED_TIME,
	200	curl_low_speed_time);
	201	}
	202
	203	curl_easy_setopt(result, CURLOPT_FOLLOWLOCATION, 1);
	204
7982d74e MW	205	if (getenv("GIT_CURL_VERBOSE"))
	206	curl_easy_setopt(result, CURLOPT_VERBOSE, 1);
	207
20fc9bc5 NH	208	curl_easy_setopt(result, CURLOPT_USERAGENT, GIT_USER_AGENT);
20fc9bc5 NH	209
3ea099d4 SK	210	if (curl_ftp_no_epsv)
	211	curl_easy_setopt(result, CURLOPT_FTP_USE_EPSV, 0);
	212
9c5665aa SV	213	if (curl_http_proxy)
	214	curl_easy_setopt(result, CURLOPT_PROXY, curl_http_proxy);
	215
11979b98 JH	216	return result;
	217	}
	218
9fc6440d	219	void http_init(struct remote *remote)
29508e1e NH	220	{
	221	char *low_speed_limit;
	222	char *low_speed_time;
	223
	224	curl_global_init(CURL_GLOBAL_ALL);
	225
9fc6440d MH	226	if (remote && remote->http_proxy)
	227	curl_http_proxy = xstrdup(remote->http_proxy);
	228
29508e1e	229	pragma_header = curl_slist_append(pragma_header, "Pragma: no-cache");
29508e1e NH	230
	231	#ifdef USE_CURL_MULTI
	232	{
	233	char *http_max_requests = getenv("GIT_HTTP_MAX_REQUESTS");
	234	if (http_max_requests != NULL)
	235	max_requests = atoi(http_max_requests);
	236	}
	237
	238	curlm = curl_multi_init();
	239	if (curlm == NULL) {
	240	fprintf(stderr, "Error creating curl multi handle.\n");
	241	exit(1);
	242	}
	243	#endif
	244
	245	if (getenv("GIT_SSL_NO_VERIFY"))
	246	curl_ssl_verify = 0;
	247
	248	ssl_cert = getenv("GIT_SSL_CERT");
	249	#if LIBCURL_VERSION_NUM >= 0x070902
	250	ssl_key = getenv("GIT_SSL_KEY");
	251	#endif
	252	#if LIBCURL_VERSION_NUM >= 0x070908
	253	ssl_capath = getenv("GIT_SSL_CAPATH");
	254	#endif
	255	ssl_cainfo = getenv("GIT_SSL_CAINFO");
	256
	257	low_speed_limit = getenv("GIT_HTTP_LOW_SPEED_LIMIT");
	258	if (low_speed_limit != NULL)
	259	curl_low_speed_limit = strtol(low_speed_limit, NULL, 10);
	260	low_speed_time = getenv("GIT_HTTP_LOW_SPEED_TIME");
	261	if (low_speed_time != NULL)
	262	curl_low_speed_time = strtol(low_speed_time, NULL, 10);
	263
ef90d6d4	264	git_config(http_options, NULL);
29508e1e NH	265
	266	if (curl_ssl_verify == -1)
	267	curl_ssl_verify = 1;
	268
	269	#ifdef USE_CURL_MULTI
	270	if (max_requests < 1)
	271	max_requests = DEFAULT_MAX_REQUESTS;
	272	#endif
	273
3ea099d4 SK	274	if (getenv("GIT_CURL_FTP_NO_EPSV"))
	275	curl_ftp_no_epsv = 1;
	276
29508e1e NH	277	#ifndef NO_CURL_EASY_DUPHANDLE
	278	curl_default = get_curl_handle();
	279	#endif
	280	}
	281
	282	void http_cleanup(void)
	283	{
	284	struct active_request_slot *slot = active_queue_head;
29508e1e NH	285
29508e1e NH	286	while (slot != NULL) {
3278cd0a	287	struct active_request_slot *next = slot->next;
f23d1f76	288	if (slot->curl != NULL) {
29508e1e	289	#ifdef USE_CURL_MULTI
f23d1f76	290	curl_multi_remove_handle(curlm, slot->curl);
29508e1e	291	#endif
29508e1e	292	curl_easy_cleanup(slot->curl);
f23d1f76	293	}
3278cd0a SP	294	free(slot);
3278cd0a SP	295	slot = next;
29508e1e	296	}
3278cd0a	297	active_queue_head = NULL;
29508e1e NH	298
	299	#ifndef NO_CURL_EASY_DUPHANDLE
	300	curl_easy_cleanup(curl_default);
	301	#endif
	302
	303	#ifdef USE_CURL_MULTI
	304	curl_multi_cleanup(curlm);
	305	#endif
	306	curl_global_cleanup();
b3ca4e4e NH	307
b3ca4e4e NH	308	curl_slist_free_all(pragma_header);
3278cd0a	309	pragma_header = NULL;
9fc6440d MH	310
	311	if (curl_http_proxy) {
	312	free(curl_http_proxy);
	313	curl_http_proxy = NULL;
	314	}
29508e1e NH	315	}
29508e1e NH	316
29508e1e NH	317	struct active_request_slot *get_active_slot(void)
	318	{
	319	struct active_request_slot *slot = active_queue_head;
	320	struct active_request_slot *newslot;
	321
	322	#ifdef USE_CURL_MULTI
	323	int num_transfers;
	324
	325	/* Wait for a slot to open up if the queue is full */
	326	while (active_requests >= max_requests) {
	327	curl_multi_perform(curlm, &num_transfers);
	328	if (num_transfers < active_requests) {
	329	process_curl_messages();
	330	}
	331	}
	332	#endif
	333
	334	while (slot != NULL && slot->in_use) {
	335	slot = slot->next;
	336	}
	337	if (slot == NULL) {
	338	newslot = xmalloc(sizeof(*newslot));
	339	newslot->curl = NULL;
	340	newslot->in_use = 0;
	341	newslot->next = NULL;
	342
	343	slot = active_queue_head;
	344	if (slot == NULL) {
	345	active_queue_head = newslot;
	346	} else {
	347	while (slot->next != NULL) {
	348	slot = slot->next;
	349	}
	350	slot->next = newslot;
	351	}
	352	slot = newslot;
	353	}
	354
	355	if (slot->curl == NULL) {
	356	#ifdef NO_CURL_EASY_DUPHANDLE
	357	slot->curl = get_curl_handle();
	358	#else
	359	slot->curl = curl_easy_duphandle(curl_default);
	360	#endif
	361	}
	362
	363	active_requests++;
	364	slot->in_use = 1;
	365	slot->local = NULL;
c8568e13	366	slot->results = NULL;
baa7b67d	367	slot->finished = NULL;
29508e1e NH	368	slot->callback_data = NULL;
	369	slot->callback_func = NULL;
	370	curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, pragma_header);
29508e1e	371	curl_easy_setopt(slot->curl, CURLOPT_ERRORBUFFER, curl_errorstr);
9094950d NH	372	curl_easy_setopt(slot->curl, CURLOPT_CUSTOMREQUEST, NULL);
	373	curl_easy_setopt(slot->curl, CURLOPT_READFUNCTION, NULL);
	374	curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, NULL);
	375	curl_easy_setopt(slot->curl, CURLOPT_UPLOAD, 0);
	376	curl_easy_setopt(slot->curl, CURLOPT_HTTPGET, 1);
29508e1e NH	377
	378	return slot;
	379	}
	380
	381	int start_active_slot(struct active_request_slot *slot)
	382	{
	383	#ifdef USE_CURL_MULTI
	384	CURLMcode curlm_result = curl_multi_add_handle(curlm, slot->curl);
45c17412	385	int num_transfers;
29508e1e NH	386
	387	if (curlm_result != CURLM_OK &&
	388	curlm_result != CURLM_CALL_MULTI_PERFORM) {
	389	active_requests--;
	390	slot->in_use = 0;
	391	return 0;
	392	}
45c17412 DB	393
	394	/*
	395	* We know there must be something to do, since we just added
	396	* something.
	397	*/
	398	curl_multi_perform(curlm, &num_transfers);
29508e1e NH	399	#endif
	400	return 1;
	401	}
	402
	403	#ifdef USE_CURL_MULTI
fc57b6aa DB	404	struct fill_chain {
	405	void *data;
	406	int (fill)(void );
	407	struct fill_chain *next;
	408	};
	409
	410	static struct fill_chain *fill_cfg = NULL;
	411
	412	void add_fill_function(void data, int (fill)(void *))
	413	{
	414	struct fill_chain new = malloc(sizeof(new));
	415	struct fill_chain **linkp = &fill_cfg;
	416	new->data = data;
	417	new->fill = fill;
	418	new->next = NULL;
	419	while (*linkp)
	420	linkp = &(*linkp)->next;
	421	*linkp = new;
	422	}
	423
45c17412 DB	424	void fill_active_slots(void)
	425	{
	426	struct active_request_slot *slot = active_queue_head;
	427
fc57b6aa DB	428	while (active_requests < max_requests) {
	429	struct fill_chain *fill;
	430	for (fill = fill_cfg; fill; fill = fill->next)
	431	if (fill->fill(fill->data))
	432	break;
	433
	434	if (!fill)
45c17412	435	break;
fc57b6aa	436	}
45c17412 DB	437
	438	while (slot != NULL) {
	439	if (!slot->in_use && slot->curl != NULL) {
	440	curl_easy_cleanup(slot->curl);
	441	slot->curl = NULL;
	442	}
	443	slot = slot->next;
	444	}
	445	}
	446
29508e1e NH	447	void step_active_slots(void)
	448	{
	449	int num_transfers;
	450	CURLMcode curlm_result;
	451
	452	do {
	453	curlm_result = curl_multi_perform(curlm, &num_transfers);
	454	} while (curlm_result == CURLM_CALL_MULTI_PERFORM);
	455	if (num_transfers < active_requests) {
	456	process_curl_messages();
	457	fill_active_slots();
	458	}
	459	}
	460	#endif
	461
	462	void run_active_slot(struct active_request_slot *slot)
	463	{
	464	#ifdef USE_CURL_MULTI
	465	long last_pos = 0;
	466	long current_pos;
	467	fd_set readfds;
	468	fd_set writefds;
	469	fd_set excfds;
	470	int max_fd;
	471	struct timeval select_timeout;
baa7b67d	472	int finished = 0;
29508e1e	473
baa7b67d NH	474	slot->finished = &finished;
baa7b67d NH	475	while (!finished) {
29508e1e NH	476	data_received = 0;
	477	step_active_slots();
	478
	479	if (!data_received && slot->local != NULL) {
	480	current_pos = ftell(slot->local);
	481	if (current_pos > last_pos)
	482	data_received++;
	483	last_pos = current_pos;
	484	}
	485
	486	if (slot->in_use && !data_received) {
	487	max_fd = 0;
	488	FD_ZERO(&readfds);
	489	FD_ZERO(&writefds);
	490	FD_ZERO(&excfds);
	491	select_timeout.tv_sec = 0;
	492	select_timeout.tv_usec = 50000;
	493	select(max_fd, &readfds, &writefds,
	494	&excfds, &select_timeout);
	495	}
	496	}
	497	#else
	498	while (slot->in_use) {
	499	slot->curl_result = curl_easy_perform(slot->curl);
	500	finish_active_slot(slot);
	501	}
	502	#endif
	503	}
	504
53f31389	505	static void closedown_active_slot(struct active_request_slot *slot)
29508e1e	506	{
028c2976 MH	507	active_requests--;
028c2976 MH	508	slot->in_use = 0;
53f31389 MW	509	}
	510
	511	void release_active_slot(struct active_request_slot *slot)
	512	{
	513	closedown_active_slot(slot);
	514	if (slot->curl) {
b3ca4e4e	515	#ifdef USE_CURL_MULTI
53f31389	516	curl_multi_remove_handle(curlm, slot->curl);
b3ca4e4e	517	#endif
53f31389 MW	518	curl_easy_cleanup(slot->curl);
	519	slot->curl = NULL;
	520	}
b3ca4e4e	521	#ifdef USE_CURL_MULTI
53f31389	522	fill_active_slots();
b3ca4e4e	523	#endif
53f31389 MW	524	}
	525
	526	static void finish_active_slot(struct active_request_slot *slot)
	527	{
	528	closedown_active_slot(slot);
028c2976	529	curl_easy_getinfo(slot->curl, CURLINFO_HTTP_CODE, &slot->http_code);
c8568e13	530
baa7b67d NH	531	if (slot->finished != NULL)
	532	(*slot->finished) = 1;
	533
c8568e13 NH	534	/* Store slot results so they can be read after the slot is reused */
	535	if (slot->results != NULL) {
	536	slot->results->curl_result = slot->curl_result;
	537	slot->results->http_code = slot->http_code;
	538	}
	539
028c2976 MH	540	/* Run callback if appropriate */
	541	if (slot->callback_func != NULL) {
	542	slot->callback_func(slot->callback_data);
	543	}
29508e1e NH	544	}
	545
	546	void finish_all_active_slots(void)
	547	{
	548	struct active_request_slot *slot = active_queue_head;
	549
	550	while (slot != NULL)
	551	if (slot->in_use) {
	552	run_active_slot(slot);
	553	slot = active_queue_head;
	554	} else {
	555	slot = slot->next;
	556	}
	557	}
d7e92806 MH	558
	559	static inline int needs_quote(int ch)
	560	{
	561	if (((ch >= 'A') && (ch <= 'Z'))
	562	\|\| ((ch >= 'a') && (ch <= 'z'))
	563	\|\| ((ch >= '0') && (ch <= '9'))
	564	\|\| (ch == '/')
	565	\|\| (ch == '-')
	566	\|\| (ch == '.'))
	567	return 0;
	568	return 1;
	569	}
	570
	571	static inline int hex(int v)
	572	{
	573	if (v < 10) return '0' + v;
	574	else return 'A' + v - 10;
	575	}
	576
	577	static char quote_ref_url(const char base, const char *ref)
	578	{
	579	const char *cp;
	580	char dp, qref;
	581	int len, baselen, ch;
	582
	583	baselen = strlen(base);
7c1a9e79	584	len = baselen + 2; /* '/' after base and terminating NUL */
d7e92806 MH	585	for (cp = ref; (ch = *cp) != 0; cp++, len++)
	586	if (needs_quote(ch))
	587	len += 2; /* extra two hex plus replacement % */
	588	qref = xmalloc(len);
	589	memcpy(qref, base, baselen);
c13b2633 DB	590	dp = qref + baselen;
	591	*(dp++) = '/';
	592	for (cp = ref; (ch = *cp) != 0; cp++) {
d7e92806 MH	593	if (needs_quote(ch)) {
	594	*dp++ = '%';
	595	*dp++ = hex((ch >> 4) & 0xF);
	596	*dp++ = hex(ch & 0xF);
	597	}
	598	else
	599	*dp++ = ch;
	600	}
	601	*dp = 0;
	602
	603	return qref;
	604	}
	605
c13b2633	606	int http_fetch_ref(const char base, struct ref ref)
d7e92806 MH	607	{
	608	char *url;
	609	struct strbuf buffer = STRBUF_INIT;
	610	struct active_request_slot *slot;
	611	struct slot_results results;
	612	int ret;
	613
c13b2633	614	url = quote_ref_url(base, ref->name);
d7e92806 MH	615	slot = get_active_slot();
	616	slot->results = &results;
	617	curl_easy_setopt(slot->curl, CURLOPT_FILE, &buffer);
	618	curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite_buffer);
	619	curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, NULL);
	620	curl_easy_setopt(slot->curl, CURLOPT_URL, url);
	621	if (start_active_slot(slot)) {
	622	run_active_slot(slot);
	623	if (results.curl_result == CURLE_OK) {
	624	strbuf_rtrim(&buffer);
	625	if (buffer.len == 40)
c13b2633	626	ret = get_sha1_hex(buffer.buf, ref->old_sha1);
be885d96 DB	627	else if (!prefixcmp(buffer.buf, "ref: ")) {
	628	ref->symref = xstrdup(buffer.buf + 5);
	629	ret = 0;
	630	} else
d7e92806 MH	631	ret = 1;
	632	} else {
	633	ret = error("Couldn't get %s for %s\n%s",
c13b2633	634	url, ref->name, curl_errorstr);
d7e92806 MH	635	}
	636	} else {
	637	ret = error("Unable to start request");
	638	}
	639
	640	strbuf_release(&buffer);
	641	free(url);
	642	return ret;
	643	}