[deb_shairplay.git] / src / lib / httpd.c

/**
 *  Copyright (C) 2011-2012  Juho Vähä-Herttua
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Lesser General Public
 *  License as published by the Free Software Foundation; either
 *  version 2.1 of the License, or (at your option) any later version.
 *
 *  This library is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  Lesser General Public License for more details.
 */

#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <assert.h>

#include "httpd.h"
#include "netutils.h"
#include "http_request.h"
#include "compat.h"
#include "logger.h"

struct http_connection_s {
	int connected;

	int socket_fd;
	void *user_data;
	http_request_t *request;
};
typedef struct http_connection_s http_connection_t;

struct httpd_s {
	logger_t *logger;
	httpd_callbacks_t callbacks;

	int max_connections;
	int open_connections;
	http_connection_t *connections;

	/* These variables only edited mutex locked */
	int running;
	int joined;
	thread_handle_t thread;
	mutex_handle_t run_mutex;

	/* Server fds for accepting connections */
	int server_fd4;
	int server_fd6;
};

httpd_t *
httpd_init(logger_t *logger, httpd_callbacks_t *callbacks, int max_connections)
{
	httpd_t *httpd;

	assert(logger);
	assert(callbacks);
	assert(max_connections > 0);

	/* Allocate the httpd_t structure */
	httpd = calloc(1, sizeof(httpd_t));
	if (!httpd) {
		return NULL;
	}

	httpd->max_connections = max_connections;
	httpd->connections = calloc(max_connections, sizeof(http_connection_t));
	if (!httpd->connections) {
		free(httpd);
		return NULL;
	}

	/* Use the logger provided */
	httpd->logger = logger;

	/* Save callback pointers */
	memcpy(&httpd->callbacks, callbacks, sizeof(httpd_callbacks_t));

	/* Initial status joined */
	httpd->running = 0;
	httpd->joined = 1;

	return httpd;
}

void
httpd_destroy(httpd_t *httpd)
{
	if (httpd) {
		httpd_stop(httpd);

		free(httpd->connections);
		free(httpd);
	}
}

static void
httpd_add_connection(httpd_t *httpd, int fd, unsigned char *local, int local_len, unsigned char *remote, int remote_len)
{
	int i;

	for (i=0; i<httpd->max_connections; i++) {
		if (!httpd->connections[i].connected) {
			break;
		}
	}
	if (i == httpd->max_connections) {
		/* This code should never be reached, we do not select server_fds when full */
		logger_log(httpd->logger, LOGGER_INFO, "Max connections reached");
		shutdown(fd, SHUT_RDWR);
		closesocket(fd);
		return;
	}

	httpd->open_connections++;
	httpd->connections[i].socket_fd = fd;
	httpd->connections[i].connected = 1;
	httpd->connections[i].user_data = httpd->callbacks.conn_init(httpd->callbacks.opaque, local, local_len, remote, remote_len);
}

static int
httpd_accept_connection(httpd_t *httpd, int server_fd, int is_ipv6)
{
	struct sockaddr_storage remote_saddr;
	socklen_t remote_saddrlen;
	struct sockaddr_storage local_saddr;
	socklen_t local_saddrlen;
	unsigned char *local, *remote;
	int local_len, remote_len;
	int ret, fd;

	remote_saddrlen = sizeof(remote_saddr);
	fd = accept(server_fd, (struct sockaddr *)&remote_saddr, &remote_saddrlen);
	if (fd == -1) {
		/* FIXME: Error happened */
		return -1;
	}

	local_saddrlen = sizeof(local_saddr);
	ret = getsockname(fd, (struct sockaddr *)&local_saddr, &local_saddrlen);
	if (ret == -1) {
		closesocket(fd);
		return 0;
	}

	logger_log(httpd->logger, LOGGER_INFO, "Accepted %s client on socket %d",
	           (is_ipv6 ? "IPv6"  : "IPv4"), fd);
	local = netutils_get_address(&local_saddr, &local_len);
	remote = netutils_get_address(&remote_saddr, &remote_len);

	httpd_add_connection(httpd, fd, local, local_len, remote, remote_len);
	return 1;
}

