From c51d65ffce7b0542a15afa4d7bb252df6a970b5c Mon Sep 17 00:00:00 2001 From: lv-426 Date: Sat, 24 May 2008 13:59:21 +0000 Subject: added : * configure.ac support for --with-gnutls=PFX * TLS connection handler in daemon.c * simple TLS echo client server example --- src/daemon/daemon.c | 1194 ++++++++++++++++++++++++++------------------------- 1 file changed, 612 insertions(+), 582 deletions(-) (limited to 'src/daemon/daemon.c') diff --git a/src/daemon/daemon.c b/src/daemon/daemon.c index 971196f8..ef575dd6 100644 --- a/src/daemon/daemon.c +++ b/src/daemon/daemon.c @@ -1,22 +1,22 @@ /* - This file is part of libmicrohttpd - (C) 2007 Daniel Pittman and Christian Grothoff + This file is part of libmicrohttpd + (C) 2007 Daniel Pittman and Christian Grothoff - 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 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. + 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. - You should have received a copy of the GNU Lesser General Public - License along with this library; if not, write to the Free Software - Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA -*/ + */ /** * @file daemon.c @@ -52,7 +52,6 @@ */ #define DEBUG_CONNECT MHD_NO - /** * Obtain the select sets for this daemon. * @@ -60,307 +59,331 @@ * daemon was not started with the right * options for this call. */ -int -MHD_get_fdset (struct MHD_Daemon *daemon, - fd_set * read_fd_set, - fd_set * write_fd_set, fd_set * except_fd_set, int *max_fd) -{ - struct MHD_Connection *pos; - int fd; - - if ((daemon == NULL) || - (read_fd_set == NULL) || - (write_fd_set == NULL) || - (except_fd_set == NULL) || - (max_fd == NULL) || - (-1 == (fd = daemon->socket_fd)) || - (daemon->shutdown == MHD_YES) || - ((daemon->options & MHD_USE_THREAD_PER_CONNECTION) != 0)) - return MHD_NO; - FD_SET (fd, read_fd_set); - if ((*max_fd) < fd) - *max_fd = fd; - pos = daemon->connections; - while (pos != NULL) - { - if (MHD_YES != MHD_connection_get_fdset (pos, - read_fd_set, - write_fd_set, - except_fd_set, max_fd)) - return MHD_NO; - pos = pos->next; - } +int MHD_get_fdset(struct MHD_Daemon *daemon, + fd_set * read_fd_set, + fd_set * write_fd_set, + fd_set * except_fd_set, + int *max_fd) + { + struct MHD_Connection *con_itr; + int fd; + + if ((daemon == NULL) || (read_fd_set == NULL) || (write_fd_set == NULL) + || (except_fd_set == NULL) || (max_fd == NULL) || (-1 == (fd = daemon-> + socket_fd)) || (daemon->shutdown == MHD_YES) || ((daemon->options + & MHD_USE_THREAD_PER_CONNECTION) != 0)) + return MHD_NO; + + __FD_SET (fd, read_fd_set); + + /* update max file descriptor */ + if ((*max_fd) < fd) + *max_fd = fd; + + con_itr = daemon->connections; + while (con_itr != NULL) + { + if (MHD_YES != MHD_connection_get_fdset (con_itr, + read_fd_set, + write_fd_set, + except_fd_set, max_fd)) + return MHD_NO; + con_itr = con_itr->next; + } #if DEBUG_CONNECT - MHD_DLOG (daemon, "Maximum socket in select set: %d\n", *max_fd); + MHD_DLOG (daemon, "Maximum socket in select set: %d\n", *max_fd); #endif - return MHD_YES; -} + return MHD_YES; + } /** * Main function of the thread that handles an individual * connection. */ -static void * -MHD_handle_connection (void *data) -{ - struct MHD_Connection *con = data; - int num_ready; - fd_set rs; - fd_set ws; - fd_set es; - int max; - struct timeval tv; - unsigned int timeout; - unsigned int now; - - if (con == NULL) - abort (); - timeout = con->daemon->connection_timeout; - while ((!con->daemon->shutdown) && (con->socket_fd != -1)) - { - FD_ZERO (&rs); - FD_ZERO (&ws); - FD_ZERO (&es); - max = 0; - MHD_connection_get_fdset (con, &rs, &ws, &es, &max); - now = time (NULL); - tv.tv_usec = 0; - if (timeout > (now - con->last_activity)) - tv.tv_sec = timeout - (now - con->last_activity); - else - tv.tv_sec = 0; - num_ready = SELECT (max + 1, - &rs, &ws, &es, (timeout != 0) ? &tv : NULL); - if (num_ready < 0) - { - if (errno == EINTR) - continue; +static void * MHD_handle_connection(void *data) + { + struct MHD_Connection *con = data; + int num_ready; + fd_set rs; + fd_set ws; + fd_set es; + int max; + struct timeval tv; + unsigned int timeout; + unsigned int now; + + if (con == NULL) + abort(); + timeout = con->daemon->connection_timeout; + while ((!con->daemon->shutdown) && (con->socket_fd != -1)) + { + FD_ZERO (&rs); + FD_ZERO (&ws); + FD_ZERO (&es); + max = 0; + MHD_connection_get_fdset(con, &rs, &ws, &es, &max); + now = time(NULL); + tv.tv_usec = 0; + if (timeout > (now - con->last_activity)) + tv.tv_sec = timeout - (now - con->last_activity); + else + tv.tv_sec = 0; + num_ready = SELECT (max + 1, + &rs, &ws, &es, (timeout != 0) ? &tv : NULL); + if (num_ready < 0) + { + if (errno == EINTR) + continue; #if HAVE_MESSAGES - MHD_DLOG (con->daemon, "Error during select (%d): `%s'\n", - max, STRERROR (errno)); + MHD_DLOG(con->daemon, "Error during select (%d): `%s'\n", max, + STRERROR (errno)); #endif - break; - } - if (FD_ISSET (con->socket_fd, &rs)) - MHD_connection_handle_read (con); - if ((con->socket_fd != -1) && (FD_ISSET (con->socket_fd, &ws))) - MHD_connection_handle_write (con); - if (con->socket_fd != -1) - MHD_connection_handle_idle (con); - } - if (con->socket_fd != -1) - { + break; + } + if (FD_ISSET (con->socket_fd, &rs)) + MHD_connection_handle_read(con); + if ((con->socket_fd != -1) && (FD_ISSET (con->socket_fd, &ws))) + MHD_connection_handle_write(con); + if (con->socket_fd != -1) + MHD_connection_handle_idle(con); + } + if (con->socket_fd != -1) + { #if DEBUG_CLOSE #if HAVE_MESSAGES - MHD_DLOG (con->daemon, - "Processing thread terminating, closing connection\n"); + MHD_DLOG (con->daemon, + "Processing thread terminating, closing connection\n"); #endif #endif - SHUTDOWN (con->socket_fd, SHUT_RDWR); - CLOSE (con->socket_fd); - con->socket_fd = -1; - } - return NULL; -} + SHUTDOWN (con->socket_fd, SHUT_RDWR); + CLOSE (con->socket_fd); + con->socket_fd = -1; + } + return NULL; + } + +/** + * Handle an individual TLS connection. + */ +static void * MHDS_handle_connection(void *data) + { + struct MHD_Connection *con = data; + + if (con == NULL) + abort(); + + /* forward call to handler */ + con->daemon->default_handler(NULL, con, NULL, NULL, NULL, NULL, NULL, + NULL); + return NULL; + } /** * Accept an incoming connection and create the MHD_Connection object for * it. This function also enforces policy by way of checking with the * accept policy callback. */ -static int -MHD_accept_connection (struct MHD_Daemon *daemon) -{ - struct MHD_Connection *pos; - struct MHD_Connection *connection; - struct sockaddr_in6 addr6; - struct sockaddr *addr = (struct sockaddr *) &addr6; - socklen_t addrlen; - unsigned int have; - int s; +static int MHD_accept_connection(struct MHD_Daemon *daemon) + { + struct MHD_Connection *pos; + struct MHD_Connection *connection; + struct sockaddr_in6 addr6; + struct sockaddr *addr = (struct sockaddr *) &addr6; + socklen_t addrlen; + unsigned int have; + int s, res_thread_create; #if OSX - static int on = 1; + static int on = 1; #endif + if (sizeof(struct sockaddr) > sizeof(struct sockaddr_in6)) + abort(); /* fatal, serious error */ + addrlen = sizeof(struct sockaddr_in6); + memset(addr, 0, sizeof(struct sockaddr_in6)); + + s = ACCEPT (daemon->socket_fd, addr, &addrlen); - if (sizeof (struct sockaddr) > sizeof (struct sockaddr_in6)) - abort (); /* fatal, serious error */ - addrlen = sizeof (struct sockaddr_in6); - memset (addr, 0, sizeof (struct sockaddr_in6)); - s = ACCEPT (daemon->socket_fd, addr, &addrlen); - if ((s < 0) || (addrlen <= 0)) - { + if ((s < 0) || (addrlen <= 0)) + { #if HAVE_MESSAGES - MHD_DLOG (daemon, "Error accepting connection: %s\n", STRERROR (errno)); + MHD_DLOG(daemon, "Error accepting connection: %s\n", STRERROR (errno)); #endif - if (s != -1) - { - SHUTDOWN (s, SHUT_RDWR); - CLOSE (s); /* just in case */ - } - return MHD_NO; - } + if (s != -1) + { + SHUTDOWN (s, SHUT_RDWR); + CLOSE (s); + /* just in case */ + } + return MHD_NO; + } #if DEBUG_CONNECT - MHD_DLOG (daemon, "Accepted connection on socket %d\n", s); + MHD_DLOG (daemon, "Accepted connection on socket %d\n", s); #endif - have = 0; - if ((daemon->per_ip_connection_limit != 0) && (daemon->max_connections > 0)) - { - pos = daemon->connections; - while (pos != NULL) - { - if ((pos->addr != NULL) && (pos->addr_len == addrlen)) - { - if (addrlen == sizeof (struct sockaddr_in)) - { - const struct sockaddr_in *a1 = - (const struct sockaddr_in *) &addr; - const struct sockaddr_in *a2 = - (const struct sockaddr_in *) pos->addr; - if (0 == - memcmp (&a1->sin_addr, &a2->sin_addr, - sizeof (struct in_addr))) - have++; - } - if (addrlen == sizeof (struct sockaddr_in6)) - { - const struct sockaddr_in6 *a1 = - (const struct sockaddr_in6 *) &addr; - const struct sockaddr_in6 *a2 = - (const struct sockaddr_in6 *) pos->addr; - if (0 == - memcmp (&a1->sin6_addr, &a2->sin6_addr, - sizeof (struct in6_addr))) - have++; - } - } - pos = pos->next; - } - } - - if ((daemon->max_connections == 0) || - ((daemon->per_ip_connection_limit != 0) && - (daemon->per_ip_connection_limit <= have))) - { - /* above connection limit - reject */ + have = 0; + if ((daemon->per_ip_connection_limit != 0) && (daemon->max_connections > 0)) + { + pos = daemon->connections; + while (pos != NULL) + { + if ((pos->addr != NULL) && (pos->addr_len == addrlen)) + { + if (addrlen == sizeof(struct sockaddr_in)) + { + const struct sockaddr_in *a1 = + (const struct sockaddr_in *) &addr; + const struct sockaddr_in *a2 = + (const struct sockaddr_in *) pos->addr; + if (0 == memcmp(&a1->sin_addr, &a2->sin_addr, + sizeof(struct in_addr))) + have++; + } + if (addrlen == sizeof(struct sockaddr_in6)) + { + const struct sockaddr_in6 *a1 = + (const struct sockaddr_in6 *) &addr; + const struct sockaddr_in6 *a2 = + (const struct sockaddr_in6 *) pos->addr; + if (0 == memcmp(&a1->sin6_addr, &a2->sin6_addr, + sizeof(struct in6_addr))) + have++; + } + } + pos = pos->next; + } + } + + if ((daemon->max_connections == 0) || ((daemon->per_ip_connection_limit + != 0) && (daemon-> + per_ip_connection_limit <= have))) + { + /* above connection limit - reject */ #if HAVE_MESSAGES - MHD_DLOG (daemon, - "Server reached connection limit (closing inbound connection)\n"); + MHD_DLOG(daemon, + "Server reached connection limit (closing inbound connection)\n"); #endif - SHUTDOWN (s, SHUT_RDWR); - CLOSE (s); - return MHD_NO; - } - if ((daemon->apc != NULL) && - (MHD_NO == daemon->apc (daemon->apc_cls, addr, addrlen))) - { + SHUTDOWN (s, SHUT_RDWR); + CLOSE (s); + return MHD_NO; + } + if ((daemon->apc != NULL) && (MHD_NO == daemon->apc (daemon->apc_cls, addr, addrlen))) + { #if DEBUG_CLOSE #if HAVE_MESSAGES - MHD_DLOG (daemon, "Connection rejected, closing connection\n"); + MHD_DLOG (daemon, "Connection rejected, closing connection\n"); #endif #endif - SHUTDOWN (s, SHUT_RDWR); - CLOSE (s); - return MHD_YES; - } + SHUTDOWN (s, SHUT_RDWR); + CLOSE (s); + return MHD_YES; + } #if OSX #ifdef SOL_SOCKET #ifdef SO_NOSIGPIPE - setsockopt (s, SOL_SOCKET, SO_NOSIGPIPE, &on, sizeof (on)); + setsockopt (s, SOL_SOCKET, SO_NOSIGPIPE, &on, sizeof (on)); #endif #endif #endif - connection = malloc (sizeof (struct MHD_Connection)); - if (connection == NULL) - { + connection = malloc(sizeof(struct MHD_Connection)); + if (connection == NULL) + { #if HAVE_MESSAGES - MHD_DLOG (daemon, "Error allocating memory: %s\n", STRERROR (errno)); + MHD_DLOG(daemon, "Error allocating memory: %s\n", STRERROR (errno)); #endif - SHUTDOWN (s, SHUT_RDWR); - CLOSE (s); - return MHD_NO; - } - memset (connection, 0, sizeof (struct MHD_Connection)); - connection->pool = NULL; - connection->addr = malloc (addrlen); - if (connection->addr == NULL) - { + SHUTDOWN (s, SHUT_RDWR); + CLOSE (s); + return MHD_NO; + } + memset(connection, 0, sizeof(struct MHD_Connection)); + connection->pool = NULL; + connection->addr = malloc(addrlen); + if (connection->addr == NULL) + { #if HAVE_MESSAGES - MHD_DLOG (daemon, "Error allocating memory: %s\n", STRERROR (errno)); + MHD_DLOG(daemon, "Error allocating memory: %s\n", STRERROR (errno)); #endif - SHUTDOWN (s, SHUT_RDWR); - CLOSE (s); - free (connection); - return MHD_NO; - } - memcpy (connection->addr, addr, addrlen); - connection->addr_len = addrlen; - connection->socket_fd = s; - connection->daemon = daemon; - if ((0 != (daemon->options & MHD_USE_THREAD_PER_CONNECTION)) && - (0 != pthread_create (&connection->pid, - NULL, &MHD_handle_connection, connection))) - { + SHUTDOWN (s, SHUT_RDWR); + CLOSE (s); + free(connection); + return MHD_NO; + } + memcpy(connection->addr, addr, addrlen); + connection->addr_len = addrlen; + connection->socket_fd = s; + connection->daemon = daemon; + + /* attempt to create handler thread */ + if (0 != (daemon->options & MHD_USE_THREAD_PER_CONNECTION)) + { + if (daemon->options & MHD_USE_SSL) + res_thread_create= pthread_create(&connection->pid, NULL, + &MHDS_handle_connection, connection); + else + { + res_thread_create= pthread_create(&connection->pid, NULL, + &MHD_handle_connection, connection); + } + if (res_thread_create != 0) + { #if HAVE_MESSAGES - MHD_DLOG (daemon, "Failed to create a thread: %s\n", STRERROR (errno)); + MHD_DLOG(daemon, "Failed to create a thread: %s\n", STRERROR (errno)); #endif - SHUTDOWN (s, SHUT_RDWR); - CLOSE (s); - free (connection->addr); - free (connection); - return MHD_NO; - } - connection->last_activity = time (NULL); - connection->next = daemon->connections; - daemon->connections = connection; - daemon->max_connections--; - return MHD_YES; -} - + SHUTDOWN (s, SHUT_RDWR); + CLOSE (s); + free(connection->addr); + free(connection); + return MHD_NO; + } + } + + connection->last_activity = time(NULL); + connection->next = daemon->connections; + daemon->connections = connection; + daemon->max_connections--; + return MHD_YES; + } /** * Free resources associated with all closed connections. * (destroy responses, free buffers, etc.). A connection * is known to be closed if the socket_fd is -1. */ -static void -MHD_cleanup_connections (struct MHD_Daemon *daemon) -{ - struct MHD_Connection *pos; - struct MHD_Connection *prev; - void *unused; - - pos = daemon->connections; - prev = NULL; - while (pos != NULL) - { - if (pos->socket_fd == -1) - { - if (prev == NULL) - daemon->connections = pos->next; - else - prev->next = pos->next; - if (0 != (daemon->options & MHD_USE_THREAD_PER_CONNECTION)) - { - pthread_kill (pos->pid, SIGALRM); - pthread_join (pos->pid, &unused); - } - MHD_destroy_response (pos->response); - MHD_pool_destroy (pos->pool); - free (pos->addr); - free (pos); - daemon->max_connections++; - if (prev == NULL) - pos = daemon->connections; - else - pos = prev->next; - continue; - } - prev = pos; - pos = pos->next; - } -} +static void MHD_cleanup_connections(struct MHD_Daemon *daemon) + { + struct MHD_Connection *pos; + struct MHD_Connection *prev; + void *unused; + + pos = daemon->connections; + prev = NULL; + while (pos != NULL) + { + if (pos->socket_fd == -1) + { + if (prev == NULL) + daemon->connections = pos->next; + else + prev->next = pos->next; + if (0 != (daemon->options & MHD_USE_THREAD_PER_CONNECTION)) + { + pthread_kill(pos->pid, SIGALRM); + pthread_join(pos->pid, &unused); + } + MHD_destroy_response(pos->response); + MHD_pool_destroy(pos->pool); + free(pos->addr); + free(pos); + daemon->max_connections++; + if (prev == NULL) + pos = daemon->connections; + else + pos = prev->next; + continue; + } + prev = pos; + pos = pos->next; + } + } /** * Obtain timeout value for select for this daemon @@ -373,35 +396,34 @@ MHD_cleanup_connections (struct MHD_Daemon *daemon) * not used (or no connections exist that would * necessiate the use of a timeout right now). */ -int -MHD_get_timeout (struct MHD_Daemon *daemon, unsigned long long *timeout) -{ - time_t earliest_deadline; - time_t now; - struct MHD_Connection *pos; - unsigned int dto; - - dto = daemon->connection_timeout; - if (0 == dto) - return MHD_NO; - pos = daemon->connections; - if (pos == NULL) - return MHD_NO; /* no connections */ - now = time (NULL); - /* start with conservative estimate */ - earliest_deadline = now + dto; - while (pos != NULL) - { - if (earliest_deadline > pos->last_activity + dto) - earliest_deadline = pos->last_activity + dto; - pos = pos->next; - } - if (earliest_deadline < now) - *timeout = 0; - else - *timeout = (earliest_deadline - now); - return MHD_YES; -} +int MHD_get_timeout(struct MHD_Daemon *daemon, unsigned long long *timeout) + { + time_t earliest_deadline; + time_t now; + struct MHD_Connection *pos; + unsigned int dto; + + dto = daemon->connection_timeout; + if (0 == dto) + return MHD_NO; + pos = daemon->connections; + if (pos == NULL) + return MHD_NO; /* no connections */ + now = time(NULL); + /* start with conservative estimate */ + earliest_deadline = now + dto; + while (pos != NULL) + { + if (earliest_deadline > pos->last_activity + dto) + earliest_deadline = pos->last_activity + dto; + pos = pos->next; + } + if (earliest_deadline < now) + *timeout = 0; + else + *timeout = (earliest_deadline - now); + return MHD_YES; + } /** * Main select call. @@ -409,101 +431,102 @@ MHD_get_timeout (struct MHD_Daemon *daemon, unsigned long long *timeout) * @param may_block YES if blocking, NO if non-blocking * @return MHD_NO on serious errors, MHD_YES on success */ -static int -MHD_select (struct MHD_Daemon *daemon, int may_block) -{ - struct MHD_Connection *pos; - int num_ready; - fd_set rs; - fd_set ws; - fd_set es; - int max; - struct timeval timeout; - unsigned long long ltimeout; - int ds; - time_t now; - - timeout.tv_sec = 0; - timeout.tv_usec = 0; - if (daemon == NULL) - abort (); - if (daemon->shutdown == MHD_YES) - return MHD_NO; - FD_ZERO (&rs); - FD_ZERO (&ws); - FD_ZERO (&es); - max = 0; - - if (0 == (daemon->options & MHD_USE_THREAD_PER_CONNECTION)) - { - /* single-threaded, go over everything */ - if (MHD_NO == MHD_get_fdset (daemon, &rs, &ws, &es, &max)) - return MHD_NO; - } - else - { - /* accept only, have one thread per connection */ - max = daemon->socket_fd; - if (max == -1) - return MHD_NO; - FD_SET (max, &rs); - } - if (may_block == MHD_NO) - { - timeout.tv_usec = 0; - timeout.tv_sec = 0; - } - else - { - /* ltimeout is in ms */ - if (MHD_YES == MHD_get_timeout (daemon, <imeout)) - { - timeout.tv_usec = (ltimeout % 1000) * 1000; - timeout.tv_sec = ltimeout / 1000; - may_block = MHD_NO; - } - } - num_ready = SELECT (max + 1, - &rs, &ws, &es, may_block == MHD_NO ? &timeout : NULL); - if (daemon->shutdown == MHD_YES) - return MHD_NO; - if (num_ready < 0) - { - if (errno == EINTR) - return MHD_YES; +static int MHD_select(struct MHD_Daemon *daemon, int may_block) + { + struct MHD_Connection *pos; + int num_ready; + fd_set rs; + fd_set ws; + fd_set es; + int max; + struct timeval timeout; + unsigned long long ltimeout; + int ds; + time_t now; + + timeout.tv_sec = 0; + timeout.tv_usec = 0; + if (daemon == NULL) + abort(); + if (daemon->shutdown == MHD_YES) + return MHD_NO; + FD_ZERO (&rs); + FD_ZERO (&ws); + FD_ZERO (&es); + max = 0; + + if (0 == (daemon->options & MHD_USE_THREAD_PER_CONNECTION)) + { + /* single-threaded, go over everything */ + if (MHD_NO == MHD_get_fdset (daemon, &rs, &ws, &es, &max)) + return MHD_NO; + } + else + { + /* accept only, have one thread per connection */ + max = daemon->socket_fd; + if (max == -1) + return MHD_NO; + FD_SET (max, &rs); + } + + if (may_block == MHD_NO) + { + timeout.tv_usec = 0; + timeout.tv_sec = 0; + } + else + { + /* ltimeout is in ms */ + if (MHD_YES == MHD_get_timeout (daemon, <imeout)) + { + timeout.tv_usec = (ltimeout % 1000) * 1000; + timeout.tv_sec = ltimeout / 1000; + may_block = MHD_NO; + } + } + + num_ready = select(max + 1, &rs, &ws, &es, may_block == MHD_NO ? &timeout + : NULL); + + if (daemon->shutdown == MHD_YES) + return MHD_NO; + if (num_ready < 0) + { + if (errno == EINTR) + return MHD_YES; #if HAVE_MESSAGES - MHD_DLOG (daemon, "Select failed: %s\n", STRERROR (errno)); + MHD_DLOG(daemon, "Select failed: %s\n", STRERROR (errno)); #endif - return MHD_NO; - } - ds = daemon->socket_fd; - if (ds == -1) + return MHD_NO; + } + ds = daemon->socket_fd; + if (ds == -1) + return MHD_YES; + if (__FD_ISSET (ds, &rs)) + MHD_accept_connection(daemon); + if (0 == (daemon->options & MHD_USE_THREAD_PER_CONNECTION)) + { + /* do not have a thread per connection, process all connections now */ + now = time(NULL); + pos = daemon->connections; + while (pos != NULL) + { + ds = pos->socket_fd; + if (ds != -1) + { + if (FD_ISSET (ds, &rs)) + MHD_connection_handle_read(pos); + if ((pos->socket_fd != -1) && (FD_ISSET (ds, &ws))) + MHD_connection_handle_write(pos); + if (pos->socket_fd != -1) + MHD_connection_handle_idle(pos); + } + pos = pos->next; + } + } return MHD_YES; - if (FD_ISSET (ds, &rs)) - MHD_accept_connection (daemon); - if (0 == (daemon->options & MHD_USE_THREAD_PER_CONNECTION)) - { - /* do not have a thread per connection, process all connections now */ - now = time (NULL); - pos = daemon->connections; - while (pos != NULL) - { - ds = pos->socket_fd; - if (ds != -1) - { - if (FD_ISSET (ds, &rs)) - MHD_connection_handle_read (pos); - if ((pos->socket_fd != -1) && (FD_ISSET (ds, &ws))) - MHD_connection_handle_write (pos); - if (pos->socket_fd != -1) - MHD_connection_handle_idle (pos); - } - pos = pos->next; - } - } - return MHD_YES; -} - + } /** * Run webserver operations (without blocking unless @@ -515,35 +538,31 @@ MHD_select (struct MHD_Daemon *daemon, int may_block) * daemon was not started with the right * options for this call. */ -int -MHD_run (struct MHD_Daemon *daemon) -{ - if ((daemon->shutdown != MHD_NO) || - (0 != (daemon->options & MHD_USE_THREAD_PER_CONNECTION)) || - (0 != (daemon->options & MHD_USE_SELECT_INTERNALLY))) - return MHD_NO; - MHD_select (daemon, MHD_NO); - MHD_cleanup_connections (daemon); - return MHD_YES; -} - +int MHD_run(struct MHD_Daemon *daemon) + { + if ((daemon->shutdown != MHD_NO) || (0 != (daemon->options + & MHD_USE_THREAD_PER_CONNECTION)) || (0 != (daemon->options + & MHD_USE_SELECT_INTERNALLY))) + return MHD_NO; + MHD_select(daemon, MHD_NO); + MHD_cleanup_connections(daemon); + return MHD_YES; + } /** * Thread that runs the select loop until the daemon * is explicitly shut down. */ -static void * -MHD_select_thread (void *cls) -{ - struct MHD_Daemon *daemon = cls; - while (daemon->shutdown == MHD_NO) - { - MHD_select (daemon, MHD_YES); - MHD_cleanup_connections (daemon); - } - return NULL; -} - +static void * MHD_select_thread(void *cls) + { + struct MHD_Daemon *daemon = cls; + while (daemon->shutdown == MHD_NO) + { + MHD_select(daemon, MHD_YES); + MHD_cleanup_connections(daemon); + } + return NULL; + } /** * Start a webserver on the given port. @@ -556,106 +575,119 @@ MHD_select_thread (void *cls) * @param dh_cls extra argument to dh * @return NULL on error, handle to daemon on success */ -struct MHD_Daemon * -MHD_start_daemon (unsigned int options, - unsigned short port, - MHD_AcceptPolicyCallback apc, - void *apc_cls, - MHD_AccessHandlerCallback dh, void *dh_cls, ...) -{ - const int on = 1; - struct MHD_Daemon *retVal; - int socket_fd; - struct sockaddr_in servaddr4; - struct sockaddr_in6 servaddr6; - const struct sockaddr *servaddr; - socklen_t addrlen; - va_list ap; - enum MHD_OPTION opt; - - if ((options & MHD_USE_SSL) != 0) - return NULL; - if ((port == 0) || (dh == NULL)) - return NULL; - if ((options & MHD_USE_IPv6) != 0) - socket_fd = SOCKET (PF_INET6, SOCK_STREAM, 0); - else - socket_fd = SOCKET (PF_INET, SOCK_STREAM, 0); - if (socket_fd < 0) - { +struct MHD_Daemon * MHD_start_daemon(unsigned int options, + unsigned short port, + MHD_AcceptPolicyCallback apc, + void *apc_cls, + MHD_AccessHandlerCallback dh, + void *dh_cls, + ...) + { + const int on = 1; + struct MHD_Daemon *retVal; + + /* listeningss sockets used by the daemon */ + int socket_fd; + + struct sockaddr_in servaddr4; + struct sockaddr_in6 servaddr6; + const struct sockaddr *servaddr; + socklen_t addrlen; + va_list ap; + enum MHD_OPTION opt; + + if ((port == 0) || (dh == NULL)) + return NULL; + if ((options & MHD_USE_IPv6) != 0) + socket_fd = SOCKET (PF_INET6, SOCK_STREAM, 0); + else + socket_fd = SOCKET (PF_INET, SOCK_STREAM, 0); + if (socket_fd < 0) + { #if HAVE_MESSAGES - if ((options & MHD_USE_DEBUG) != 0) - fprintf (stderr, "Call to socket failed: %s\n", STRERROR (errno)); + if ((options & MHD_USE_DEBUG) != 0) + fprintf(stderr, "Call to socket failed: %s\n", STRERROR (errno)); #endif - return NULL; - } - if ((SETSOCKOPT (socket_fd, - SOL_SOCKET, - SO_REUSEADDR, - &on, sizeof (on)) < 0) && (options & MHD_USE_DEBUG) != 0) - { + return NULL; + } + if ((SETSOCKOPT (socket_fd, + SOL_SOCKET, + SO_REUSEADDR, + &on, sizeof (on)) < 0) && (options & MHD_USE_DEBUG) != 0) + { #if HAVE_MESSAGES - fprintf (stderr, "setsockopt failed: %s\n", STRERROR (errno)); + fprintf(stderr, "setsockopt failed: %s\n", STRERROR (errno)); #endif - } - if ((options & MHD_USE_IPv6) != 0) - { - memset (&servaddr6, 0, sizeof (struct sockaddr_in6)); - servaddr6.sin6_family = AF_INET6; - servaddr6.sin6_port = htons (port); - servaddr = (struct sockaddr *) &servaddr6; - addrlen = sizeof (struct sockaddr_in6); - } - else - { - memset (&servaddr4, 0, sizeof (struct sockaddr_in)); - servaddr4.sin_family = AF_INET; - servaddr4.sin_port = htons (port); - servaddr = (struct sockaddr *) &servaddr4; - addrlen = sizeof (struct sockaddr_in); - } - if (BIND (socket_fd, servaddr, addrlen) < 0) - { + } + if ((options & MHD_USE_IPv6) != 0) + { + memset(&servaddr6, 0, sizeof(struct sockaddr_in6)); + servaddr6.sin6_family = AF_INET6; + servaddr6.sin6_port = htons(port); + servaddr = (struct sockaddr *) &servaddr6; + addrlen = sizeof(struct sockaddr_in6); + } + else + { + memset(&servaddr4, 0, sizeof(struct sockaddr_in)); + servaddr4.sin_family = AF_INET; + servaddr4.sin_port = htons(port); + servaddr = (struct sockaddr *) &servaddr4; + addrlen = sizeof(struct sockaddr_in); + } + if (BIND (socket_fd, servaddr, addrlen) < 0) + { #if HAVE_MESSAGES - if ((options & MHD_USE_DEBUG) != 0) - fprintf (stderr, - "Failed to bind to port %u: %s\n", port, STRERROR (errno)); + if ((options & MHD_USE_DEBUG) != 0) + fprintf(stderr, + "Failed to bind to port %u: %s\n", port, STRERROR (errno)); #endif - CLOSE (socket_fd); - return NULL; - } - if (LISTEN (socket_fd, 20) < 0) - { + CLOSE (socket_fd); + return NULL; + } + if (LISTEN (socket_fd, 20) < 0) + { #if HAVE_MESSAGES - if ((options & MHD_USE_DEBUG) != 0) - fprintf (stderr, - "Failed to listen for connections: %s\n", STRERROR (errno)); + if ((options & MHD_USE_DEBUG) != 0) + fprintf(stderr, + "Failed to listen for connections: %s\n", STRERROR (errno)); #endif - CLOSE (socket_fd); - return NULL; - } - retVal = malloc (sizeof (struct MHD_Daemon)); - if (retVal == NULL) - { - CLOSE (socket_fd); - return NULL; - } - memset (retVal, 0, sizeof (struct MHD_Daemon)); - retVal->options = options; - retVal->port = port; - retVal->apc = apc; - retVal->apc_cls = apc_cls; - retVal->socket_fd = socket_fd; - retVal->default_handler = dh; - retVal->default_handler_cls = dh_cls; - retVal->max_connections = MHD_MAX_CONNECTIONS_DEFAULT; - retVal->pool_size = MHD_POOL_SIZE_DEFAULT; - retVal->connection_timeout = 0; /* no timeout */ - va_start (ap, dh_cls); - while (MHD_OPTION_END != (opt = va_arg (ap, enum MHD_OPTION))) - { - switch (opt) - { + CLOSE (socket_fd); + return NULL; + } + + /* allocate the mhd daemon */ + + retVal = malloc(sizeof(struct MHD_Daemon)); + + if (retVal == NULL) + { + CLOSE (socket_fd); + return NULL; + } + + memset(retVal, 0, sizeof(struct MHD_Daemon)); + retVal->options = options; + retVal->port = port; + retVal->apc = apc; + retVal->apc_cls = apc_cls; + retVal->socket_fd = socket_fd; + retVal->default_handler = dh; + retVal->default_handler_cls = dh_cls; + retVal->max_connections = MHD_MAX_CONNECTIONS_DEFAULT; + retVal->pool_size = MHD_POOL_SIZE_DEFAULT; + retVal->connection_timeout = 0; /* no timeout */ + + /* initializes the argument pointer variable */ + va_start (ap, dh_cls); + + /* + * loop through daemon options + */ + while (MHD_OPTION_END != (opt = va_arg (ap, enum MHD_OPTION))) + { + switch (opt) + { case MHD_OPTION_CONNECTION_MEMORY_LIMIT: retVal->pool_size = va_arg (ap, unsigned int); break; @@ -666,8 +698,7 @@ MHD_start_daemon (unsigned int options, retVal->connection_timeout = va_arg (ap, unsigned int); break; case MHD_OPTION_NOTIFY_COMPLETED: - retVal->notify_completed = - va_arg (ap, MHD_RequestCompletedCallback); + retVal->notify_completed = va_arg (ap, MHD_RequestCompletedCallback); retVal->notify_completed_cls = va_arg (ap, void *); break; case MHD_OPTION_PER_IP_CONNECTION_LIMIT: @@ -675,76 +706,76 @@ MHD_start_daemon (unsigned int options, break; default: #if HAVE_MESSAGES - fprintf (stderr, - "Invalid MHD_OPTION argument! (Did you terminate the list with MHD_OPTION_END?)\n"); + fprintf(stderr, + "Invalid MHD_OPTION argument! (Did you terminate the list with MHD_OPTION_END?)\n"); #endif - abort (); - } - } - va_end (ap); - if (((0 != (options & MHD_USE_THREAD_PER_CONNECTION)) || - (0 != (options & MHD_USE_SELECT_INTERNALLY))) && - (0 != pthread_create (&retVal->pid, NULL, &MHD_select_thread, retVal))) - { + abort(); + } + } + va_end (ap); + if (((0 != (options & MHD_USE_THREAD_PER_CONNECTION)) || (0 != (options + & MHD_USE_SELECT_INTERNALLY))) && (0 != pthread_create(&retVal->pid, + NULL, &MHD_select_thread, retVal))) + { #if HAVE_MESSAGES - MHD_DLOG (retVal, - "Failed to create listen thread: %s\n", STRERROR (errno)); + MHD_DLOG(retVal, "Failed to create listen thread: %s\n", + STRERROR (errno)); #endif - free (retVal); - CLOSE (socket_fd); - return NULL; - } - return retVal; -} + free(retVal); + CLOSE (socket_fd); + return NULL; + } + + return retVal; + } /** * Shutdown an http daemon. */ -void -MHD_stop_daemon (struct MHD_Daemon *daemon) -{ - void *unused; - int fd; - - if (daemon == NULL) - return; - daemon->shutdown = MHD_YES; - fd = daemon->socket_fd; - daemon->socket_fd = -1; +void MHD_stop_daemon(struct MHD_Daemon *daemon) + { + void *unused; + int fd; + + if (daemon == NULL) + return; + daemon->shutdown = MHD_YES; + fd = daemon->socket_fd; + daemon->socket_fd = -1; #if DEBUG_CLOSE #if HAVE_MESSAGES - MHD_DLOG (daemon, "MHD shutdown, closing listen socket\n"); + MHD_DLOG (daemon, "MHD shutdown, closing listen socket\n"); #endif #endif - CLOSE (fd); - if ((0 != (daemon->options & MHD_USE_THREAD_PER_CONNECTION)) || - (0 != (daemon->options & MHD_USE_SELECT_INTERNALLY))) - { - pthread_kill (daemon->pid, SIGALRM); - pthread_join (daemon->pid, &unused); - } - while (daemon->connections != NULL) - { - if (-1 != daemon->connections->socket_fd) - { + CLOSE (fd); + if ((0 != (daemon->options & MHD_USE_THREAD_PER_CONNECTION)) || (0 + != (daemon-> + options & MHD_USE_SELECT_INTERNALLY))) + { + pthread_kill(daemon->pid, SIGALRM); + pthread_join(daemon->pid, &unused); + } + while (daemon->connections != NULL) + { + if (-1 != daemon->connections->socket_fd) + { #if DEBUG_CLOSE #if HAVE_MESSAGES - MHD_DLOG (daemon, "MHD shutdown, closing active connections\n"); + MHD_DLOG (daemon, "MHD shutdown, closing active connections\n"); #endif #endif - if (daemon->notify_completed != NULL) - daemon->notify_completed (daemon->notify_completed_cls, - daemon->connections, - &daemon->connections->client_context, - MHD_REQUEST_TERMINATED_DAEMON_SHUTDOWN); - SHUTDOWN (daemon->connections->socket_fd, SHUT_RDWR); - CLOSE (daemon->connections->socket_fd); - daemon->connections->socket_fd = -1; - } - MHD_cleanup_connections (daemon); - } - free (daemon); -} + if (daemon->notify_completed != NULL) + daemon->notify_completed(daemon->notify_completed_cls, + daemon->connections, &daemon->connections->client_context, + MHD_REQUEST_TERMINATED_DAEMON_SHUTDOWN); + SHUTDOWN (daemon->connections->socket_fd, SHUT_RDWR); + CLOSE (daemon->connections->socket_fd); + daemon->connections->socket_fd = -1; + } + MHD_cleanup_connections(daemon); + } + free(daemon); + } #ifndef WINDOWS @@ -752,38 +783,37 @@ static struct sigaction sig; static struct sigaction old; -static void -sigalrmHandler (int sig) -{ -} +static void sigalrmHandler(int sig) + { + } /** * Initialize the signal handler for SIGALRM. */ -void __attribute__ ((constructor)) MHD_pthread_handlers_ltdl_init () -{ - /* make sure SIGALRM does not kill us */ - memset (&sig, 0, sizeof (struct sigaction)); - memset (&old, 0, sizeof (struct sigaction)); - sig.sa_flags = SA_NODEFER; - sig.sa_handler = &sigalrmHandler; - sigaction (SIGALRM, &sig, &old); -} - -void __attribute__ ((destructor)) MHD_pthread_handlers_ltdl_fini () -{ - sigaction (SIGALRM, &old, &sig); -} +void __attribute__ ((constructor)) MHD_pthread_handlers_ltdl_init() + { + /* make sure SIGALRM does not kill us */ + memset(&sig, 0, sizeof(struct sigaction)); + memset(&old, 0, sizeof(struct sigaction)); + sig.sa_flags = SA_NODEFER; + sig.sa_handler = &sigalrmHandler; + sigaction(SIGALRM, &sig, &old); + } + +void __attribute__ ((destructor)) MHD_pthread_handlers_ltdl_fini() + { + sigaction(SIGALRM, &old, &sig); + } #else void __attribute__ ((constructor)) MHD_win_ltdl_init () -{ - plibc_init ("CRISP", "libmicrohttpd"); -} + { + plibc_init ("CRISP", "libmicrohttpd"); + } void __attribute__ ((destructor)) MHD_win_ltdl_fini () -{ - plibc_shutdown (); -} + { + plibc_shutdown (); + } #endif /* end of daemon.c */ -- cgit v1.2.3