[thirdparty/git.git] / http.c

#include "http.h"

int data_received;
int active_requests = 0;

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

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

struct curl_slist *pragma_header;

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->size - buffer->posn)
		size = buffer->size - buffer->posn;
	memcpy(ptr, (char *) buffer->buffer + buffer->posn, size);
	buffer->posn += size;
	return size;
}

size_t fwrite_buffer(const void *ptr, size_t eltsize,
			    size_t nmemb, struct buffer *buffer)
{
	size_t size = eltsize * nmemb;
	if (size > buffer->size - buffer->posn) {
		buffer->size = buffer->size * 3 / 2;
		if (buffer->size < buffer->posn + size)
			buffer->size = buffer->posn + size;
		buffer->buffer = xrealloc(buffer->buffer, buffer->size);
	}
	memcpy((char *) buffer->buffer + buffer->posn, ptr, size);
	buffer->posn += size;
	data_received++;
	return size;
}

size_t fwrite_null(const void *ptr, size_t eltsize,
			  size_t nmemb, struct buffer *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) {
			ssl_cert = xmalloc(strlen(value)+1);
			strcpy(ssl_cert, value);
		}
		return 0;
	}
#if LIBCURL_VERSION_NUM >= 0x070902
	if (!strcmp("http.sslkey", var)) {
		if (ssl_key == NULL) {
			ssl_key = xmalloc(strlen(value)+1);
			strcpy(ssl_key, value);
		}
		return 0;
	}
#endif
#if LIBCURL_VERSION_NUM >= 0x070908
	if (!strcmp("http.sslcapath", var)) {
		if (ssl_capath == NULL) {
			ssl_capath = xmalloc(strlen(value)+1);
			strcpy(ssl_capath, value);
		}
		return 0;
	}
#endif
	if (!strcmp("http.sslcainfo", var)) {
		if (ssl_cainfo == NULL) {
			ssl_cainfo = xmalloc(strlen(value)+1);
			strcpy(ssl_cainfo, 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;
	}

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

	return result;
}

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

	curl_global_init(CURL_GLOBAL_ALL);

	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

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

void http_cleanup(void)
{
	struct active_request_slot *slot = active_queue_head;
#ifdef USE_CURL_MULTI
	char *wait_url;
#endif

	while (slot != NULL) {
#ifdef USE_CURL_MULTI
		if (slot->in_use) {
			curl_easy_getinfo(slot->curl,
					  CURLINFO_EFFECTIVE_URL,
					  &wait_url);
			fprintf(stderr, "Waiting for %s\n", wait_url);
			run_active_slot(slot);
		}
#endif
		if (slot->curl != NULL)
			curl_easy_cleanup(slot->curl);
		slot = slot->next;
	}

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

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

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

#ifdef USE_CURL_MULTI
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;
		}
}
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
	7	int max_requests = -1;
	8	CURLM *curlm;
	9	#endif
	10	#ifndef NO_CURL_EASY_DUPHANDLE
	11	CURL *curl_default;
	12	#endif
	13	char curl_errorstr[CURL_ERROR_SIZE];
	14
	15	int curl_ssl_verify = -1;
	16	char *ssl_cert = NULL;
	17	#if LIBCURL_VERSION_NUM >= 0x070902
	18	char *ssl_key = NULL;
	19	#endif
	20	#if LIBCURL_VERSION_NUM >= 0x070908
	21	char *ssl_capath = NULL;
	22	#endif
	23	char *ssl_cainfo = NULL;
	24	long curl_low_speed_limit = -1;
	25	long curl_low_speed_time = -1;
	26
	27	struct curl_slist *pragma_header;
