[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,
			   struct buffer *buffer)
{
	size_t size = eltsize * nmemb;
	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, struct strbuf *buffer)
{
	size_t size = eltsize * nmemb;
	strbuf_add(buffer, ptr, size);
	data_received++;
	return size;
}

size_t fwrite_null(const void *ptr, size_t eltsize,
			  size_t nmemb, struct strbuf *buffer)
{
	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)
{
	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);
}

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);

	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 + 7; /* "/refs/" + 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);
	memcpy(qref + baselen, "/refs/", 6);
	for (cp = ref, dp = qref + baselen + 6; (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, const char *ref, unsigned char *sha1)
{
	char *url;
	struct strbuf buffer = STRBUF_INIT;
	struct active_request_slot *slot;
	struct slot_results results;
	int ret;

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