static void
httpd_remove_connection(httpd_t *httpd, http_connection_t *connection)
{
	if (connection->request) {
		http_request_destroy(connection->request);
		connection->request = NULL;
	}
	httpd->callbacks.conn_destroy(connection->user_data);
	shutdown(connection->socket_fd, SHUT_WR);
	closesocket(connection->socket_fd);
	connection->connected = 0;
	httpd->open_connections--;
}

static THREAD_RETVAL
httpd_thread(void *arg)
{
	httpd_t *httpd = arg;
	char buffer[1024];
	int i;

	assert(httpd);

	while (1) {
		fd_set rfds;
		struct timeval tv;
		int nfds=0;
		int ret;

		MUTEX_LOCK(httpd->run_mutex);
		if (!httpd->running) {
			MUTEX_UNLOCK(httpd->run_mutex);
			break;
		}
		MUTEX_UNLOCK(httpd->run_mutex);

		/* Set timeout value to 5ms */
		tv.tv_sec = 1;
		tv.tv_usec = 5000;

		/* Get the correct nfds value and set rfds */
		FD_ZERO(&rfds);
		if (httpd->open_connections < httpd->max_connections) {
			FD_SET(httpd->server_fd4, &rfds);
			nfds = httpd->server_fd4+1;
			if (httpd->server_fd6 != -1) {
				FD_SET(httpd->server_fd6, &rfds);
				if (nfds <= httpd->server_fd6) {
					nfds = httpd->server_fd6+1;
				}
			}
		}
		for (i=0; i<httpd->max_connections; i++) {
			int socket_fd;
			if (!httpd->connections[i].connected) {
				continue;
			}
			socket_fd = httpd->connections[i].socket_fd;
			FD_SET(socket_fd, &rfds);
			if (nfds <= socket_fd) {
				nfds = socket_fd+1;
			}
		}

		ret = select(nfds, &rfds, NULL, NULL, &tv);
		if (ret == 0) {
			/* Timeout happened */
			continue;
		} else if (ret == -1) {
			/* FIXME: Error happened */
			logger_log(httpd->logger, LOGGER_INFO, "Error in select");
			break;
		}

		if (FD_ISSET(httpd->server_fd4, &rfds)) {
			ret = httpd_accept_connection(httpd, httpd->server_fd4, 0);
			if (ret == -1) {
				break;
			} else if (ret == 0) {
				continue;
			}
		}
		if (httpd->server_fd6 != -1 && FD_ISSET(httpd->server_fd6, &rfds)) {
			ret = httpd_accept_connection(httpd, httpd->server_fd6, 1);
			if (ret == -1) {
				break;
			} else if (ret == 0) {
				continue;
			}
		}
		for (i=0; i<httpd->max_connections; i++) {
			http_connection_t *connection = &httpd->connections[i];

			if (!connection->connected) {
				continue;
			}
			if (!FD_ISSET(connection->socket_fd, &rfds)) {
				continue;
			}

			/* If not in the middle of request, allocate one */
			if (!connection->request) {
				connection->request = http_request_init();
				assert(connection->request);
			}

			logger_log(httpd->logger, LOGGER_DEBUG, "Receiving on socket %d", connection->socket_fd);
			ret = recv(connection->socket_fd, buffer, sizeof(buffer), 0);
			if (ret == 0) {
				logger_log(httpd->logger, LOGGER_INFO, "Connection closed for socket %d", connection->socket_fd);
				httpd_remove_connection(httpd, connection);
				continue;
			}

			/* Parse HTTP request from data read from connection */
			http_request_add_data(connection->request, buffer, ret);
			if (http_request_has_error(connection->request)) {
				logger_log(httpd->logger, LOGGER_INFO, "Error in parsing: %s", http_request_get_error_name(connection->request));
				httpd_remove_connection(httpd, connection);
				continue;
			}

			/* If request is finished, process and deallocate */
			if (http_request_is_complete(connection->request)) {
				http_response_t *response = NULL;

				httpd->callbacks.conn_request(connection->user_data, connection->request, &response);
				http_request_destroy(connection->request);
				connection->request = NULL;

				if (response) {
					const char *data;
					int datalen;
					int written;
					int ret;

					/* Get response data and datalen */
					data = http_response_get_data(response, &datalen);

					written = 0;
					while (written < datalen) {
						ret = send(connection->socket_fd, data+written, datalen-written, 0);
						if (ret == -1) {
							/* FIXME: Error happened */
							logger_log(httpd->logger, LOGGER_INFO, "Error in sending data");
							break;
						}
						written += ret;
					}

					if (http_response_get_disconnect(response)) {
						logger_log(httpd->logger, LOGGER_INFO, "Disconnecting on software request");
						httpd_remove_connection(httpd, connection);
					}
				} else {
					logger_log(httpd->logger, LOGGER_INFO, "Didn't get response");
				}
				http_response_destroy(response);
			} else {
				logger_log(httpd->logger, LOGGER_DEBUG, "Request not complete, waiting for more data...");
			}
		}
	}

	/* Remove all connections that are still connected */
	for (i=0; i<httpd->max_connections; i++) {
		http_connection_t *connection = &httpd->connections[i];

		if (!connection->connected) {
			continue;
		}
		logger_log(httpd->logger, LOGGER_INFO, "Removing connection for socket %d", connection->socket_fd);
		httpd_remove_connection(httpd, connection);
	}

	/* Close server sockets since they are not used any more */
	if (httpd->server_fd4 != -1) {
		closesocket(httpd->server_fd4);
		httpd->server_fd4 = -1;
	}
	if (httpd->server_fd6 != -1) {
		closesocket(httpd->server_fd6);
		httpd->server_fd6 = -1;
	}

	logger_log(httpd->logger, LOGGER_INFO, "Exiting HTTP thread");

	return 0;
}