29508e1e NH	28
	29	struct active_request_slot *active_queue_head = NULL;
	30
	31	size_t fread_buffer(void *ptr, size_t eltsize, size_t nmemb,
	32	struct buffer *buffer)
	33	{
	34	size_t size = eltsize * nmemb;
	35	if (size > buffer->size - buffer->posn)
	36	size = buffer->size - buffer->posn;
1d7f171c	37	memcpy(ptr, (char *) buffer->buffer + buffer->posn, size);
29508e1e NH	38	buffer->posn += size;
	39	return size;
	40	}
	41
	42	size_t fwrite_buffer(const void *ptr, size_t eltsize,
	43	size_t nmemb, struct buffer *buffer)
	44	{
	45	size_t size = eltsize * nmemb;
	46	if (size > buffer->size - buffer->posn) {
	47	buffer->size = buffer->size * 3 / 2;
	48	if (buffer->size < buffer->posn + size)
	49	buffer->size = buffer->posn + size;
	50	buffer->buffer = xrealloc(buffer->buffer, buffer->size);
	51	}
1d7f171c	52	memcpy((char *) buffer->buffer + buffer->posn, ptr, size);
29508e1e NH	53	buffer->posn += size;
	54	data_received++;
	55	return size;
	56	}
	57
	58	size_t fwrite_null(const void *ptr, size_t eltsize,
	59	size_t nmemb, struct buffer *buffer)
	60	{
	61	data_received++;
	62	return eltsize * nmemb;
	63	}
	64
	65	static void finish_active_slot(struct active_request_slot *slot);
	66
	67	#ifdef USE_CURL_MULTI
	68	static void process_curl_messages(void)
	69	{
	70	int num_messages;
	71	struct active_request_slot *slot;
	72	CURLMsg *curl_message = curl_multi_info_read(curlm, &num_messages);
	73
	74	while (curl_message != NULL) {
	75	if (curl_message->msg == CURLMSG_DONE) {
	76	int curl_result = curl_message->data.result;
	77	slot = active_queue_head;
	78	while (slot != NULL &&
	79	slot->curl != curl_message->easy_handle)
	80	slot = slot->next;
	81	if (slot != NULL) {
	82	curl_multi_remove_handle(curlm, slot->curl);
	83	slot->curl_result = curl_result;
	84	finish_active_slot(slot);
	85	} else {
	86	fprintf(stderr, "Received DONE message for unknown request!\n");
	87	}
	88	} else {
	89	fprintf(stderr, "Unknown CURL message received: %d\n",
	90	(int)curl_message->msg);
	91	}
	92	curl_message = curl_multi_info_read(curlm, &num_messages);
	93	}
	94	}
	95	#endif
	96
	97	static int http_options(const char var, const char value)
	98	{
	99	if (!strcmp("http.sslverify", var)) {
	100	if (curl_ssl_verify == -1) {
	101	curl_ssl_verify = git_config_bool(var, value);
	102	}
	103	return 0;
	104	}
	105
	106	if (!strcmp("http.sslcert", var)) {
	107	if (ssl_cert == NULL) {
	108	ssl_cert = xmalloc(strlen(value)+1);
	109	strcpy(ssl_cert, value);
	110	}
	111	return 0;
	112	}
	113	#if LIBCURL_VERSION_NUM >= 0x070902
	114	if (!strcmp("http.sslkey", var)) {
	115	if (ssl_key == NULL) {
	116	ssl_key = xmalloc(strlen(value)+1);
117	strcpy(ssl_key, value);
118	}
119	return 0;
120	}
121	#endif
122	#if LIBCURL_VERSION_NUM >= 0x070908
123	if (!strcmp("http.sslcapath", var)) {
124	if (ssl_capath == NULL) {
125	ssl_capath = xmalloc(strlen(value)+1);
126	strcpy(ssl_capath, value);
127	}
128	return 0;
129	}
130	#endif
131	if (!strcmp("http.sslcainfo", var)) {
132	if (ssl_cainfo == NULL) {
133	ssl_cainfo = xmalloc(strlen(value)+1);
134	strcpy(ssl_cainfo, value);
135	}
136	return 0;
137	}
138
139	#ifdef USE_CURL_MULTI
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
158	/* Fall back on the default ones */
159	return git_default_config(var, value);
160	}
161
11979b98 JH	162	static CURL* get_curl_handle(void)
	163	{
	164	CURL* result = curl_easy_init();
	165
	166	curl_easy_setopt(result, CURLOPT_SSL_VERIFYPEER, curl_ssl_verify);
	167	#if LIBCURL_VERSION_NUM >= 0x070907
	168	curl_easy_setopt(result, CURLOPT_NETRC, CURL_NETRC_OPTIONAL);
	169	#endif
	170
	171	if (ssl_cert != NULL)
	172	curl_easy_setopt(result, CURLOPT_SSLCERT, ssl_cert);
	173	#if LIBCURL_VERSION_NUM >= 0x070902
	174	if (ssl_key != NULL)
	175	curl_easy_setopt(result, CURLOPT_SSLKEY, ssl_key);
	176	#endif
	177	#if LIBCURL_VERSION_NUM >= 0x070908
	178	if (ssl_capath != NULL)
	179	curl_easy_setopt(result, CURLOPT_CAPATH, ssl_capath);
	180	#endif
	181	if (ssl_cainfo != NULL)
	182	curl_easy_setopt(result, CURLOPT_CAINFO, ssl_cainfo);
	183	curl_easy_setopt(result, CURLOPT_FAILONERROR, 1);
	184
	185	if (curl_low_speed_limit > 0 && curl_low_speed_time > 0) {
	186	curl_easy_setopt(result, CURLOPT_LOW_SPEED_LIMIT,
	187	curl_low_speed_limit);
	188	curl_easy_setopt(result, CURLOPT_LOW_SPEED_TIME,
	189	curl_low_speed_time);
	190	}
	191
	192	curl_easy_setopt(result, CURLOPT_FOLLOWLOCATION, 1);
	193
7982d74e MW	194	if (getenv("GIT_CURL_VERBOSE"))
	195	curl_easy_setopt(result, CURLOPT_VERBOSE, 1);
	196
20fc9bc5 NH	197	curl_easy_setopt(result, CURLOPT_USERAGENT, GIT_USER_AGENT);
20fc9bc5 NH	198
11979b98 JH	199	return result;
	200	}
	201
