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 max_connections;
  40         int open_connections;
  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
  49         /* Server fds for accepting connections */
  50         int server_fd4;
  51         int server_fd6;
  52 };
  53
  54 httpd_t *
  55 httpd_init(logger_t *logger, httpd_callbacks_t *callbacks, int max_connections)
  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
  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) {
 111                 /* This code should never be reached, we do not select server_fds when full */
 112                 logger_log(httpd->logger, LOGGER_INFO, "Max connections reached");
 113                 shutdown(fd, SHUT_RDWR);
 114                 closesocket(fd);
 115                 return;
 116         }
 117
 118         httpd->open_connections++;
 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
 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
 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;
 169         httpd->open_connections--;
 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);
 200                 if (httpd->open_connections < httpd->max_connections) {
 201                         if (httpd->server_fd4 != -1) {
 202                                 FD_SET(httpd->server_fd4, &rfds);
 203                                 if (nfds <= httpd->server_fd4) {
 204                                         nfds = httpd->server_fd4+1;
 205                                 }
 206                         }
 207                         if (httpd->server_fd6 != -1) {
 208                                 FD_SET(httpd->server_fd6, &rfds);
 209                                 if (nfds <= httpd->server_fd6) {
 210                                         nfds = httpd->server_fd6+1;
 211                                 }
 212                         }
 213                 }
 214                 for (i=0; i<httpd->max_connections; i++) {
 215                         int socket_fd;
 216                         if (!httpd->connections[i].connected) {
 217                                 continue;
 218                         }
 219                         socket_fd = httpd->connections[i].socket_fd;
 220                         FD_SET(socket_fd, &rfds);
 221                         if (nfds <= socket_fd) {
 222                                 nfds = socket_fd+1;
 223                         }
 224                 }
 225
 226                 ret = select(nfds, &rfds, NULL, NULL, &tv);
 227                 if (ret == 0) {
 228                         /* Timeout happened */
 229                         continue;
 230                 } else if (ret == -1) {
 231                         /* FIXME: Error happened */
 232                         logger_log(httpd->logger, LOGGER_INFO, "Error in select");
 233                         break;
 234                 }
 235
 236                 if (httpd->open_connections < httpd->max_connections &&
 237                     httpd->server_fd4 != -1 && FD_ISSET(httpd->server_fd4, &rfds)) {
 238                         ret = httpd_accept_connection(httpd, httpd->server_fd4, 0);
 239                         if (ret == -1) {
 240                                 break;
 241                         } else if (ret == 0) {
 242                                 continue;
 243                         }
 244                 }
 245                 if (httpd->open_connections < httpd->max_connections &&
 246                     httpd->server_fd6 != -1 && FD_ISSET(httpd->server_fd6, &rfds)) {
 247                         ret = httpd_accept_connection(httpd, httpd->server_fd6, 1);
 248                         if (ret == -1) {
 249                                 break;
 250                         } else if (ret == 0) {
 251                                 continue;
 252                         }
 253                 }
 254                 for (i=0; i<httpd->max_connections; i++) {
 255                         http_connection_t *connection = &httpd->connections[i];
 256
 257                         if (!connection->connected) {
 258                                 continue;
 259                         }
 260                         if (!FD_ISSET(connection->socket_fd, &rfds)) {
 261                                 continue;
 262                         }
 263
 264                         /* If not in the middle of request, allocate one */
 265                         if (!connection->request) {
 266                                 connection->request = http_request_init();
 267                                 assert(connection->request);
 268                         }
 269
 270                         logger_log(httpd->logger, LOGGER_DEBUG, "Receiving on socket %d", connection->socket_fd);
 271                         ret = recv(connection->socket_fd, buffer, sizeof(buffer), 0);
 272                         if (ret == 0) {
 273                                 logger_log(httpd->logger, LOGGER_INFO, "Connection closed for socket %d", connection->socket_fd);
 274                                 httpd_remove_connection(httpd, connection);
 275                                 continue;
 276                         }
 277
 278                         /* Parse HTTP request from data read from connection */
 279                         http_request_add_data(connection->request, buffer, ret);
 280                         if (http_request_has_error(connection->request)) {
 281                                 logger_log(httpd->logger, LOGGER_INFO, "Error in parsing: %s", http_request_get_error_name(connection->request));
 282                                 httpd_remove_connection(httpd, connection);
 283                                 continue;
 284                         }
 285
 286                         /* If request is finished, process and deallocate */
 287                         if (http_request_is_complete(connection->request)) {
 288                                 http_response_t *response = NULL;
 289
 290                                 httpd->callbacks.conn_request(connection->user_data, connection->request, &response);
 291                                 http_request_destroy(connection->request);
 292                                 connection->request = NULL;
 293
 294                                 if (response) {
 295                                         const char *data;
 296                                         int datalen;
 297                                         int written;
 298                                         int ret;
 299
 300                                         /* Get response data and datalen */
 301                                         data = http_response_get_data(response, &datalen);
 302
 303                                         written = 0;
 304                                         while (written < datalen) {
 305                                                 ret = send(connection->socket_fd, data+written, datalen-written, 0);
 306                                                 if (ret == -1) {
 307                                                         /* FIXME: Error happened */
 308                                                         logger_log(httpd->logger, LOGGER_INFO, "Error in sending data");
 309                                                         break;
 310                                                 }
 311                                                 written += ret;
 312                                         }
 313
 314                                         if (http_response_get_disconnect(response)) {
 315                                                 logger_log(httpd->logger, LOGGER_INFO, "Disconnecting on software request");
 316                                                 httpd_remove_connection(httpd, connection);
 317                                         }
 318                                 } else {
 319                                         logger_log(httpd->logger, LOGGER_INFO, "Didn't get response");
 320                                 }
 321                                 http_response_destroy(response);
 322                         } else {
 323                                 logger_log(httpd->logger, LOGGER_DEBUG, "Request not complete, waiting for more data...");
 324                         }
 325                 }
 326         }
 327
 328         /* Remove all connections that are still connected */
 329         for (i=0; i<httpd->max_connections; i++) {
 330                 http_connection_t *connection = &httpd->connections[i];
 331
 332                 if (!connection->connected) {
 333                         continue;
 334                 }
 335                 logger_log(httpd->logger, LOGGER_INFO, "Removing connection for socket %d", connection->socket_fd);
 336                 httpd_remove_connection(httpd, connection);
 337         }
 338
 339         /* Close server sockets since they are not used any more */
 340         if (httpd->server_fd4 != -1) {
 341                 closesocket(httpd->server_fd4);
 342                 httpd->server_fd4 = -1;
 343         }
 344         if (httpd->server_fd6 != -1) {
 345                 closesocket(httpd->server_fd6);
 346                 httpd->server_fd6 = -1;
 347         }
 348
 349         logger_log(httpd->logger, LOGGER_INFO, "Exiting HTTP thread");
 350
 351         return 0;
 352 }
 353
 354 int
 355 httpd_start(httpd_t *httpd, unsigned short *port)
 356 {
 357         /* How many connection attempts are kept in queue */
 358         int backlog = 5;
 359
 360         assert(httpd);
 361         assert(port);
 362
 363         MUTEX_LOCK(httpd->run_mutex);
 364         if (httpd->running || !httpd->joined) {
 365                 MUTEX_UNLOCK(httpd->run_mutex);
 366                 return 0;
 367         }
 368
 369         httpd->server_fd4 = netutils_init_socket(port, 0, 0);
 370         if (httpd->server_fd4 == -1) {
 371                 logger_log(httpd->logger, LOGGER_ERR, "Error initialising socket %d", SOCKET_GET_ERROR());
 372                 MUTEX_UNLOCK(httpd->run_mutex);
 373                 return -1;
 374         }
 375         httpd->server_fd6 = netutils_init_socket(port, 1, 0);
 376         if (httpd->server_fd6 == -1) {
 377                 logger_log(httpd->logger, LOGGER_WARNING, "Error initialising IPv6 socket %d", SOCKET_GET_ERROR());
 378                 logger_log(httpd->logger, LOGGER_WARNING, "Continuing without IPv6 support");
 379         }
 380
 381         if (httpd->server_fd4 != -1 && listen(httpd->server_fd4, backlog) == -1) {
 382                 logger_log(httpd->logger, LOGGER_ERR, "Error listening to IPv4 socket");
 383                 closesocket(httpd->server_fd4);
 384                 closesocket(httpd->server_fd6);
 385                 MUTEX_UNLOCK(httpd->run_mutex);
 386                 return -2;
 387         }
 388         if (httpd->server_fd6 != -1 && listen(httpd->server_fd6, backlog) == -1) {
 389                 logger_log(httpd->logger, LOGGER_ERR, "Error listening to IPv6 socket");
 390                 closesocket(httpd->server_fd4);
 391                 closesocket(httpd->server_fd6);
 392                 MUTEX_UNLOCK(httpd->run_mutex);
 393                 return -2;
 394         }
 395         logger_log(httpd->logger, LOGGER_INFO, "Initialized server socket(s)");
 396
 397         /* Set values correctly and create new thread */
 398         httpd->running = 1;
 399         httpd->joined = 0;
 400         THREAD_CREATE(httpd->thread, httpd_thread, httpd);
 401         MUTEX_UNLOCK(httpd->run_mutex);
 402
 403         return 1;
 404 }
 405
 406 int
 407 httpd_is_running(httpd_t *httpd)
 408 {
 409         int running;
 410
 411         assert(httpd);
 412
 413         MUTEX_LOCK(httpd->run_mutex);
 414         running = httpd->running || !httpd->joined;
 415         MUTEX_UNLOCK(httpd->run_mutex);
 416
 417         return running;
 418 }
 419
 420 void
 421 httpd_stop(httpd_t *httpd)
 422 {
 423         assert(httpd);
 424
 425         MUTEX_LOCK(httpd->run_mutex);
 426         if (!httpd->running || httpd->joined) {
 427                 MUTEX_UNLOCK(httpd->run_mutex);
 428                 return;
 429         }
 430         httpd->running = 0;
 431         MUTEX_UNLOCK(httpd->run_mutex);
 432
 433         THREAD_JOIN(httpd->thread);
 434
 435         MUTEX_LOCK(httpd->run_mutex);
 436         httpd->joined = 1;
 437         MUTEX_UNLOCK(httpd->run_mutex);
 438 }
 439