int
httpd_start(httpd_t *httpd, unsigned short *port)
{
	assert(httpd);
	assert(port);

	MUTEX_LOCK(httpd->run_mutex);
	if (httpd->running || !httpd->joined) {
		MUTEX_UNLOCK(httpd->run_mutex);
		return 0;
	}

	httpd->server_fd4 = netutils_init_socket(port, 0, 0);
	if (httpd->server_fd4 == -1) {
		logger_log(httpd->logger, LOGGER_ERR, "Error initialising socket %d", SOCKET_GET_ERROR());
		MUTEX_UNLOCK(httpd->run_mutex);
		return -1;
	}
	httpd->server_fd6 = netutils_init_socket(port, 1, 0);
	if (httpd->server_fd6 == -1) {
		logger_log(httpd->logger, LOGGER_WARNING, "Error initialising IPv6 socket %d", SOCKET_GET_ERROR());
		logger_log(httpd->logger, LOGGER_WARNING, "Continuing without IPv6 support");
	}

	if (listen(httpd->server_fd4, 5) == -1) {
		logger_log(httpd->logger, LOGGER_ERR, "Error listening to IPv4 socket");
		closesocket(httpd->server_fd4);
		closesocket(httpd->server_fd6);
		MUTEX_UNLOCK(httpd->run_mutex);
		return -2;
	}
	if (httpd->server_fd6 != -1 && listen(httpd->server_fd6, 5) == -1) {
		logger_log(httpd->logger, LOGGER_ERR, "Error listening to IPv6 socket");
		closesocket(httpd->server_fd4);
		closesocket(httpd->server_fd6);
		MUTEX_UNLOCK(httpd->run_mutex);
		return -2;
	}
	logger_log(httpd->logger, LOGGER_INFO, "Initialized server socket(s)");

	/* Set values correctly and create new thread */
	httpd->running = 1;
	httpd->joined = 0;
	THREAD_CREATE(httpd->thread, httpd_thread, httpd);
	MUTEX_UNLOCK(httpd->run_mutex);

	return 1;
}

int
httpd_is_running(httpd_t *httpd)
{
	int running;

	assert(httpd);

	MUTEX_LOCK(httpd->run_mutex);
	running = httpd->running || !httpd->joined;
	MUTEX_UNLOCK(httpd->run_mutex);

	return running;
}

