[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 char *ssl_cert = NULL;
#if LIBCURL_VERSION_NUM >= 0x070902
static char *ssl_key = NULL;
#endif
#if LIBCURL_VERSION_NUM >= 0x070908
static char *ssl_capath = NULL;
#endif
static 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) {
			if (!value)
				return config_error_nonbool(var);
			ssl_cert = xstrdup(value);
		}
		return 0;
	}
#if LIBCURL_VERSION_NUM >= 0x070902
	if (!strcmp("http.sslkey", var)) {
		if (ssl_key == NULL) {
			if (!value)
				return config_error_nonbool(var);
			ssl_key = xstrdup(value);
		}
		return 0;
	}
#endif
#if LIBCURL_VERSION_NUM >= 0x070908
	if (!strcmp("http.sslcapath", var)) {
		if (ssl_capath == NULL) {
			if (!value)
				return config_error_nonbool(var);
			ssl_capath = xstrdup(value);
		}
		return 0;
	}
#endif
	if (!strcmp("http.sslcainfo", var)) {
		if (ssl_cainfo == NULL) {
			if (!value)
				return config_error_nonbool(var);
			ssl_cainfo = xstrdup(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();

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