| /* |
| This file is part of libmicrohttpd |
| Copyright (C) 2007-2018 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 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 |
| */ |
| /** |
| * @file lib/connection_add.c |
| * @brief functions to add connection to our active set |
| * @author Christian Grothoff |
| */ |
| #include "internal.h" |
| #include "connection_add.h" |
| #include "connection_call_handlers.h" |
| #include "connection_close.h" |
| #include "connection_finish_forward.h" |
| #include "connection_update_last_activity.h" |
| #include "daemon_ip_limit.h" |
| #include "daemon_select.h" |
| #include "daemon_poll.h" |
| #include "mhd_sockets.h" |
| |
| |
| #ifdef UPGRADE_SUPPORT |
| /** |
| * Main function of the thread that handles an individual connection |
| * after it was "upgraded" when #MHD_USE_THREAD_PER_CONNECTION is set. |
| * @remark To be called only from thread that process |
| * connection's recv(), send() and response. |
| * |
| * @param con the connection this thread will handle |
| */ |
| static void |
| thread_main_connection_upgrade (struct MHD_Connection *con) |
| { |
| #ifdef HTTPS_SUPPORT |
| struct MHD_Daemon *daemon = con->daemon; |
| |
| /* Here, we need to bi-directionally forward |
| until the application tells us that it is done |
| with the socket; */ |
| if ( (NULL != daemon->tls_api) && |
| (MHD_ELS_POLL != daemon->event_loop_syscall) ) |
| { |
| MHD_daemon_upgrade_connection_with_select_ (con); |
| } |
| #ifdef HAVE_POLL |
| else if (NULL != daemon->tls_api) |
| { |
| MHD_daemon_upgrade_connection_with_poll_ (con); |
| } |
| #endif |
| /* end HTTPS */ |
| #endif /* HTTPS_SUPPORT */ |
| /* TLS forwarding was finished. Cleanup socketpair. */ |
| MHD_connection_finish_forward_ (con); |
| /* Do not set 'urh->clean_ready' yet as 'urh' will be used |
| * in connection thread for a little while. */ |
| } |
| |
| |
| #endif /* UPGRADE_SUPPORT */ |
| |
| |
| /** |
| * Main function of the thread that handles an individual |
| * connection when #MHD_USE_THREAD_PER_CONNECTION is set. |
| * |
| * @param data the `struct MHD_Connection` this thread will handle |
| * @return always 0 |
| */ |
| static MHD_THRD_RTRN_TYPE_ MHD_THRD_CALL_SPEC_ |
| thread_main_handle_connection (void *data) |
| { |
| struct MHD_Connection *con = data; |
| struct MHD_Daemon *daemon = con->daemon; |
| int num_ready; |
| fd_set rs; |
| fd_set ws; |
| fd_set es; |
| MHD_socket maxsock; |
| struct timeval tv; |
| struct timeval *tvp; |
| time_t now; |
| #if WINDOWS |
| #ifdef HAVE_POLL |
| int extra_slot; |
| #endif /* HAVE_POLL */ |
| #define EXTRA_SLOTS 1 |
| #else /* !WINDOWS */ |
| #define EXTRA_SLOTS 0 |
| #endif /* !WINDOWS */ |
| #ifdef HAVE_POLL |
| struct pollfd p[1 + EXTRA_SLOTS]; |
| #endif |
| #undef EXTRA_SLOTS |
| #ifdef HAVE_POLL |
| const bool use_poll = (MHD_ELS_POLL == daemon->event_loop_syscall); |
| #else /* ! HAVE_POLL */ |
| const bool use_poll = false; |
| #endif /* ! HAVE_POLL */ |
| bool was_suspended = false; |
| |
| MHD_thread_init_ (&con->pid); |
| |
| while ( (! daemon->shutdown) && |
| (MHD_REQUEST_CLOSED != con->request.state) ) |
| { |
| const time_t timeout = daemon->connection_default_timeout; |
| #ifdef UPGRADE_SUPPORT |
| struct MHD_UpgradeResponseHandle *const urh = con->request.urh; |
| #else /* ! UPGRADE_SUPPORT */ |
| static const void *const urh = NULL; |
| #endif /* ! UPGRADE_SUPPORT */ |
| |
| if ( (con->suspended) && |
| (NULL == urh) ) |
| { |
| /* Connection was suspended, wait for resume. */ |
| was_suspended = true; |
| if (! use_poll) |
| { |
| FD_ZERO (&rs); |
| if (! MHD_add_to_fd_set_ (MHD_itc_r_fd_ (daemon->itc), |
| &rs, |
| NULL, |
| FD_SETSIZE)) |
| { |
| #ifdef HAVE_MESSAGES |
| MHD_DLOG (con->daemon, |
| MHD_SC_SOCKET_OUTSIDE_OF_FDSET_RANGE, |
| _ ("Failed to add FD to fd_set.\n")); |
| #endif |
| goto exit; |
| } |
| if (0 > MHD_SYS_select_ (MHD_itc_r_fd_ (daemon->itc) + 1, |
| &rs, |
| NULL, |
| NULL, |
| NULL)) |
| { |
| const int err = MHD_socket_get_error_ (); |
| |
| if (MHD_SCKT_ERR_IS_EINTR_ (err)) |
| continue; |
| #ifdef HAVE_MESSAGES |
| MHD_DLOG (con->daemon, |
| MHD_SC_UNEXPECTED_SELECT_ERROR, |
| _ ("Error during select (%d): `%s'\n"), |
| err, |
| MHD_socket_strerr_ (err)); |
| #endif |
| break; |
| } |
| } |
| #ifdef HAVE_POLL |
| else /* use_poll */ |
| { |
| p[0].events = POLLIN; |
| p[0].fd = MHD_itc_r_fd_ (daemon->itc); |
| p[0].revents = 0; |
| if (0 > MHD_sys_poll_ (p, |
| 1, |
| -1)) |
| { |
| if (MHD_SCKT_LAST_ERR_IS_ (MHD_SCKT_EINTR_)) |
| continue; |
| #ifdef HAVE_MESSAGES |
| MHD_DLOG (con->daemon, |
| MHD_SC_UNEXPECTED_POLL_ERROR, |
| _ ("Error during poll: `%s'\n"), |
| MHD_socket_last_strerr_ ()); |
| #endif |
| break; |
| } |
| } |
| #endif /* HAVE_POLL */ |
| MHD_itc_clear_ (daemon->itc); |
| continue; /* Check again for resume. */ |
| } /* End of "suspended" branch. */ |
| |
| if (was_suspended) |
| { |
| MHD_connection_update_last_activity_ (con); /* Reset timeout timer. */ |
| /* Process response queued during suspend and update states. */ |
| MHD_request_handle_idle_ (&con->request); |
| was_suspended = false; |
| } |
| |
| tvp = NULL; |
| |
| if ( (MHD_EVENT_LOOP_INFO_BLOCK == con->request.event_loop_info) |
| #ifdef HTTPS_SUPPORT |
| || ( (con->tls_read_ready) && |
| (MHD_EVENT_LOOP_INFO_READ == con->request.event_loop_info) ) |
| #endif /* HTTPS_SUPPORT */ |
| ) |
| { |
| /* do not block: more data may be inside of TLS buffers waiting or |
| * application must provide response data */ |
| tv.tv_sec = 0; |
| tv.tv_usec = 0; |
| tvp = &tv; |
| } |
| if ( (NULL == tvp) && |
| (timeout > 0) ) |
| { |
| now = MHD_monotonic_sec_counter (); |
| if (now - con->last_activity > timeout) |
| tv.tv_sec = 0; |
| else |
| { |
| const time_t seconds_left = timeout - (now - con->last_activity); |
| #if ! defined(_WIN32) || defined(__CYGWIN__) |
| tv.tv_sec = seconds_left; |
| #else /* _WIN32 && !__CYGWIN__ */ |
| if (seconds_left > TIMEVAL_TV_SEC_MAX) |
| tv.tv_sec = TIMEVAL_TV_SEC_MAX; |
| else |
| tv.tv_sec = (_MHD_TIMEVAL_TV_SEC_TYPE) seconds_left; |
| #endif /* _WIN32 && ! __CYGWIN__ */ |
| } |
| tv.tv_usec = 0; |
| tvp = &tv; |
| } |
| if (! use_poll) |
| { |
| /* use select */ |
| bool err_state = false; |
| |
| FD_ZERO (&rs); |
| FD_ZERO (&ws); |
| FD_ZERO (&es); |
| maxsock = MHD_INVALID_SOCKET; |
| switch (con->request.event_loop_info) |
| { |
| case MHD_EVENT_LOOP_INFO_READ: |
| if (! MHD_add_to_fd_set_ (con->socket_fd, |
| &rs, |
| &maxsock, |
| FD_SETSIZE)) |
| err_state = true; |
| break; |
| case MHD_EVENT_LOOP_INFO_WRITE: |
| if (! MHD_add_to_fd_set_ (con->socket_fd, |
| &ws, |
| &maxsock, |
| FD_SETSIZE)) |
| err_state = true; |
| break; |
| case MHD_EVENT_LOOP_INFO_BLOCK: |
| if (! MHD_add_to_fd_set_ (con->socket_fd, |
| &es, |
| &maxsock, |
| FD_SETSIZE)) |
| err_state = true; |
| break; |
| case MHD_EVENT_LOOP_INFO_CLEANUP: |
| /* how did we get here!? */ |
| goto exit; |
| } |
| #if WINDOWS |
| if (MHD_ITC_IS_VALID_ (daemon->itc) ) |
| { |
| if (! MHD_add_to_fd_set_ (MHD_itc_r_fd_ (daemon->itc), |
| &rs, |
| &maxsock, |
| FD_SETSIZE)) |
| err_state = 1; |
| } |
| #endif |
| if (err_state) |
| { |
| #ifdef HAVE_MESSAGES |
| MHD_DLOG (con->daemon, |
| MHD_SC_SOCKET_OUTSIDE_OF_FDSET_RANGE, |
| _ ("Failed to add FD to fd_set.\n")); |
| #endif |
| goto exit; |
| } |
| |
| num_ready = MHD_SYS_select_ (maxsock + 1, |
| &rs, |
| &ws, |
| &es, |
| tvp); |
| if (num_ready < 0) |
| { |
| const int err = MHD_socket_get_error_ (); |
| |
| if (MHD_SCKT_ERR_IS_EINTR_ (err)) |
| continue; |
| #ifdef HAVE_MESSAGES |
| MHD_DLOG (con->daemon, |
| MHD_SC_UNEXPECTED_SELECT_ERROR, |
| _ ("Error during select (%d): `%s'\n"), |
| err, |
| MHD_socket_strerr_ (err)); |
| #endif |
| break; |
| } |
| #if WINDOWS |
| /* Clear ITC before other processing so additional |
| * signals will trigger select() again */ |
| if ( (MHD_ITC_IS_VALID_ (daemon->itc)) && |
| (FD_ISSET (MHD_itc_r_fd_ (daemon->itc), |
| &rs)) ) |
| MHD_itc_clear_ (daemon->itc); |
| #endif |
| if (MHD_NO == |
| MHD_connection_call_handlers_ (con, |
| FD_ISSET (con->socket_fd, |
| &rs), |
| FD_ISSET (con->socket_fd, |
| &ws), |
| FD_ISSET (con->socket_fd, |
| &es)) ) |
| goto exit; |
| } |
| #ifdef HAVE_POLL |
| else |
| { |
| /* use poll */ |
| memset (&p, |
| 0, |
| sizeof (p)); |
| p[0].fd = con->socket_fd; |
| switch (con->request.event_loop_info) |
| { |
| case MHD_EVENT_LOOP_INFO_READ: |
| p[0].events |= POLLIN | MHD_POLL_EVENTS_ERR_DISC; |
| break; |
| case MHD_EVENT_LOOP_INFO_WRITE: |
| p[0].events |= POLLOUT | MHD_POLL_EVENTS_ERR_DISC; |
| break; |
| case MHD_EVENT_LOOP_INFO_BLOCK: |
| p[0].events |= MHD_POLL_EVENTS_ERR_DISC; |
| break; |
| case MHD_EVENT_LOOP_INFO_CLEANUP: |
| /* how did we get here!? */ |
| goto exit; |
| } |
| #if WINDOWS |
| extra_slot = 0; |
| if (MHD_ITC_IS_VALID_ (daemon->itc)) |
| { |
| p[1].events |= POLLIN; |
| p[1].fd = MHD_itc_r_fd_ (daemon->itc); |
| p[1].revents = 0; |
| extra_slot = 1; |
| } |
| #endif |
| if (MHD_sys_poll_ (p, |
| #if WINDOWS |
| 1 + extra_slot, |
| #else |
| 1, |
| #endif |
| (NULL == tvp) ? -1 : tv.tv_sec * 1000) < 0) |
| { |
| if (MHD_SCKT_LAST_ERR_IS_ (MHD_SCKT_EINTR_)) |
| continue; |
| #ifdef HAVE_MESSAGES |
| MHD_DLOG (con->daemon, |
| MHD_SC_UNEXPECTED_POLL_ERROR, |
| _ ("Error during poll: `%s'\n"), |
| MHD_socket_last_strerr_ ()); |
| #endif |
| break; |
| } |
| #if WINDOWS |
| /* Clear ITC before other processing so additional |
| * signals will trigger poll() again */ |
| if ( (MHD_ITC_IS_VALID_ (daemon->itc)) && |
| (0 != (p[1].revents & (POLLERR | POLLHUP | POLLIN))) ) |
| MHD_itc_clear_ (daemon->itc); |
| #endif |
| if (MHD_NO == |
| MHD_connection_call_handlers_ (con, |
| (0 != (p[0].revents & POLLIN)), |
| (0 != (p[0].revents & POLLOUT)), |
| (0 != (p[0].revents & (POLLERR |
| | |
| MHD_POLL_REVENTS_ERR_DISC))) )) |
| goto exit; |
| } |
| #endif |
| #ifdef UPGRADE_SUPPORT |
| if (MHD_REQUEST_UPGRADE == con->request.state) |
| { |
| /* Normal HTTP processing is finished, |
| * notify application. */ |
| if (NULL != con->request.response->termination_cb) |
| con->request.response->termination_cb |
| (con->request.response->termination_cb_cls, |
| MHD_REQUEST_TERMINATED_COMPLETED_OK, |
| con->request.client_context); |
| thread_main_connection_upgrade (con); |
| /* MHD_connection_finish_forward_() was called by thread_main_connection_upgrade(). */ |
| |
| /* "Upgraded" data will not be used in this thread from this point. */ |
| con->request.urh->clean_ready = true; |
| /* If 'urh->was_closed' set to true, connection will be |
| * moved immediately to cleanup list. Otherwise connection |
| * will stay in suspended list until 'urh' will be marked |
| * with 'was_closed' by application. */ |
| MHD_request_resume (&con->request); |
| |
| /* skip usual clean up */ |
| return (MHD_THRD_RTRN_TYPE_) 0; |
| } |
| #endif /* UPGRADE_SUPPORT */ |
| } |
| #if DEBUG_CLOSE |
| #ifdef HAVE_MESSAGES |
| MHD_DLOG (con->daemon, |
| MHD_SC_THREAD_TERMINATING, |
| _ ("Processing thread terminating. Closing connection.\n")); |
| #endif |
| #endif |
| if (MHD_REQUEST_CLOSED != con->request.state) |
| MHD_connection_close_ (con, |
| (daemon->shutdown) ? |
| MHD_REQUEST_TERMINATED_DAEMON_SHUTDOWN : |
| MHD_REQUEST_TERMINATED_WITH_ERROR); |
| MHD_request_handle_idle_ (&con->request); |
| exit: |
| if (NULL != con->request.response) |
| { |
| MHD_response_queue_for_destroy (con->request.response); |
| con->request.response = NULL; |
| } |
| |
| if (MHD_INVALID_SOCKET != con->socket_fd) |
| { |
| shutdown (con->socket_fd, |
| SHUT_WR); |
| /* 'socket_fd' can be used in other thread to signal shutdown. |
| * To avoid data races, do not close socket here. Daemon will |
| * use more connections only after cleanup anyway. */ |
| } |
| return (MHD_THRD_RTRN_TYPE_) 0; |
| } |
| |
| |
| /** |
| * Callback for receiving data from the socket. |
| * |
| * @param connection the MHD connection structure |
| * @param other where to write received data to |
| * @param i maximum size of other (in bytes) |
| * @return positive value for number of bytes actually received or |
| * negative value for error number MHD_ERR_xxx_ |
| */ |
| static ssize_t |
| recv_param_adapter (struct MHD_Connection *connection, |
| void *other, |
| size_t i) |
| { |
| ssize_t ret; |
| |
| if ( (MHD_INVALID_SOCKET == connection->socket_fd) || |
| (MHD_REQUEST_CLOSED == connection->request.state) ) |
| { |
| return MHD_ERR_NOTCONN_; |
| } |
| if (i > MHD_SCKT_SEND_MAX_SIZE_) |
| i = MHD_SCKT_SEND_MAX_SIZE_; /* return value limit */ |
| |
| ret = MHD_recv_ (connection->socket_fd, |
| other, |
| i); |
| if (0 > ret) |
| { |
| const int err = MHD_socket_get_error_ (); |
| if (MHD_SCKT_ERR_IS_EAGAIN_ (err)) |
| { |
| #ifdef EPOLL_SUPPORT |
| /* Got EAGAIN --- no longer read-ready */ |
| connection->epoll_state &= ~MHD_EPOLL_STATE_READ_READY; |
| #endif /* EPOLL_SUPPORT */ |
| return MHD_ERR_AGAIN_; |
| } |
| if (MHD_SCKT_ERR_IS_EINTR_ (err)) |
| return MHD_ERR_AGAIN_; |
| if (MHD_SCKT_ERR_IS_ (err, MHD_SCKT_ECONNRESET_)) |
| return MHD_ERR_CONNRESET_; |
| /* Treat any other error as hard error. */ |
| return MHD_ERR_NOTCONN_; |
| } |
| #ifdef EPOLL_SUPPORT |
| else if (i > (size_t) ret) |
| connection->epoll_state &= ~MHD_EPOLL_STATE_READ_READY; |
| #endif /* EPOLL_SUPPORT */ |
| return ret; |
| } |
| |
| |
| /** |
| * Callback for writing data to the socket. |
| * |
| * @param connection the MHD connection structure |
| * @param other data to write |
| * @param i number of bytes to write |
| * @return positive value for number of bytes actually sent or |
| * negative value for error number MHD_ERR_xxx_ |
| */ |
| static ssize_t |
| send_param_adapter (struct MHD_Connection *connection, |
| const void *other, |
| size_t i) |
| { |
| ssize_t ret; |
| |
| if ( (MHD_INVALID_SOCKET == connection->socket_fd) || |
| (MHD_REQUEST_CLOSED == connection->request.state) ) |
| { |
| return MHD_ERR_NOTCONN_; |
| } |
| if (i > MHD_SCKT_SEND_MAX_SIZE_) |
| i = MHD_SCKT_SEND_MAX_SIZE_; /* return value limit */ |
| |
| ret = MHD_send_ (connection->socket_fd, |
| other, |
| i); |
| if (0 > ret) |
| { |
| const int err = MHD_socket_get_error_ (); |
| |
| if (MHD_SCKT_ERR_IS_EAGAIN_ (err)) |
| { |
| #ifdef EPOLL_SUPPORT |
| /* EAGAIN --- no longer write-ready */ |
| connection->epoll_state &= ~MHD_EPOLL_STATE_WRITE_READY; |
| #endif /* EPOLL_SUPPORT */ |
| return MHD_ERR_AGAIN_; |
| } |
| if (MHD_SCKT_ERR_IS_EINTR_ (err)) |
| return MHD_ERR_AGAIN_; |
| if (MHD_SCKT_ERR_IS_ (err, MHD_SCKT_ECONNRESET_)) |
| return MHD_ERR_CONNRESET_; |
| /* Treat any other error as hard error. */ |
| return MHD_ERR_NOTCONN_; |
| } |
| #ifdef EPOLL_SUPPORT |
| else if (i > (size_t) ret) |
| connection->epoll_state &= ~MHD_EPOLL_STATE_WRITE_READY; |
| #endif /* EPOLL_SUPPORT */ |
| return ret; |
| } |
| |
| |
| /** |
| * Add another client connection to the set of connections |
| * managed by MHD. This API is usually not needed (since |
| * MHD will accept inbound connections on the server socket). |
| * Use this API in special cases, for example if your HTTP |
| * server is behind NAT and needs to connect out to the |
| * HTTP client. |
| * |
| * The given client socket will be managed (and closed!) by MHD after |
| * this call and must no longer be used directly by the application |
| * afterwards. |
| * |
| * @param daemon daemon that manages the connection |
| * @param client_socket socket to manage (MHD will expect |
| * to receive an HTTP request from this socket next). |
| * @param addr IP address of the client |
| * @param addrlen number of bytes in @a addr |
| * @param external_add perform additional operations needed due |
| * to the application calling us directly |
| * @param non_blck indicate that socket in non-blocking mode |
| * @return #MHD_SC_OK on success |
| */ |
| static enum MHD_StatusCode |
| internal_add_connection (struct MHD_Daemon *daemon, |
| MHD_socket client_socket, |
| const struct sockaddr *addr, |
| socklen_t addrlen, |
| bool external_add, |
| bool non_blck) |
| { |
| enum MHD_StatusCode sc; |
| struct MHD_Connection *connection; |
| int eno = 0; |
| |
| /* Direct add to master daemon could happen only with "external" add mode. */ |
| mhd_assert ( (NULL == daemon->worker_pool) || |
| (external_add) ); |
| if ( (external_add) && |
| (NULL != daemon->worker_pool) ) |
| { |
| unsigned int i; |
| |
| /* have a pool, try to find a pool with capacity; we use the |
| socket as the initial offset into the pool for load |
| balancing */ |
| for (i = 0; i < daemon->worker_pool_size; ++i) |
| { |
| struct MHD_Daemon *const worker = |
| &daemon->worker_pool[(i + client_socket) % daemon->worker_pool_size]; |
| if (worker->connections < worker->global_connection_limit) |
| return internal_add_connection (worker, |
| client_socket, |
| addr, |
| addrlen, |
| true, |
| non_blck); |
| } |
| /* all pools are at their connection limit, must refuse */ |
| MHD_socket_close_chk_ (client_socket); |
| #if ENFILE |
| errno = ENFILE; |
| #endif |
| return MHD_SC_LIMIT_CONNECTIONS_REACHED; |
| } |
| |
| if ( (! MHD_SCKT_FD_FITS_FDSET_ (client_socket, |
| NULL)) && |
| (MHD_ELS_SELECT == daemon->event_loop_syscall) ) |
| { |
| #ifdef HAVE_MESSAGES |
| MHD_DLOG (daemon, |
| MHD_SC_SOCKET_OUTSIDE_OF_FDSET_RANGE, |
| _ ("Socket descriptor larger than FD_SETSIZE: %d > %d\n"), |
| (int) client_socket, |
| (int) FD_SETSIZE); |
| #endif |
| MHD_socket_close_chk_ (client_socket); |
| #if EINVAL |
| errno = EINVAL; |
| #endif |
| return MHD_SC_SOCKET_OUTSIDE_OF_FDSET_RANGE; |
| } |
| |
| #ifdef MHD_socket_nosignal_ |
| if (! MHD_socket_nosignal_ (client_socket)) |
| { |
| #ifdef HAVE_MESSAGES |
| MHD_DLOG (daemon, |
| MHD_SC_ACCEPT_CONFIGURE_NOSIGPIPE_FAILED, |
| _ ("Failed to set SO_NOSIGPIPE on accepted socket: %s\n"), |
| MHD_socket_last_strerr_ ()); |
| #endif |
| #ifndef MSG_NOSIGNAL |
| /* Cannot use socket as it can produce SIGPIPE. */ |
| #ifdef ENOTSOCK |
| errno = ENOTSOCK; |
| #endif /* ENOTSOCK */ |
| return MHD_SC_ACCEPT_CONFIGURE_NOSIGPIPE_FAILED; |
| #endif /* ! MSG_NOSIGNAL */ |
| } |
| #endif /* MHD_socket_nosignal_ */ |
| |
| |
| #ifdef HAVE_MESSAGES |
| #if DEBUG_CONNECT |
| MHD_DLOG (daemon, |
| MHD_SC_CONNECTION_ACCEPTED, |
| _ ("Accepted connection on socket %d.\n"), |
| client_socket); |
| #endif |
| #endif |
| if ( (daemon->connections == daemon->global_connection_limit) || |
| (MHD_NO == MHD_ip_limit_add (daemon, |
| addr, |
| addrlen)) ) |
| { |
| /* above connection limit - reject */ |
| #ifdef HAVE_MESSAGES |
| MHD_DLOG (daemon, |
| MHD_SC_LIMIT_CONNECTIONS_REACHED, |
| _ ( |
| "Server reached connection limit. Closing inbound connection.\n")); |
| #endif |
| MHD_socket_close_chk_ (client_socket); |
| #if ENFILE |
| errno = ENFILE; |
| #endif |
| return MHD_SC_LIMIT_CONNECTIONS_REACHED; |
| } |
| |
| /* apply connection acceptance policy if present */ |
| if ( (NULL != daemon->accept_policy_cb) && |
| (MHD_NO == |
| daemon->accept_policy_cb (daemon->accept_policy_cb_cls, |
| addr, |
| addrlen)) ) |
| { |
| #if DEBUG_CLOSE |
| #ifdef HAVE_MESSAGES |
| MHD_DLOG (daemon, |
| MHD_SC_ACCEPT_POLICY_REJECTED, |
| _ ("Connection rejected by application. Closing connection.\n")); |
| #endif |
| #endif |
| MHD_socket_close_chk_ (client_socket); |
| MHD_ip_limit_del (daemon, |
| addr, |
| addrlen); |
| #if EACCESS |
| errno = EACCESS; |
| #endif |
| return MHD_SC_ACCEPT_POLICY_REJECTED; |
| } |
| |
| if (NULL == |
| (connection = MHD_calloc_ (1, |
| sizeof (struct MHD_Connection)))) |
| { |
| eno = errno; |
| #ifdef HAVE_MESSAGES |
| MHD_DLOG (daemon, |
| MHD_SC_CONNECTION_MALLOC_FAILURE, |
| "Error allocating memory: %s\n", |
| MHD_strerror_ (errno)); |
| #endif |
| MHD_socket_close_chk_ (client_socket); |
| MHD_ip_limit_del (daemon, |
| addr, |
| addrlen); |
| errno = eno; |
| return MHD_SC_CONNECTION_MALLOC_FAILURE; |
| } |
| connection->pool |
| = MHD_pool_create (daemon->connection_memory_limit_b); |
| if (NULL == connection->pool) |
| { |
| #ifdef HAVE_MESSAGES |
| MHD_DLOG (daemon, |
| MHD_SC_POOL_MALLOC_FAILURE, |
| _ ("Error allocating memory: %s\n"), |
| MHD_strerror_ (errno)); |
| #endif |
| MHD_socket_close_chk_ (client_socket); |
| MHD_ip_limit_del (daemon, |
| addr, |
| addrlen); |
| free (connection); |
| #if ENOMEM |
| errno = ENOMEM; |
| #endif |
| return MHD_SC_POOL_MALLOC_FAILURE; |
| } |
| |
| connection->connection_timeout = daemon->connection_default_timeout; |
| memcpy (&connection->addr, |
| addr, |
| addrlen); |
| connection->addr_len = addrlen; |
| connection->socket_fd = client_socket; |
| connection->sk_nonblck = non_blck; |
| connection->daemon = daemon; |
| connection->last_activity = MHD_monotonic_sec_counter (); |
| |
| #ifdef HTTPS_SUPPORT |
| if (NULL != daemon->tls_api) |
| { |
| connection->tls_cs |
| = daemon->tls_api->setup_connection (daemon->tls_api->cls, |
| NULL /* FIXME */); |
| if (NULL == connection->tls_cs) |
| { |
| eno = EINVAL; |
| sc = -1; // FIXME! |
| goto cleanup; |
| } |
| } |
| else |
| #endif /* ! HTTPS_SUPPORT */ |
| { |
| /* set default connection handlers */ |
| connection->recv_cls = &recv_param_adapter; |
| connection->send_cls = &send_param_adapter; |
| } |
| MHD_mutex_lock_chk_ (&daemon->cleanup_connection_mutex); |
| /* Firm check under lock. */ |
| if (daemon->connections >= daemon->global_connection_limit) |
| { |
| MHD_mutex_unlock_chk_ (&daemon->cleanup_connection_mutex); |
| /* above connection limit - reject */ |
| #ifdef HAVE_MESSAGES |
| MHD_DLOG (daemon, |
| MHD_SC_LIMIT_CONNECTIONS_REACHED, |
| _ ( |
| "Server reached connection limit. Closing inbound connection.\n")); |
| #endif |
| #if ENFILE |
| eno = ENFILE; |
| #endif |
| sc = MHD_SC_LIMIT_CONNECTIONS_REACHED; |
| goto cleanup; |
| } |
| daemon->connections++; |
| if (MHD_TM_THREAD_PER_CONNECTION != daemon->threading_mode) |
| { |
| XDLL_insert (daemon->normal_timeout_head, |
| daemon->normal_timeout_tail, |
| connection); |
| } |
| DLL_insert (daemon->connections_head, |
| daemon->connections_tail, |
| connection); |
| MHD_mutex_unlock_chk_ (&daemon->cleanup_connection_mutex); |
| |
| if (NULL != daemon->notify_connection_cb) |
| daemon->notify_connection_cb (daemon->notify_connection_cb_cls, |
| connection, |
| MHD_CONNECTION_NOTIFY_STARTED); |
| |
| /* attempt to create handler thread */ |
| if (MHD_TM_THREAD_PER_CONNECTION == daemon->threading_mode) |
| { |
| if (! MHD_create_named_thread_ (&connection->pid, |
| "MHD-connection", |
| daemon->thread_stack_limit_b, |
| &thread_main_handle_connection, |
| connection)) |
| { |
| eno = errno; |
| #ifdef HAVE_MESSAGES |
| MHD_DLOG (daemon, |
| MHD_SC_THREAD_LAUNCH_FAILURE, |
| "Failed to create a thread: %s\n", |
| MHD_strerror_ (eno)); |
| #endif |
| sc = MHD_SC_THREAD_LAUNCH_FAILURE; |
| goto cleanup; |
| } |
| } |
| else |
| { |
| connection->pid = daemon->pid; |
| } |
| #ifdef EPOLL_SUPPORT |
| if (MHD_ELS_EPOLL == daemon->event_loop_syscall) |
| { |
| if ( (! daemon->enable_turbo) || |
| (external_add)) |
| { /* Do not manipulate EReady DL-list in 'external_add' mode. */ |
| struct epoll_event event; |
| |
| event.events = EPOLLIN | EPOLLOUT | EPOLLPRI | EPOLLET; |
| event.data.ptr = connection; |
| if (0 != epoll_ctl (daemon->epoll_fd, |
| EPOLL_CTL_ADD, |
| client_socket, |
| &event)) |
| { |
| eno = errno; |
| #ifdef HAVE_MESSAGES |
| MHD_DLOG (daemon, |
| MHD_SC_EPOLL_CTL_ADD_FAILED, |
| _ ("Call to epoll_ctl failed: %s\n"), |
| MHD_socket_last_strerr_ ()); |
| #endif |
| sc = MHD_SC_EPOLL_CTL_ADD_FAILED; |
| goto cleanup; |
| } |
| connection->epoll_state |= MHD_EPOLL_STATE_IN_EPOLL_SET; |
| } |
| else |
| { |
| connection->epoll_state |= MHD_EPOLL_STATE_READ_READY |
| | MHD_EPOLL_STATE_WRITE_READY |
| | MHD_EPOLL_STATE_IN_EREADY_EDLL; |
| EDLL_insert (daemon->eready_head, |
| daemon->eready_tail, |
| connection); |
| } |
| } |
| else /* This 'else' is combined with next 'if'. */ |
| #endif |
| if ( (MHD_TM_THREAD_PER_CONNECTION != daemon->threading_mode) && |
| (external_add) && |
| (MHD_ITC_IS_VALID_ (daemon->itc)) && |
| (! MHD_itc_activate_ (daemon->itc, |
| "n")) ) |
| { |
| #ifdef HAVE_MESSAGES |
| MHD_DLOG (daemon, |
| MHD_SC_ITC_USE_FAILED, |
| _ ( |
| "Failed to signal new connection via inter-thread communication channel (not necessarily fatal, continuing anyway).\n")); |
| #endif |
| } |
| return MHD_SC_OK; |
| |
| cleanup: |
| if (NULL != daemon->notify_connection_cb) |
| daemon->notify_connection_cb (daemon->notify_connection_cb_cls, |
| connection, |
| MHD_CONNECTION_NOTIFY_CLOSED); |
| #ifdef HTTPS_SUPPORT |
| if ( (NULL != daemon->tls_api) && |
| (NULL != connection->tls_cs) ) |
| daemon->tls_api->teardown_connection (daemon->tls_api->cls, |
| connection->tls_cs); |
| #endif /* HTTPS_SUPPORT */ |
| MHD_socket_close_chk_ (client_socket); |
| MHD_ip_limit_del (daemon, |
| addr, |
| addrlen); |
| MHD_mutex_lock_chk_ (&daemon->cleanup_connection_mutex); |
| if (MHD_TM_THREAD_PER_CONNECTION != daemon->threading_mode) |
| { |
| XDLL_remove (daemon->normal_timeout_head, |
| daemon->normal_timeout_tail, |
| connection); |
| } |
| DLL_remove (daemon->connections_head, |
| daemon->connections_tail, |
| connection); |
| MHD_mutex_unlock_chk_ (&daemon->cleanup_connection_mutex); |
| MHD_pool_destroy (connection->pool); |
| free (connection); |
| if (0 != eno) |
| errno = eno; |
| else |
| errno = EINVAL; |
| return sc; |
| } |
| |
| |
| /** |
| * Add another client connection to the set of connections managed by |
| * MHD. This API is usually not needed (since MHD will accept inbound |
| * connections on the server socket). Use this API in special cases, |
| * for example if your HTTP server is behind NAT and needs to connect |
| * out to the HTTP client, or if you are building a proxy. |
| * |
| * If you use this API in conjunction with a internal select or a |
| * thread pool, you must set the option #MHD_USE_ITC to ensure that |
| * the freshly added connection is immediately processed by MHD. |
| * |
| * The given client socket will be managed (and closed!) by MHD after |
| * this call and must no longer be used directly by the application |
| * afterwards. |
| * |
| * @param daemon daemon that manages the connection |
| * @param client_socket socket to manage (MHD will expect |
| * to receive an HTTP request from this socket next). |
| * @param addr IP address of the client |
| * @param addrlen number of bytes in @a addr |
| * @return #MHD_YES on success, #MHD_NO if this daemon could |
| * not handle the connection (i.e. malloc() failed, etc). |
| * The socket will be closed in any case; `errno` is |
| * set to indicate further details about the error. |
| * @ingroup specialized |
| */ |
| enum MHD_StatusCode |
| MHD_daemon_add_connection (struct MHD_Daemon *daemon, |
| MHD_socket client_socket, |
| const struct sockaddr *addr, |
| socklen_t addrlen) |
| { |
| bool sk_nonbl; |
| |
| if (! MHD_socket_nonblocking_ (client_socket)) |
| { |
| #ifdef HAVE_MESSAGES |
| MHD_DLOG (daemon, |
| MHD_SC_ACCEPT_CONFIGURE_NONBLOCKING_FAILED, |
| _ ("Failed to set nonblocking mode on new client socket: %s\n"), |
| MHD_socket_last_strerr_ ()); |
| #endif |
| sk_nonbl = false; |
| } |
| else |
| { |
| sk_nonbl = true; |
| } |
| |
| if ( (daemon->enable_turbo) && |
| (! MHD_socket_noninheritable_ (client_socket)) ) |
| { |
| #ifdef HAVE_MESSAGES |
| MHD_DLOG (daemon, |
| MHD_SC_ACCEPT_CONFIGURE_NOINHERIT_FAILED, |
| _ ("Failed to set noninheritable mode on new client socket.\n")); |
| #endif |
| } |
| return internal_add_connection (daemon, |
| client_socket, |
| addr, |
| addrlen, |
| true, |
| sk_nonbl); |
| } |
| |
| |
| /** |
| * 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. @remark To be called only from thread |
| * that process daemon's select()/poll()/etc. |
| * |
| * @param daemon handle with the listen socket |
| * @return #MHD_SC_OK on success |
| */ |
| enum MHD_StatusCode |
| MHD_accept_connection_ (struct MHD_Daemon *daemon) |
| { |
| struct sockaddr_storage addrstorage; |
| struct sockaddr *addr = (struct sockaddr *) &addrstorage; |
| socklen_t addrlen; |
| MHD_socket s; |
| MHD_socket fd; |
| bool sk_nonbl; |
| |
| addrlen = sizeof (addrstorage); |
| memset (addr, |
| 0, |
| sizeof (addrstorage)); |
| if ( (MHD_INVALID_SOCKET == (fd = daemon->listen_socket)) || |
| (daemon->was_quiesced) ) |
| return MHD_SC_DAEMON_ALREADY_QUIESCED; |
| #ifdef USE_ACCEPT4 |
| s = accept4 (fd, |
| addr, |
| &addrlen, |
| MAYBE_SOCK_CLOEXEC | MAYBE_SOCK_NONBLOCK); |
| sk_nonbl = (0 != MAYBE_SOCK_NONBLOCK); |
| #else /* ! USE_ACCEPT4 */ |
| s = accept (fd, |
| addr, |
| &addrlen); |
| sk_nonbl = false; |
| #endif /* ! USE_ACCEPT4 */ |
| if ( (MHD_INVALID_SOCKET == s) || |
| (addrlen <= 0) ) |
| { |
| const int err = MHD_socket_get_error_ (); |
| |
| /* This could be a common occurrence with multiple worker threads */ |
| if (MHD_SCKT_ERR_IS_ (err, |
| MHD_SCKT_EINVAL_)) |
| return MHD_SC_DAEMON_ALREADY_SHUTDOWN; /* can happen during shutdown, let's hope this is the cause... */ |
| if (MHD_SCKT_ERR_IS_DISCNN_BEFORE_ACCEPT_ (err)) |
| return MHD_SC_ACCEPT_FAST_DISCONNECT; /* do not print error if client just disconnected early */ |
| if (MHD_SCKT_ERR_IS_EAGAIN_ (err) ) |
| return MHD_SC_ACCEPT_FAILED_EAGAIN; |
| if (MHD_INVALID_SOCKET != s) |
| { |
| MHD_socket_close_chk_ (s); |
| } |
| if (MHD_SCKT_ERR_IS_LOW_RESOURCES_ (err) ) |
| { |
| /* system/process out of resources */ |
| if (0 == daemon->connections) |
| { |
| #ifdef HAVE_MESSAGES |
| /* Not setting 'at_limit' flag, as there is no way it |
| would ever be cleared. Instead trying to produce |
| bit fat ugly warning. */ |
| MHD_DLOG (daemon, |
| MHD_SC_ACCEPT_SYSTEM_LIMIT_REACHED_INSTANTLY, |
| _ ( |
| "Hit process or system resource limit at FIRST connection. This is really bad as there is no sane way to proceed. Will try busy waiting for system resources to become magically available.\n")); |
| #endif |
| return MHD_SC_ACCEPT_SYSTEM_LIMIT_REACHED_INSTANTLY; |
| } |
| else |
| { |
| MHD_mutex_lock_chk_ (&daemon->cleanup_connection_mutex); |
| daemon->at_limit = true; |
| MHD_mutex_unlock_chk_ (&daemon->cleanup_connection_mutex); |
| #ifdef HAVE_MESSAGES |
| MHD_DLOG (daemon, |
| MHD_SC_ACCEPT_SYSTEM_LIMIT_REACHED, |
| _ ( |
| "Hit process or system resource limit at %u connections, temporarily suspending accept(). Consider setting a lower MHD_OPTION_CONNECTION_LIMIT.\n"), |
| (unsigned int) daemon->connections); |
| #endif |
| return MHD_SC_ACCEPT_SYSTEM_LIMIT_REACHED; |
| } |
| } |
| #ifdef HAVE_MESSAGES |
| MHD_DLOG (daemon, |
| MHD_SC_ACCEPT_FAILED_UNEXPECTEDLY, |
| _ ("Error accepting connection: %s\n"), |
| MHD_socket_strerr_ (err)); |
| #endif |
| return MHD_SC_ACCEPT_FAILED_UNEXPECTEDLY; |
| } |
| #if ! defined(USE_ACCEPT4) || ! defined(HAVE_SOCK_NONBLOCK) |
| if (! MHD_socket_nonblocking_ (s)) |
| { |
| #ifdef HAVE_MESSAGES |
| MHD_DLOG (daemon, |
| MHD_SC_ACCEPT_CONFIGURE_NONBLOCKING_FAILED, |
| _ ( |
| "Failed to set nonblocking mode on incoming connection socket: %s\n"), |
| MHD_socket_last_strerr_ ()); |
| #endif |
| } |
| else |
| sk_nonbl = true; |
| #endif /* !USE_ACCEPT4 || !HAVE_SOCK_NONBLOCK */ |
| #if ! defined(USE_ACCEPT4) || ! defined(SOCK_CLOEXEC) |
| if (! MHD_socket_noninheritable_ (s)) |
| { |
| #ifdef HAVE_MESSAGES |
| MHD_DLOG (daemon, |
| MHD_SC_ACCEPT_CONFIGURE_NOINHERIT_FAILED, |
| _ ( |
| "Failed to set noninheritable mode on incoming connection socket.\n")); |
| #endif |
| } |
| #endif /* !USE_ACCEPT4 || !SOCK_CLOEXEC */ |
| #ifdef HAVE_MESSAGES |
| #if DEBUG_CONNECT |
| MHD_DLOG (daemon, |
| MHD_SC_CONNECTION_ACCEPTED, |
| _ ("Accepted connection on socket %d.\n"), |
| s); |
| #endif |
| #endif |
| return internal_add_connection (daemon, |
| s, |
| addr, |
| addrlen, |
| false, |
| sk_nonbl); |
| } |
| |
| |
| /* end of connection_add.c */ |