29508e1e NH	202	void http_init(void)
	203	{
	204	char *low_speed_limit;
	205	char *low_speed_time;
	206
	207	curl_global_init(CURL_GLOBAL_ALL);
	208
	209	pragma_header = curl_slist_append(pragma_header, "Pragma: no-cache");
29508e1e NH	210
	211	#ifdef USE_CURL_MULTI
	212	{
	213	char *http_max_requests = getenv("GIT_HTTP_MAX_REQUESTS");
	214	if (http_max_requests != NULL)
	215	max_requests = atoi(http_max_requests);
	216	}
	217
	218	curlm = curl_multi_init();
	219	if (curlm == NULL) {
	220	fprintf(stderr, "Error creating curl multi handle.\n");
	221	exit(1);
	222	}
	223	#endif
	224
	225	if (getenv("GIT_SSL_NO_VERIFY"))
	226	curl_ssl_verify = 0;
	227
	228	ssl_cert = getenv("GIT_SSL_CERT");
	229	#if LIBCURL_VERSION_NUM >= 0x070902
	230	ssl_key = getenv("GIT_SSL_KEY");
	231	#endif
	232	#if LIBCURL_VERSION_NUM >= 0x070908
	233	ssl_capath = getenv("GIT_SSL_CAPATH");
	234	#endif
	235	ssl_cainfo = getenv("GIT_SSL_CAINFO");
	236
	237	low_speed_limit = getenv("GIT_HTTP_LOW_SPEED_LIMIT");
	238	if (low_speed_limit != NULL)
	239	curl_low_speed_limit = strtol(low_speed_limit, NULL, 10);
	240	low_speed_time = getenv("GIT_HTTP_LOW_SPEED_TIME");
	241	if (low_speed_time != NULL)
	242	curl_low_speed_time = strtol(low_speed_time, NULL, 10);
	243
	244	git_config(http_options);
	245
	246	if (curl_ssl_verify == -1)
	247	curl_ssl_verify = 1;
	248
	249	#ifdef USE_CURL_MULTI
	250	if (max_requests < 1)
	251	max_requests = DEFAULT_MAX_REQUESTS;
	252	#endif
	253
	254	#ifndef NO_CURL_EASY_DUPHANDLE
	255	curl_default = get_curl_handle();
	256	#endif
	257	}
	258
	259	void http_cleanup(void)
	260	{
	261	struct active_request_slot *slot = active_queue_head;
	262	#ifdef USE_CURL_MULTI
	263	char *wait_url;
29508e1e NH	264	#endif
	265
	266	while (slot != NULL) {
	267	#ifdef USE_CURL_MULTI
	268	if (slot->in_use) {
	269	curl_easy_getinfo(slot->curl,
	270	CURLINFO_EFFECTIVE_URL,
	271	&wait_url);
	272	fprintf(stderr, "Waiting for %s\n", wait_url);
	273	run_active_slot(slot);
	274	}
	275	#endif
	276	if (slot->curl != NULL)
	277	curl_easy_cleanup(slot->curl);
	278	slot = slot->next;
	279	}
	280
	281	#ifndef NO_CURL_EASY_DUPHANDLE
	282	curl_easy_cleanup(curl_default);
	283	#endif
	284
	285	#ifdef USE_CURL_MULTI
	286	curl_multi_cleanup(curlm);
	287	#endif
	288	curl_global_cleanup();
b3ca4e4e NH	289
b3ca4e4e NH	290	curl_slist_free_all(pragma_header);
29508e1e NH	291	}
29508e1e NH	292
29508e1e NH	293	struct active_request_slot *get_active_slot(void)
	294	{
	295	struct active_request_slot *slot = active_queue_head;
	296	struct active_request_slot *newslot;
	297
	298	#ifdef USE_CURL_MULTI
	299	int num_transfers;
	300
	301	/* Wait for a slot to open up if the queue is full */
	302	while (active_requests >= max_requests) {
	303	curl_multi_perform(curlm, &num_transfers);
	304	if (num_transfers < active_requests) {
	305	process_curl_messages();
	306	}
	307	}
	308	#endif
	309
	310	while (slot != NULL && slot->in_use) {
	311	slot = slot->next;
	312	}
	313	if (slot == NULL) {
	314	newslot = xmalloc(sizeof(*newslot));
	315	newslot->curl = NULL;
	316	newslot->in_use = 0;
	317	newslot->next = NULL;
	318
	319	slot = active_queue_head;
	320	if (slot == NULL) {
	321	active_queue_head = newslot;
	322	} else {
	323	while (slot->next != NULL) {
	324	slot = slot->next;
	325	}
	326	slot->next = newslot;
	327	}
	328	slot = newslot;
	329	}
	330
	331	if (slot->curl == NULL) {
	332	#ifdef NO_CURL_EASY_DUPHANDLE
	333	slot->curl = get_curl_handle();
	334	#else
	335	slot->curl = curl_easy_duphandle(curl_default);
	336	#endif
	337	}
	338
	339	active_requests++;
	340	slot->in_use = 1;
	341	slot->local = NULL;
c8568e13	342	slot->results = NULL;
baa7b67d	343	slot->finished = NULL;
29508e1e NH	344	slot->callback_data = NULL;
29508e1e NH	345	slot->callback_func = NULL;
9094950d	346	curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, NULL);
29508e1e	347	curl_easy_setopt(slot->curl, CURLOPT_HTTPHEADER, pragma_header);
29508e1e	348	curl_easy_setopt(slot->curl, CURLOPT_ERRORBUFFER, curl_errorstr);
9094950d NH	349	curl_easy_setopt(slot->curl, CURLOPT_CUSTOMREQUEST, NULL);
	350	curl_easy_setopt(slot->curl, CURLOPT_READFUNCTION, NULL);
	351	curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, NULL);
	352	curl_easy_setopt(slot->curl, CURLOPT_UPLOAD, 0);
	353	curl_easy_setopt(slot->curl, CURLOPT_HTTPGET, 1);