void
httpd_stop(httpd_t *httpd)
{
	assert(httpd);

	MUTEX_LOCK(httpd->run_mutex);
	if (!httpd->running || httpd->joined) {
		MUTEX_UNLOCK(httpd->run_mutex);
		return;
	}
	httpd->running = 0;
	MUTEX_UNLOCK(httpd->run_mutex);

	THREAD_JOIN(httpd->thread);

	MUTEX_LOCK(httpd->run_mutex);
	httpd->joined = 1;
	MUTEX_UNLOCK(httpd->run_mutex);
}
Commit	Line	Data
23e7e3ae JVH	1	/**
	2	* Copyright (C) 2011-2012 Juho Vähä-Herttua
	3	*
	4	* This library is free software; you can redistribute it and/or
	5	* modify it under the terms of the GNU Lesser General Public
	6	* License as published by the Free Software Foundation; either
	7	* version 2.1 of the License, or (at your option) any later version.
	8	*
	9	* This library is distributed in the hope that it will be useful,
	10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	12	* Lesser General Public License for more details.
	13	*/
	14
2340bcd3 JVH	15	#include <stdlib.h>
	16	#include <string.h>
	17	#include <stdio.h>
	18	#include <assert.h>
	19
	20	#include "httpd.h"
	21	#include "netutils.h"
	22	#include "http_request.h"
	23	#include "compat.h"
	24	#include "logger.h"
	25
	26	struct http_connection_s {
	27	int connected;
	28
	29	int socket_fd;
	30	void *user_data;
	31	http_request_t *request;
	32	};
	33	typedef struct http_connection_s http_connection_t;
	34
	35	struct httpd_s {
	36	logger_t *logger;
	37	httpd_callbacks_t callbacks;
	38
2340bcd3	39	int max_connections;
c457d545	40	int open_connections;
2340bcd3 JVH	41	http_connection_t *connections;
	42
	43	/* These variables only edited mutex locked */
	44	int running;
	45	int joined;
	46	thread_handle_t thread;
	47	mutex_handle_t run_mutex;
	48
870f342f JVH	49	/* Server fds for accepting connections */
	50	int server_fd4;
	51	int server_fd6;
2340bcd3 JVH	52	};
	53
	54	httpd_t *
462c72aa	55	httpd_init(logger_t logger, httpd_callbacks_t callbacks, int max_connections)
2340bcd3 JVH	56	{
	57	httpd_t *httpd;
	58
	59	assert(logger);
	60	assert(callbacks);
	61	assert(max_connections > 0);
	62
	63	/* Allocate the httpd_t structure */
	64	httpd = calloc(1, sizeof(httpd_t));
	65	if (!httpd) {
	66	return NULL;
	67	}
	68
2340bcd3 JVH	69	httpd->max_connections = max_connections;
	70	httpd->connections = calloc(max_connections, sizeof(http_connection_t));
	71	if (!httpd->connections) {
	72	free(httpd);
	73	return NULL;
	74	}
	75
	76	/* Use the logger provided */
	77	httpd->logger = logger;
	78
	79	/* Save callback pointers */
	80	memcpy(&httpd->callbacks, callbacks, sizeof(httpd_callbacks_t));
	81
	82	/* Initial status joined */
	83	httpd->running = 0;
	84	httpd->joined = 1;
	85
	86	return httpd;
	87	}
	88
	89	void
	90	httpd_destroy(httpd_t *httpd)
	91	{
	92	if (httpd) {
	93	httpd_stop(httpd);
	94
	95	free(httpd->connections);
	96	free(httpd);
	97	}
	98	}
	99
	100	static void
	101	httpd_add_connection(httpd_t httpd, int fd, unsigned char local, int local_len, unsigned char *remote, int remote_len)
	102	{
	103	int i;
	104
	105	for (i=0; i<httpd->max_connections; i++) {
	106	if (!httpd->connections[i].connected) {
	107	break;
	108	}
	109	}
	110	if (i == httpd->max_connections) {
870f342f	111	/* This code should never be reached, we do not select server_fds when full */
46212791	112	logger_log(httpd->logger, LOGGER_INFO, "Max connections reached");
2340bcd3 JVH	113	shutdown(fd, SHUT_RDWR);
	114	closesocket(fd);
	115	return;
	116	}
	117
c457d545	118	httpd->open_connections++;
2340bcd3 JVH	119	httpd->connections[i].socket_fd = fd;
	120	httpd->connections[i].connected = 1;
	121	httpd->connections[i].user_data = httpd->callbacks.conn_init(httpd->callbacks.opaque, local, local_len, remote, remote_len);
	122	}
	123
