Attempt to fix the IPv4/IPv6 problems once and for all
[deb_shairplay.git] / src / lib / httpd.c
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
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
39 int use_rtsp;
40
41 int max_connections;
42 int open_connections;
43 http_connection_t *connections;
44
45 /* These variables only edited mutex locked */
46 int running;
47 int joined;
48 thread_handle_t thread;
49 mutex_handle_t run_mutex;
50
51 /* Server fds for accepting connections */
52 int server_fd4;
53 int server_fd6;
54 };
55
56 httpd_t *
57 httpd_init(logger_t *logger, httpd_callbacks_t *callbacks, int max_connections, int use_rtsp)
58 {
59 httpd_t *httpd;
60
61 assert(logger);
62 assert(callbacks);
63 assert(max_connections > 0);
64
65 /* Allocate the httpd_t structure */
66 httpd = calloc(1, sizeof(httpd_t));
67 if (!httpd) {
68 return NULL;
69 }
70
71 httpd->use_rtsp = !!use_rtsp;
72 httpd->max_connections = max_connections;
73 httpd->connections = calloc(max_connections, sizeof(http_connection_t));
74 if (!httpd->connections) {
75 free(httpd);
76 return NULL;
77 }
78
79 /* Use the logger provided */
80 httpd->logger = logger;
81
82 /* Save callback pointers */
83 memcpy(&httpd->callbacks, callbacks, sizeof(httpd_callbacks_t));
84
85 /* Initial status joined */
86 httpd->running = 0;
87 httpd->joined = 1;
88
89 return httpd;
90 }
91
92 void
93 httpd_destroy(httpd_t *httpd)
94 {
95 if (httpd) {
96 httpd_stop(httpd);
97
98 free(httpd->connections);
99 free(httpd);
100 }
101 }
102
103 static void
104 httpd_add_connection(httpd_t *httpd, int fd, unsigned char *local, int local_len, unsigned char *remote, int remote_len)
105 {
106 int i;
107
108 for (i=0; i<httpd->max_connections; i++) {
109 if (!httpd->connections[i].connected) {
110 break;
111 }
112 }
113 if (i == httpd->max_connections) {
114 /* This code should never be reached, we do not select server_fds when full */
115 logger_log(httpd->logger, LOGGER_INFO, "Max connections reached");
116 shutdown(fd, SHUT_RDWR);
117 closesocket(fd);
118 return;
119 }
120
121 httpd->open_connections++;
122 httpd->connections[i].socket_fd = fd;
123 httpd->connections[i].connected = 1;
124 httpd->connections[i].user_data = httpd->callbacks.conn_init(httpd->callbacks.opaque, local, local_len, remote, remote_len);
125 }
126
127 static int
128 httpd_accept_connection(httpd_t *httpd, int server_fd, int is_ipv6)
129 {
130 struct sockaddr_storage remote_saddr;
131 socklen_t remote_saddrlen;
132 struct sockaddr_storage local_saddr;
133 socklen_t local_saddrlen;
134 unsigned char *local, *remote;
135 int local_len, remote_len;
136 int ret, fd;
137
138 remote_saddrlen = sizeof(remote_saddr);
139 fd = accept(server_fd, (struct sockaddr *)&remote_saddr, &remote_saddrlen);
140 if (fd == -1) {
141 /* FIXME: Error happened */
142 return -1;
143 }
144
145 local_saddrlen = sizeof(local_saddr);
146 ret = getsockname(fd, (struct sockaddr *)&local_saddr, &local_saddrlen);
147 if (ret == -1) {
148 closesocket(fd);
149 return 0;
150 }
151
152 logger_log(httpd->logger, LOGGER_INFO, "Accepted %s client on socket %d",
153 (is_ipv6 ? "IPv6" : "IPv4"), fd);
154 local = netutils_get_address(&local_saddr, &local_len);
155 remote = netutils_get_address(&remote_saddr, &remote_len);
156
157 httpd_add_connection(httpd, fd, local, local_len, remote, remote_len);
158 return 1;
159 }
160
161 static void
162 httpd_remove_connection(httpd_t *httpd, http_connection_t *connection)
163 {
164 if (connection->request) {
165 http_request_destroy(connection->request);
166 connection->request = NULL;
167 }
168 httpd->callbacks.conn_destroy(connection->user_data);
169 shutdown(connection->socket_fd, SHUT_WR);
170 closesocket(connection->socket_fd);
171 connection->connected = 0;
172 httpd->open_connections--;
173 }
174
175 static THREAD_RETVAL
176 httpd_thread(void *arg)
177 {
178 httpd_t *httpd = arg;
179 char buffer[1024];
180 int i;
181
182 assert(httpd);
183
184 while (1) {
185 fd_set rfds;
186 struct timeval tv;
187 int nfds=0;
188 int ret;
189
190 MUTEX_LOCK(httpd->run_mutex);
191 if (!httpd->running) {
192 MUTEX_UNLOCK(httpd->run_mutex);
193 break;
194 }
195 MUTEX_UNLOCK(httpd->run_mutex);
196
197 /* Set timeout value to 5ms */
198 tv.tv_sec = 1;
199 tv.tv_usec = 5000;
200
201 /* Get the correct nfds value and set rfds */
202 FD_ZERO(&rfds);
203 if (httpd->open_connections < httpd->max_connections) {
204 FD_SET(httpd->server_fd4, &rfds);
205 nfds = httpd->server_fd4+1;
206 if (httpd->server_fd6 != -1) {
207 FD_SET(httpd->server_fd6, &rfds);
208 if (nfds <= httpd->server_fd6) {
209 nfds = httpd->server_fd6+1;
210 }
211 }
212 }
213 for (i=0; i<httpd->max_connections; i++) {
214 int socket_fd;
215 if (!httpd->connections[i].connected) {
216 continue;
217 }
218 socket_fd = httpd->connections[i].socket_fd;
219 FD_SET(socket_fd, &rfds);
220 if (nfds <= socket_fd) {
221 nfds = socket_fd+1;
222 }
223 }
224
225 ret = select(nfds, &rfds, NULL, NULL, &tv);
226 if (ret == 0) {
227 /* Timeout happened */
228 continue;
229 } else if (ret == -1) {
230 /* FIXME: Error happened */
231 logger_log(httpd->logger, LOGGER_INFO, "Error in select");
232 break;
233 }
234
235 if (FD_ISSET(httpd->server_fd4, &rfds)) {
236 ret = httpd_accept_connection(httpd, httpd->server_fd4, 0);
237 if (ret == -1) {
238 break;
239 } else if (ret == 0) {
240 continue;
241 }
242 }
243 if (FD_ISSET(httpd->server_fd6, &rfds)) {
244 ret = httpd_accept_connection(httpd, httpd->server_fd6, 1);
245 if (ret == -1) {
246 break;
247 } else if (ret == 0) {
248 continue;
249 }
250 }
251 for (i=0; i<httpd->max_connections; i++) {
252 http_connection_t *connection = &httpd->connections[i];
253
254 if (!connection->connected) {
255 continue;
256 }
257 if (!FD_ISSET(connection->socket_fd, &rfds)) {
258 continue;
259 }
260
261 /* If not in the middle of request, allocate one */
262 if (!connection->request) {
263 connection->request = http_request_init(httpd->use_rtsp);
264 assert(connection->request);
265 }
266
267 logger_log(httpd->logger, LOGGER_DEBUG, "Receiving on socket %d", connection->socket_fd);
268 ret = recv(connection->socket_fd, buffer, sizeof(buffer), 0);
269 if (ret == 0) {
270 logger_log(httpd->logger, LOGGER_INFO, "Connection closed for socket %d", connection->socket_fd);
271 httpd_remove_connection(httpd, connection);
272 continue;
273 }
274
275 /* Parse HTTP request from data read from connection */
276 http_request_add_data(connection->request, buffer, ret);
277 if (http_request_has_error(connection->request)) {
278 logger_log(httpd->logger, LOGGER_INFO, "Error in parsing: %s", http_request_get_error_name(connection->request));
279 httpd_remove_connection(httpd, connection);
280 continue;
281 }
282
283 /* If request is finished, process and deallocate */
284 if (http_request_is_complete(connection->request)) {
285 http_response_t *response = NULL;
286
287 httpd->callbacks.conn_request(connection->user_data, connection->request, &response);
288 http_request_destroy(connection->request);
289 connection->request = NULL;
290
291 if (response) {
292 const char *data;
293 int datalen;
294 int written;
295 int ret;
296
297 /* Get response data and datalen */
298 data = http_response_get_data(response, &datalen);
299
300 written = 0;
301 while (written < datalen) {
302 ret = send(connection->socket_fd, data+written, datalen-written, 0);
303 if (ret == -1) {
304 /* FIXME: Error happened */
305 logger_log(httpd->logger, LOGGER_INFO, "Error in sending data");
306 break;
307 }
308 written += ret;
309 }
310 } else {
311 logger_log(httpd->logger, LOGGER_INFO, "Didn't get response");
312 }
313 http_response_destroy(response);
314 }
315 }
316 }
317
318 /* Remove all connections that are still connected */
319 for (i=0; i<httpd->max_connections; i++) {
320 http_connection_t *connection = &httpd->connections[i];
321
322 if (!connection->connected) {
323 continue;
324 }
325 logger_log(httpd->logger, LOGGER_INFO, "Removing connection for socket %d", connection->socket_fd);
326 httpd_remove_connection(httpd, connection);
327 }
328
329 logger_log(httpd->logger, LOGGER_INFO, "Exiting HTTP thread");
330
331 return 0;
332 }
333
334 int
335 httpd_start(httpd_t *httpd, unsigned short *port)
336 {
337 assert(httpd);
338 assert(port);
339
340 MUTEX_LOCK(httpd->run_mutex);
341 if (httpd->running || !httpd->joined) {
342 MUTEX_UNLOCK(httpd->run_mutex);
343 return 0;
344 }
345
346 httpd->server_fd4 = netutils_init_socket(port, 0, 0);
347 if (httpd->server_fd4 == -1) {
348 logger_log(httpd->logger, LOGGER_ERR, "Error initialising socket %d", SOCKET_GET_ERROR());
349 MUTEX_UNLOCK(httpd->run_mutex);
350 return -1;
351 }
352 httpd->server_fd6 = netutils_init_socket(port, 1, 0);
353 if (httpd->server_fd6 == -1) {
354 logger_log(httpd->logger, LOGGER_WARNING, "Error initialising IPv6 socket %d", SOCKET_GET_ERROR());
355 logger_log(httpd->logger, LOGGER_WARNING, "Continuing without IPv6 support");
356 }
357
358 if (listen(httpd->server_fd4, 5) == -1) {
359 logger_log(httpd->logger, LOGGER_ERR, "Error listening to IPv4 socket");
360 closesocket(httpd->server_fd4);
361 closesocket(httpd->server_fd6);
362 MUTEX_UNLOCK(httpd->run_mutex);
363 return -2;
364 }
365 if (httpd->server_fd6 != -1 && listen(httpd->server_fd6, 5) == -1) {
366 logger_log(httpd->logger, LOGGER_ERR, "Error listening to IPv6 socket");
367 closesocket(httpd->server_fd4);
368 closesocket(httpd->server_fd6);
369 MUTEX_UNLOCK(httpd->run_mutex);
370 return -2;
371 }
372 logger_log(httpd->logger, LOGGER_INFO, "Initialized server socket(s)");
373
374 /* Set values correctly and create new thread */
375 httpd->running = 1;
376 httpd->joined = 0;
377 THREAD_CREATE(httpd->thread, httpd_thread, httpd);
378 MUTEX_UNLOCK(httpd->run_mutex);
379
380 return 1;
381 }
382
383 int
384 httpd_is_running(httpd_t *httpd)
385 {
386 int running;
387
388 assert(httpd);
389
390 MUTEX_LOCK(httpd->run_mutex);
391 running = httpd->running || !httpd->joined;
392 MUTEX_UNLOCK(httpd->run_mutex);
393
394 return running;
395 }
396
397 void
398 httpd_stop(httpd_t *httpd)
399 {
400 assert(httpd);
401
402 MUTEX_LOCK(httpd->run_mutex);
403 if (!httpd->running || httpd->joined) {
404 MUTEX_UNLOCK(httpd->run_mutex);
405 return;
406 }
407 httpd->running = 0;
408 MUTEX_UNLOCK(httpd->run_mutex);
409
410 THREAD_JOIN(httpd->thread);
411
412 MUTEX_LOCK(httpd->run_mutex);
413 httpd->joined = 1;
414 MUTEX_UNLOCK(httpd->run_mutex);
415 }
416