29508e1e NH	354
	355	return slot;
	356	}
	357
	358	int start_active_slot(struct active_request_slot *slot)
	359	{
	360	#ifdef USE_CURL_MULTI
	361	CURLMcode curlm_result = curl_multi_add_handle(curlm, slot->curl);
	362
	363	if (curlm_result != CURLM_OK &&
	364	curlm_result != CURLM_CALL_MULTI_PERFORM) {
	365	active_requests--;
	366	slot->in_use = 0;
	367	return 0;
	368	}
	369	#endif
	370	return 1;
	371	}
	372
	373	#ifdef USE_CURL_MULTI
	374	void step_active_slots(void)
	375	{
	376	int num_transfers;
	377	CURLMcode curlm_result;
	378
	379	do {
	380	curlm_result = curl_multi_perform(curlm, &num_transfers);
	381	} while (curlm_result == CURLM_CALL_MULTI_PERFORM);
	382	if (num_transfers < active_requests) {
	383	process_curl_messages();
	384	fill_active_slots();
	385	}
	386	}
	387	#endif
	388
	389	void run_active_slot(struct active_request_slot *slot)
	390	{
	391	#ifdef USE_CURL_MULTI
	392	long last_pos = 0;
	393	long current_pos;
	394	fd_set readfds;
	395	fd_set writefds;
	396	fd_set excfds;
	397	int max_fd;
	398	struct timeval select_timeout;
baa7b67d	399	int finished = 0;
29508e1e	400
baa7b67d NH	401	slot->finished = &finished;
baa7b67d NH	402	while (!finished) {
29508e1e NH	403	data_received = 0;
	404	step_active_slots();
	405
	406	if (!data_received && slot->local != NULL) {
	407	current_pos = ftell(slot->local);
	408	if (current_pos > last_pos)
	409	data_received++;
	410	last_pos = current_pos;
	411	}
	412
	413	if (slot->in_use && !data_received) {
	414	max_fd = 0;
	415	FD_ZERO(&readfds);
	416	FD_ZERO(&writefds);
	417	FD_ZERO(&excfds);
	418	select_timeout.tv_sec = 0;
	419	select_timeout.tv_usec = 50000;
	420	select(max_fd, &readfds, &writefds,
	421	&excfds, &select_timeout);
	422	}
	423	}
	424	#else
	425	while (slot->in_use) {
	426	slot->curl_result = curl_easy_perform(slot->curl);
	427	finish_active_slot(slot);
	428	}
	429	#endif
	430	}
	431