870f342f JVH	124	static int
	125	httpd_accept_connection(httpd_t *httpd, int server_fd, int is_ipv6)
	126	{
	127	struct sockaddr_storage remote_saddr;
	128	socklen_t remote_saddrlen;
	129	struct sockaddr_storage local_saddr;
	130	socklen_t local_saddrlen;
	131	unsigned char local, remote;
	132	int local_len, remote_len;
	133	int ret, fd;
	134
	135	remote_saddrlen = sizeof(remote_saddr);
	136	fd = accept(server_fd, (struct sockaddr *)&remote_saddr, &remote_saddrlen);
	137	if (fd == -1) {
	138	/* FIXME: Error happened */
	139	return -1;
	140	}
	141
	142	local_saddrlen = sizeof(local_saddr);
	143	ret = getsockname(fd, (struct sockaddr *)&local_saddr, &local_saddrlen);
	144	if (ret == -1) {
	145	closesocket(fd);
	146	return 0;
	147	}
	148
	149	logger_log(httpd->logger, LOGGER_INFO, "Accepted %s client on socket %d",
	150	(is_ipv6 ? "IPv6" : "IPv4"), fd);
	151	local = netutils_get_address(&local_saddr, &local_len);
	152	remote = netutils_get_address(&remote_saddr, &remote_len);
	153
	154	httpd_add_connection(httpd, fd, local, local_len, remote, remote_len);
	155	return 1;
	156	}
	157