53f31389	432	static void closedown_active_slot(struct active_request_slot *slot)
29508e1e NH	433	{
	434	active_requests--;
	435	slot->in_use = 0;
53f31389 MW	436	}
	437
	438	void release_active_slot(struct active_request_slot *slot)
	439	{
	440	closedown_active_slot(slot);
	441	if (slot->curl) {
b3ca4e4e	442	#ifdef USE_CURL_MULTI
53f31389	443	curl_multi_remove_handle(curlm, slot->curl);
b3ca4e4e	444	#endif
53f31389 MW	445	curl_easy_cleanup(slot->curl);
	446	slot->curl = NULL;
	447	}
b3ca4e4e	448	#ifdef USE_CURL_MULTI
53f31389	449	fill_active_slots();
b3ca4e4e	450	#endif
53f31389 MW	451	}
	452
	453	static void finish_active_slot(struct active_request_slot *slot)
	454	{
	455	closedown_active_slot(slot);
29508e1e	456	curl_easy_getinfo(slot->curl, CURLINFO_HTTP_CODE, &slot->http_code);
c8568e13	457
baa7b67d NH	458	if (slot->finished != NULL)
	459	(*slot->finished) = 1;
	460
c8568e13 NH	461	/* Store slot results so they can be read after the slot is reused */
	462	if (slot->results != NULL) {
	463	slot->results->curl_result = slot->curl_result;
	464	slot->results->http_code = slot->http_code;
	465	}
	466
29508e1e NH	467	/* Run callback if appropriate */
	468	if (slot->callback_func != NULL) {
	469	slot->callback_func(slot->callback_data);
	470	}
	471	}
	472
	473	void finish_all_active_slots(void)
	474	{
	475	struct active_request_slot *slot = active_queue_head;
	476
	477	while (slot != NULL)
	478	if (slot->in_use) {
	479	run_active_slot(slot);
	480	slot = active_queue_head;
	481	} else {
	482	slot = slot->next;
	483	}
	484	}