2340bcd3 JVH	158	static void
	159	httpd_remove_connection(httpd_t httpd, http_connection_t connection)
	160	{
	161	if (connection->request) {
	162	http_request_destroy(connection->request);
	163	connection->request = NULL;
	164	}
	165	httpd->callbacks.conn_destroy(connection->user_data);
	166	shutdown(connection->socket_fd, SHUT_WR);
	167	closesocket(connection->socket_fd);
	168	connection->connected = 0;
c457d545	169	httpd->open_connections--;
2340bcd3 JVH	170	}
	171
	172	static THREAD_RETVAL
	173	httpd_thread(void *arg)
	174	{
	175	httpd_t *httpd = arg;
	176	char buffer[1024];
	177	int i;
	178
	179	assert(httpd);
	180
	181	while (1) {
	182	fd_set rfds;
	183	struct timeval tv;
	184	int nfds=0;
	185	int ret;
	186
	187	MUTEX_LOCK(httpd->run_mutex);
	188	if (!httpd->running) {
	189	MUTEX_UNLOCK(httpd->run_mutex);
	190	break;
	191	}
	192	MUTEX_UNLOCK(httpd->run_mutex);
	193
	194	/* Set timeout value to 5ms */
	195	tv.tv_sec = 1;
	196	tv.tv_usec = 5000;
	197
	198	/* Get the correct nfds value and set rfds */
	199	FD_ZERO(&rfds);
c457d545	200	if (httpd->open_connections < httpd->max_connections) {
870f342f JVH	201	FD_SET(httpd->server_fd4, &rfds);
	202	nfds = httpd->server_fd4+1;
	203	if (httpd->server_fd6 != -1) {
	204	FD_SET(httpd->server_fd6, &rfds);
	205	if (nfds <= httpd->server_fd6) {
	206	nfds = httpd->server_fd6+1;
	207	}
	208	}
c457d545	209	}
2340bcd3 JVH	210	for (i=0; i<httpd->max_connections; i++) {
	211	int socket_fd;
	212	if (!httpd->connections[i].connected) {
	213	continue;
	214	}
	215	socket_fd = httpd->connections[i].socket_fd;
	216	FD_SET(socket_fd, &rfds);
	217	if (nfds <= socket_fd) {
	218	nfds = socket_fd+1;
	219	}
	220	}
	221
	222	ret = select(nfds, &rfds, NULL, NULL, &tv);
	223	if (ret == 0) {
	224	/* Timeout happened */
	225	continue;
	226	} else if (ret == -1) {
	227	/* FIXME: Error happened */
46212791	228	logger_log(httpd->logger, LOGGER_INFO, "Error in select");
2340bcd3 JVH	229	break;
	230	}
	231
870f342f JVH	232	if (FD_ISSET(httpd->server_fd4, &rfds)) {
	233	ret = httpd_accept_connection(httpd, httpd->server_fd4, 0);
	234	if (ret == -1) {
2340bcd3	235	break;
870f342f JVH	236	} else if (ret == 0) {
870f342f JVH	237	continue;
2340bcd3	238	}
870f342f	239	}
2e66aa96	240	if (httpd->server_fd6 != -1 && FD_ISSET(httpd->server_fd6, &rfds)) {
870f342f	241	ret = httpd_accept_connection(httpd, httpd->server_fd6, 1);
2340bcd3	242	if (ret == -1) {
870f342f JVH	243	break;
870f342f JVH	244	} else if (ret == 0) {
2340bcd3 JVH	245	continue;
2340bcd3 JVH	246	}
2340bcd3 JVH	247	}
	248	for (i=0; i<httpd->max_connections; i++) {
	249	http_connection_t *connection = &httpd->connections[i];
	250
	251	if (!connection->connected) {
	252	continue;
	253	}
	254	if (!FD_ISSET(connection->socket_fd, &rfds)) {
	255	continue;
	256	}
	257
	258	/* If not in the middle of request, allocate one */
	259	if (!connection->request) {
462c72aa	260	connection->request = http_request_init();
2340bcd3 JVH	261	assert(connection->request);
	262	}
	263
46212791	264	logger_log(httpd->logger, LOGGER_DEBUG, "Receiving on socket %d", connection->socket_fd);
2340bcd3 JVH	265	ret = recv(connection->socket_fd, buffer, sizeof(buffer), 0);
2340bcd3 JVH	266	if (ret == 0) {
46212791	267	logger_log(httpd->logger, LOGGER_INFO, "Connection closed for socket %d", connection->socket_fd);
2340bcd3 JVH	268	httpd_remove_connection(httpd, connection);
	269	continue;
	270	}
	271
	272	/* Parse HTTP request from data read from connection */
	273	http_request_add_data(connection->request, buffer, ret);
	274	if (http_request_has_error(connection->request)) {
46212791	275	logger_log(httpd->logger, LOGGER_INFO, "Error in parsing: %s", http_request_get_error_name(connection->request));
2340bcd3 JVH	276	httpd_remove_connection(httpd, connection);
	277	continue;
	278	}
	279
	280	/* If request is finished, process and deallocate */
	281	if (http_request_is_complete(connection->request)) {
	282	http_response_t *response = NULL;
	283
	284	httpd->callbacks.conn_request(connection->user_data, connection->request, &response);
	285	http_request_destroy(connection->request);
	286	connection->request = NULL;
	287
	288	if (response) {
	289	const char *data;
	290	int datalen;
	291	int written;
	292	int ret;
	293
	294	/* Get response data and datalen */
	295	data = http_response_get_data(response, &datalen);
	296
	297	written = 0;
	298	while (written < datalen) {
	299	ret = send(connection->socket_fd, data+written, datalen-written, 0);
	300	if (ret == -1) {
	301	/* FIXME: Error happened */
46212791	302	logger_log(httpd->logger, LOGGER_INFO, "Error in sending data");
2340bcd3 JVH	303	break;
	304	}
	305	written += ret;
	306	}
c5f65268 JVH	307
	308	if (http_response_get_disconnect(response)) {
	309	logger_log(httpd->logger, LOGGER_INFO, "Disconnecting on software request");
	310	httpd_remove_connection(httpd, connection);
	311	}
2340bcd3	312	} else {
46212791	313	logger_log(httpd->logger, LOGGER_INFO, "Didn't get response");
2340bcd3 JVH	314	}
2340bcd3 JVH	315	http_response_destroy(response);
20e91d6c JVH	316	} else {
20e91d6c JVH	317	logger_log(httpd->logger, LOGGER_DEBUG, "Request not complete, waiting for more data...");
2340bcd3 JVH	318	}
	319	}
	320	}
	321
	322	/* Remove all connections that are still connected */
	323	for (i=0; i<httpd->max_connections; i++) {
	324	http_connection_t *connection = &httpd->connections[i];
	325
	326	if (!connection->connected) {
	327	continue;
	328	}
46212791	329	logger_log(httpd->logger, LOGGER_INFO, "Removing connection for socket %d", connection->socket_fd);
2340bcd3 JVH	330	httpd_remove_connection(httpd, connection);
	331	}
	332
1321b5e9 JVH	333	/* Close server sockets since they are not used any more */
	334	if (httpd->server_fd4 != -1) {
	335	closesocket(httpd->server_fd4);
	336	httpd->server_fd4 = -1;
	337	}
	338	if (httpd->server_fd6 != -1) {
	339	closesocket(httpd->server_fd6);
	340	httpd->server_fd6 = -1;
	341	}
	342
46212791	343	logger_log(httpd->logger, LOGGER_INFO, "Exiting HTTP thread");
2340bcd3 JVH	344
	345	return 0;
	346	}
	347
	348	int
	349	httpd_start(httpd_t httpd, unsigned short port)
	350	{
	351	assert(httpd);
	352	assert(port);
	353
	354	MUTEX_LOCK(httpd->run_mutex);
	355	if (httpd->running \|\| !httpd->joined) {
	356	MUTEX_UNLOCK(httpd->run_mutex);
	357	return 0;
	358	}
	359
870f342f JVH	360	httpd->server_fd4 = netutils_init_socket(port, 0, 0);
	361	if (httpd->server_fd4 == -1) {
	362	logger_log(httpd->logger, LOGGER_ERR, "Error initialising socket %d", SOCKET_GET_ERROR());
2340bcd3 JVH	363	MUTEX_UNLOCK(httpd->run_mutex);
	364	return -1;
	365	}
870f342f JVH	366	httpd->server_fd6 = netutils_init_socket(port, 1, 0);
	367	if (httpd->server_fd6 == -1) {
	368	logger_log(httpd->logger, LOGGER_WARNING, "Error initialising IPv6 socket %d", SOCKET_GET_ERROR());
	369	logger_log(httpd->logger, LOGGER_WARNING, "Continuing without IPv6 support");
	370	}
	371
	372	if (listen(httpd->server_fd4, 5) == -1) {
	373	logger_log(httpd->logger, LOGGER_ERR, "Error listening to IPv4 socket");
	374	closesocket(httpd->server_fd4);
	375	closesocket(httpd->server_fd6);
	376	MUTEX_UNLOCK(httpd->run_mutex);
	377	return -2;
	378	}
	379	if (httpd->server_fd6 != -1 && listen(httpd->server_fd6, 5) == -1) {
	380	logger_log(httpd->logger, LOGGER_ERR, "Error listening to IPv6 socket");
	381	closesocket(httpd->server_fd4);
	382	closesocket(httpd->server_fd6);
2340bcd3 JVH	383	MUTEX_UNLOCK(httpd->run_mutex);
	384	return -2;
	385	}
870f342f	386	logger_log(httpd->logger, LOGGER_INFO, "Initialized server socket(s)");
2340bcd3 JVH	387
	388	/* Set values correctly and create new thread */
	389	httpd->running = 1;
	390	httpd->joined = 0;
	391	THREAD_CREATE(httpd->thread, httpd_thread, httpd);
	392	MUTEX_UNLOCK(httpd->run_mutex);
	393
	394	return 1;
	395	}
	396
5a746b97 JVH	397	int
	398	httpd_is_running(httpd_t *httpd)
	399	{
	400	int running;
	401
	402	assert(httpd);
	403
	404	MUTEX_LOCK(httpd->run_mutex);
	405	running = httpd->running \|\| !httpd->joined;
	406	MUTEX_UNLOCK(httpd->run_mutex);
	407
	408	return running;
	409	}
	410
2340bcd3 JVH	411	void
	412	httpd_stop(httpd_t *httpd)
	413	{
	414	assert(httpd);
	415
	416	MUTEX_LOCK(httpd->run_mutex);
	417	if (!httpd->running \|\| httpd->joined) {
	418	MUTEX_UNLOCK(httpd->run_mutex);
	419	return;
	420	}
	421	httpd->running = 0;
	422	MUTEX_UNLOCK(httpd->run_mutex);
	423
	424	THREAD_JOIN(httpd->thread);
	425
	426	MUTEX_LOCK(httpd->run_mutex);
	427	httpd->joined = 1;
	428	MUTEX_UNLOCK(httpd->run_mutex);
	429	}
	430