internal.h

Go to the documentation of this file.

/*
  This file is part of libmicrohttpd
  Copyright (C) 2007-2018 Daniel Pittman and Christian Grothoff
  Copyright (C) 2014-2023 Evgeny Grin (Karlson2k)
 
  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
*/

 
#ifndef INTERNAL_H
#define INTERNAL_H
 
#include "mhd_options.h"
#include "platform.h"
#include "microhttpd.h"
#include "mhd_assert.h"
 
#ifdef HTTPS_SUPPORT
#include <gnutls/gnutls.h>
#if GNUTLS_VERSION_MAJOR >= 3
#include <gnutls/abstract.h>
#endif
#endif /* HTTPS_SUPPORT */
 
#ifdef HAVE_STDBOOL_H
#include <stdbool.h>
#endif
 
#ifdef HAVE_INTTYPES_H
#include <inttypes.h>
#endif /* HAVE_INTTYPES_H */
 
#ifndef PRIu64
#define PRIu64  "llu"
#endif /* ! PRIu64 */
 
/* Must be included before other internal headers! */
#include "mhd_panic.h"
 
#if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
#include "mhd_threads.h"
#endif
#include "mhd_locks.h"
#include "mhd_sockets.h"
#include "mhd_itc_types.h"
#include "mhd_str_types.h"
#if defined(BAUTH_SUPPORT) || defined(DAUTH_SUPPORT)
#include "gen_auth.h"
#endif /* BAUTH_SUPPORT || DAUTH_SUPPORT*/
 

#define _MHD_DROP_CONST(ptr)    ((void *) ((uintptr_t) ((const void *) (ptr))))

#define _MHD_MACRO_NO   0

#define _MHD_MACRO_YES  1

#define MHD_fd_close_chk_(fd) do {                      \
    if ( (0 != close ((fd)) && (EBADF == errno)) ) {    \
      MHD_PANIC (_ ("Failed to close FD.\n"));          \
    }                                                   \
} while (0)
 
/*
#define EXTRA_CHECKS _MHD_MACRO_NO
 * Not used. Behaviour is controlled by _DEBUG/NDEBUG macros.
 */
 
#ifndef _MHD_DEBUG_CONNECT
#define _MHD_DEBUG_CONNECT _MHD_MACRO_NO
#endif /* ! _MHD_DEBUG_CONNECT */
 
#ifndef _MHD_DEBUG_SEND_DATA
#define _MHD_DEBUG_SEND_DATA _MHD_MACRO_NO
#endif /* ! _MHD_DEBUG_SEND_DATA */
 
#ifndef _MHD_DEBUG_CLOSE
#define _MHD_DEBUG_CLOSE _MHD_MACRO_NO
#endif /* ! _MHD_DEBUG_CLOSE */
 
#define MHD_MAX(a,b) (((a)<(b)) ? (b) : (a))
#define MHD_MIN(a,b) (((a)<(b)) ? (a) : (b))
 

#define MHD_BUF_INC_SIZE 1500
 
#ifndef MHD_STATICSTR_LEN_
#define MHD_STATICSTR_LEN_(macro) (sizeof(macro) / sizeof(char) - 1)
#endif /* ! MHD_STATICSTR_LEN_ */
 

enum MHD_tristate
{
  _MHD_UNKNOWN = -1,    
  _MHD_OFF     = false, 
  _MHD_NO      = false, 
  _MHD_ON      = true,  
  _MHD_YES     = true   
} _MHD_FIXED_ENUM;
 

enum MHD_EpollState
{

  MHD_EPOLL_STATE_UNREADY = 0,

  MHD_EPOLL_STATE_READ_READY = 1,

  MHD_EPOLL_STATE_WRITE_READY = 2,

  MHD_EPOLL_STATE_IN_EREADY_EDLL = 4,

  MHD_EPOLL_STATE_IN_EPOLL_SET = 8,

  MHD_EPOLL_STATE_SUSPENDED = 16,

  MHD_EPOLL_STATE_ERROR = 128
} _MHD_FIXED_FLAGS_ENUM;
 

enum MHD_ConnectionEventLoopInfo
{
  MHD_EVENT_LOOP_INFO_READ = 1 << 0,

  MHD_EVENT_LOOP_INFO_WRITE = 1 << 1,

  MHD_EVENT_LOOP_INFO_PROCESS = 1 << 2,

  MHD_EVENT_LOOP_INFO_PROCESS_READ =
    MHD_EVENT_LOOP_INFO_READ | MHD_EVENT_LOOP_INFO_PROCESS,

  MHD_EVENT_LOOP_INFO_CLEANUP = 1 << 3
} _MHD_FIXED_ENUM;
 

#define MHD_TEST_ALLOW_SUSPEND_RESUME 8192

#define MAX_CLIENT_NONCE_LENGTH 129

#if defined(MHD_SHA256_SUPPORT) || defined(MHD_SHA512_256_SUPPORT)
#define MAX_DIGEST_NONCE_LENGTH ((32 + 6) * 2)
#else  /* !MHD_SHA256_SUPPORT && !MHD_SHA512_256_SUPPORT */
#define MAX_DIGEST_NONCE_LENGTH ((16 + 6) * 2)
#endif /* !MHD_SHA256_SUPPORT && !MHD_SHA512_256_SUPPORT */

struct MHD_NonceNc
{

  uint32_t nc;

  uint64_t nmask;

  char nonce[MAX_DIGEST_NONCE_LENGTH + 1];
 
};
 
#ifdef HAVE_MESSAGES
void
MHD_DLOG (const struct MHD_Daemon *daemon,
          const char *format,
          ...);
 
#endif
 

struct MHD_HTTP_Res_Header
{
  struct MHD_HTTP_Res_Header *next;

  struct MHD_HTTP_Res_Header *prev;

  char *header;

  size_t header_size;

  char *value;

  size_t value_size;

  enum MHD_ValueKind kind;
 
};
 

struct MHD_HTTP_Req_Header
{
  struct MHD_HTTP_Req_Header *next;

  struct MHD_HTTP_Req_Header *prev;

  const char *header;

  size_t header_size;

  const char *value;

  size_t value_size;

  enum MHD_ValueKind kind;
 
};
 

enum MHD_ResponseAutoFlags
{
  MHD_RAF_NO_FLAGS = 0,                   
  MHD_RAF_HAS_CONNECTION_HDR = 1 << 0,    
  MHD_RAF_HAS_CONNECTION_CLOSE = 1 << 1,  
  MHD_RAF_HAS_TRANS_ENC_CHUNKED = 1 << 2, 
  MHD_RAF_HAS_CONTENT_LENGTH = 1 << 3,    
  MHD_RAF_HAS_DATE_HDR = 1 << 4           
} _MHD_FIXED_FLAGS_ENUM;
 
 
#if defined(MHD_WINSOCK_SOCKETS)
typedef struct _MHD_W32_iovec
{
  unsigned long iov_len;
  char *iov_base;
} MHD_iovec_;
#define MHD_IOV_ELMN_MAX_SIZE    ULONG_MAX
typedef unsigned long MHD_iov_size_;
#elif defined(HAVE_SENDMSG) || defined(HAVE_WRITEV)
typedef struct iovec MHD_iovec_;
#define MHD_IOV_ELMN_MAX_SIZE    SIZE_MAX
typedef size_t MHD_iov_size_;
#else
typedef struct MHD_IoVec MHD_iovec_;
#define MHD_IOV_ELMN_MAX_SIZE    SIZE_MAX
typedef size_t MHD_iov_size_;
#endif
 
 
struct MHD_iovec_track_
{
  MHD_iovec_ *iov;

  size_t cnt;

  size_t sent;
};

struct MHD_Response
{

  struct MHD_HTTP_Res_Header *first_header;

  struct MHD_HTTP_Res_Header *last_header;

  const char *data;

  void *crc_cls;

  MHD_ContentReaderCallback crc;

  MHD_ContentReaderFreeCallback crfc;
 
#ifdef UPGRADE_SUPPORT
  MHD_UpgradeHandler upgrade_handler;

  void *upgrade_handler_cls;
#endif /* UPGRADE_SUPPORT */
 
#if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
  MHD_mutex_ mutex;
#endif

  uint64_t total_size;

  uint64_t data_start;

  uint64_t fd_off;

  size_t data_size;

  size_t data_buffer_size;

  unsigned int reference_count;

  int fd;

  enum MHD_ResponseFlags flags;

  enum MHD_ResponseAutoFlags flags_auto;

  bool is_pipe;

  MHD_iovec_ *data_iov;

  unsigned int data_iovcnt;
};
 

enum MHD_CONNECTION_STATE
{
  MHD_CONNECTION_INIT = 0,

  MHD_CONNECTION_REQ_LINE_RECEIVING = MHD_CONNECTION_INIT + 1,

  MHD_CONNECTION_REQ_LINE_RECEIVED = MHD_CONNECTION_REQ_LINE_RECEIVING + 1,

  MHD_CONNECTION_REQ_HEADERS_RECEIVING = MHD_CONNECTION_REQ_LINE_RECEIVED + 1,

  MHD_CONNECTION_HEADERS_RECEIVED = MHD_CONNECTION_REQ_HEADERS_RECEIVING + 1,

  MHD_CONNECTION_HEADERS_PROCESSED = MHD_CONNECTION_HEADERS_RECEIVED + 1,

  MHD_CONNECTION_CONTINUE_SENDING = MHD_CONNECTION_HEADERS_PROCESSED + 1,

  MHD_CONNECTION_BODY_RECEIVING = MHD_CONNECTION_CONTINUE_SENDING + 1,

  MHD_CONNECTION_BODY_RECEIVED = MHD_CONNECTION_BODY_RECEIVING + 1,

  MHD_CONNECTION_FOOTERS_RECEIVING = MHD_CONNECTION_BODY_RECEIVED + 1,

  MHD_CONNECTION_FOOTERS_RECEIVED = MHD_CONNECTION_FOOTERS_RECEIVING + 1,

  MHD_CONNECTION_FULL_REQ_RECEIVED = MHD_CONNECTION_FOOTERS_RECEIVED + 1,

  MHD_CONNECTION_START_REPLY = MHD_CONNECTION_FULL_REQ_RECEIVED + 1,

  MHD_CONNECTION_HEADERS_SENDING = MHD_CONNECTION_START_REPLY + 1,

  MHD_CONNECTION_HEADERS_SENT = MHD_CONNECTION_HEADERS_SENDING + 1,

  MHD_CONNECTION_NORMAL_BODY_UNREADY = MHD_CONNECTION_HEADERS_SENT + 1,

  MHD_CONNECTION_NORMAL_BODY_READY = MHD_CONNECTION_NORMAL_BODY_UNREADY + 1,

  MHD_CONNECTION_CHUNKED_BODY_UNREADY = MHD_CONNECTION_NORMAL_BODY_READY + 1,

  MHD_CONNECTION_CHUNKED_BODY_READY = MHD_CONNECTION_CHUNKED_BODY_UNREADY + 1,

  MHD_CONNECTION_CHUNKED_BODY_SENT = MHD_CONNECTION_CHUNKED_BODY_READY + 1,

  MHD_CONNECTION_FOOTERS_SENDING = MHD_CONNECTION_CHUNKED_BODY_SENT + 1,

  MHD_CONNECTION_FULL_REPLY_SENT = MHD_CONNECTION_FOOTERS_SENDING + 1,

  MHD_CONNECTION_CLOSED = MHD_CONNECTION_FULL_REPLY_SENT + 1
 
#ifdef UPGRADE_SUPPORT
  ,
  MHD_CONNECTION_UPGRADE = MHD_CONNECTION_CLOSED + 1
#endif /* UPGRADE_SUPPORT */
 
} _MHD_FIXED_ENUM;
 

enum MHD_TLS_CONN_STATE
{
  MHD_TLS_CONN_NO_TLS = 0,  
  MHD_TLS_CONN_INIT,        
  MHD_TLS_CONN_HANDSHAKING, 
  MHD_TLS_CONN_CONNECTED,   
  MHD_TLS_CONN_WR_CLOSING,  
  MHD_TLS_CONN_WR_CLOSED,   
  MHD_TLS_CONN_TLS_CLOSING, 
  MHD_TLS_CONN_TLS_CLOSED,  
  MHD_TLS_CONN_TLS_FAILED,  
  MHD_TLS_CONN_INVALID_STATE
} _MHD_FIXED_ENUM;

#define DEBUG_STATES _MHD_MACRO_NO
 
 
#ifdef HAVE_MESSAGES
#if DEBUG_STATES
const char *
MHD_state_to_string (enum MHD_CONNECTION_STATE state);
 
#endif
#endif

typedef ssize_t
(*ReceiveCallback) (struct MHD_Connection *conn,
                    void *write_to,
                    size_t max_bytes);
 

typedef ssize_t
(*TransmitCallback) (struct MHD_Connection *conn,
                     const void *read_from,
                     size_t max_bytes);
 

enum MHD_ConnKeepAlive
{
  MHD_CONN_MUST_CLOSE = -1,

  MHD_CONN_KEEPALIVE_UNKOWN = 0,

  MHD_CONN_USE_KEEPALIVE = 1,

  MHD_CONN_MUST_UPGRADE = 2
} _MHD_FIXED_ENUM;
 
enum MHD_HTTP_Version
{
  MHD_HTTP_VER_INVALID = -1,

  MHD_HTTP_VER_UNKNOWN = 0,

  MHD_HTTP_VER_TOO_OLD = 1,

  MHD_HTTP_VER_1_0 = 2,

  MHD_HTTP_VER_1_1 = 3,

  MHD_HTTP_VER_1_2__1_9 = 4,

  MHD_HTTP_VER_FUTURE = 100
} _MHD_FIXED_ENUM;

#define MHD_IS_HTTP_VER_SUPPORTED(ver) (MHD_HTTP_VER_1_0 <= (ver) && \
                                        MHD_HTTP_VER_1_2__1_9 >= (ver))

#define MHD_IS_HTTP_VER_1_1_COMPAT(ver) (MHD_HTTP_VER_1_1 == (ver) || \
                                         MHD_HTTP_VER_1_2__1_9 == (ver))

enum MHD_HTTP_Method
{
  MHD_HTTP_MTHD_NO_METHOD = 0,
  MHD_HTTP_MTHD_GET = 1,
  MHD_HTTP_MTHD_HEAD = 2,
  MHD_HTTP_MTHD_POST = 3,
  MHD_HTTP_MTHD_PUT = 4,
  MHD_HTTP_MTHD_DELETE = 5,
  MHD_HTTP_MTHD_CONNECT = 6,
  MHD_HTTP_MTHD_OPTIONS = 7,
  MHD_HTTP_MTHD_TRACE = 8,
  MHD_HTTP_MTHD_OTHER = 1000
} _MHD_FIXED_ENUM;
 

struct MHD_RequestLineProcessing
{
  size_t proc_pos;
  unsigned int skipped_empty_lines;
  size_t last_ws_start;
  size_t last_ws_end;
  char *rq_tgt;
  char *rq_tgt_qmark;
  size_t num_ws_in_uri;
};

struct MHD_HeaderProcessing
{
  size_t proc_pos;

  size_t ws_start;

  bool name_end_found;

  size_t name_len;

  size_t value_start;

  bool starts_with_ws;
};

union MHD_HeadersProcessing
{
  struct MHD_RequestLineProcessing rq_line;

  struct MHD_HeaderProcessing hdr;
};
 

union MHD_StartOrSize
{
  const char *start;
  size_t size;
};

struct MHD_Request
{
  const char *version;

  enum MHD_HTTP_Version http_ver;

  const char *method;

  enum MHD_HTTP_Method http_mthd;

  const char *url;

  size_t url_len;

  size_t req_target_len;

  const char *url_for_callback;

  struct MHD_HTTP_Req_Header *headers_received;

  struct MHD_HTTP_Req_Header *headers_received_tail;

  size_t header_size;

  union MHD_StartOrSize field_lines;

  uint64_t remaining_upload_size;

  bool have_chunked_upload;

  uint64_t current_chunk_size;

  uint64_t current_chunk_offset;

  bool some_payload_processed;

  void *client_context;

  bool client_aware;
 
#ifdef BAUTH_SUPPORT
  const struct MHD_RqBAuth *bauth;

  bool bauth_tried;
#endif /* BAUTH_SUPPORT */
#ifdef DAUTH_SUPPORT
  const struct MHD_RqDAuth *dauth;

  bool dauth_tried;
#endif /* DAUTH_SUPPORT */
  size_t num_cr_sp_replaced;

  size_t skipped_broken_lines;

  union MHD_HeadersProcessing hdrs;
};
 

struct MHD_Reply_Properties
{
#ifdef _DEBUG
  bool set; 
#endif /* _DEBUG */
  bool use_reply_body_headers; 
  bool send_reply_body; 
  bool chunked; 
};
 
#if defined(_MHD_HAVE_SENDFILE)
enum MHD_resp_sender_
{
  MHD_resp_sender_std = 0,
  MHD_resp_sender_sendfile
};
#endif /* _MHD_HAVE_SENDFILE */

struct MHD_Reply
{
  struct MHD_Response *response;

  unsigned int responseCode;

  bool responseIcy;

  uint64_t rsp_write_position;

  struct MHD_iovec_track_ resp_iov;
 
#if defined(_MHD_HAVE_SENDFILE)
  enum MHD_resp_sender_ resp_sender;
#endif /* _MHD_HAVE_SENDFILE */

  struct MHD_Reply_Properties props;
};

struct MHD_Connection
{
 
#ifdef EPOLL_SUPPORT
  struct MHD_Connection *nextE;

  struct MHD_Connection *prevE;
#endif

  struct MHD_Connection *next;

  struct MHD_Connection *prev;

  struct MHD_Connection *nextX;

  struct MHD_Connection *prevX;

  struct MHD_Daemon *daemon;

  struct MHD_Request rq;

  struct MHD_Reply rp;

  struct MemoryPool *pool;

  void *socket_context;

  enum MHD_ConnKeepAlive keepalive;

  char *read_buffer;

  char *write_buffer;

  struct sockaddr_storage *addr;
 
#if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
  MHD_thread_handle_ID_ tid;
#endif

  size_t read_buffer_size;

  size_t read_buffer_offset;

  size_t write_buffer_size;

  size_t write_buffer_send_offset;

  size_t write_buffer_append_offset;

  size_t continue_message_write_offset;

  socklen_t addr_len;

  uint64_t last_activity;

  uint64_t connection_timeout_ms;

  MHD_socket socket_fd;

  enum MHD_tristate is_nonip;

  bool sk_nonblck;

  bool sk_spipe_suppress;

  enum MHD_tristate sk_corked;

  enum MHD_tristate sk_nodelay;

  bool read_closed;

  bool stop_with_error;

  bool discard_request;
 
#if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
  bool thread_joined;
#endif

  bool in_idle;

  bool in_cleanup;
 
#ifdef EPOLL_SUPPORT
  enum MHD_EpollState epoll_state;
#endif

  enum MHD_CONNECTION_STATE state;

  enum MHD_ConnectionEventLoopInfo event_loop_info;

  ReceiveCallback recv_cls;
 
#ifdef UPGRADE_SUPPORT
  struct MHD_UpgradeResponseHandle *urh;
#endif /* UPGRADE_SUPPORT */
 
#ifdef HTTPS_SUPPORT

  gnutls_session_t tls_session;

  enum MHD_TLS_CONN_STATE tls_state;

  bool tls_read_ready;
#endif /* HTTPS_SUPPORT */

  bool suspended;

  bool in_access_handler;

  volatile bool resuming;

  union MHD_ConnectionInfo connection_info_dummy;
};
 
 
#ifdef UPGRADE_SUPPORT
#define RESERVE_EBUF_SIZE 8

struct UpgradeEpollHandle
{
  struct MHD_UpgradeResponseHandle *urh;

  MHD_socket socket;

  enum MHD_EpollState celi;
 
};
 

struct MHD_UpgradeResponseHandle
{
  struct MHD_Connection *connection;
 
#ifdef HTTPS_SUPPORT
  struct MHD_UpgradeResponseHandle *next;

  struct MHD_UpgradeResponseHandle *prev;
 
#ifdef EPOLL_SUPPORT
  struct MHD_UpgradeResponseHandle *nextE;

  struct MHD_UpgradeResponseHandle *prevE;

  bool in_eready_list;
#endif

  char *in_buffer;

  char *out_buffer;

  size_t in_buffer_size;

  size_t out_buffer_size;

  size_t in_buffer_used;

  size_t out_buffer_used;

  struct UpgradeEpollHandle app;

  struct UpgradeEpollHandle mhd;

  char e_buf[RESERVE_EBUF_SIZE];
 
#endif /* HTTPS_SUPPORT */

  volatile bool was_closed;

  volatile bool clean_ready;
};
#endif /* UPGRADE_SUPPORT */
 

typedef void *
(*LogCallback)(void *cls,
               const char *uri,
               struct MHD_Connection *con);

typedef size_t
(*UnescapeCallback)(void *cls,
                    struct MHD_Connection *conn,
                    char *uri);
 

struct MHD_Daemon
{

  MHD_AccessHandlerCallback default_handler;

  void *default_handler_cls;

  enum MHD_FLAG options;

  struct MHD_Connection *new_connections_head;

  struct MHD_Connection *new_connections_tail;

  struct MHD_Connection *connections_head;

  struct MHD_Connection *connections_tail;

  struct MHD_Connection *suspended_connections_head;

  struct MHD_Connection *suspended_connections_tail;

  struct MHD_Connection *cleanup_head;

  struct MHD_Connection *cleanup_tail;

  enum MHD_tristate listen_is_unix;
 
#ifdef EPOLL_SUPPORT
  struct MHD_Connection *eready_head;

  struct MHD_Connection *eready_tail;

  int epoll_fd;

  bool listen_socket_in_epoll;
 
#ifdef UPGRADE_SUPPORT
#ifdef HTTPS_SUPPORT
  int epoll_upgrade_fd;

  bool upgrade_fd_in_epoll;
#endif /* HTTPS_SUPPORT */

  struct MHD_UpgradeResponseHandle *eready_urh_head;

  struct MHD_UpgradeResponseHandle *eready_urh_tail;
#endif /* UPGRADE_SUPPORT */
#endif /* EPOLL_SUPPORT */

  struct MHD_Connection *normal_timeout_head;

  struct MHD_Connection *normal_timeout_tail;

  struct MHD_Connection *manual_timeout_head;

  struct MHD_Connection *manual_timeout_tail;

  MHD_AcceptPolicyCallback apc;

  void *apc_cls;

  MHD_RequestCompletedCallback notify_completed;

  void *notify_completed_cls;

  MHD_NotifyConnectionCallback notify_connection;

  void *notify_connection_cls;

  LogCallback uri_log_callback;

  void *uri_log_callback_cls;

  UnescapeCallback unescape_callback;

  void *unescape_callback_cls;

  uint16_t port;
 
#ifdef HAVE_MESSAGES
  MHD_LogCallback custom_error_log;

  void *custom_error_log_cls;
#endif

  struct MHD_Daemon *master;

  MHD_socket listen_fd;

  bool listen_nonblk;
 
#if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
  struct MHD_Daemon *worker_pool;
#endif

  void *per_ip_connection_count;

  unsigned int connections;

  size_t pool_size;

  size_t pool_increment;
 
#if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
  size_t thread_stack_size;

  unsigned int worker_pool_size;

  MHD_thread_handle_ID_ tid;

  MHD_mutex_ per_ip_connection_mutex;

  MHD_mutex_ cleanup_connection_mutex;

  MHD_mutex_ new_connections_mutex;
#endif

  enum MHD_DisableSanityCheck insanity_level;

  int listening_address_reuse;
 

  struct MHD_itc_ itc;

  volatile bool shutdown;

  volatile bool was_quiesced;

  bool at_limit;
 
  /*
   * Do we need to process resuming connections?
   */
  volatile bool resuming;

  volatile bool have_new;

  bool data_already_pending;

  unsigned int connection_limit;

  uint64_t connection_timeout_ms;

  unsigned int per_ip_connection_limit;

  int client_discipline;

  int allow_bzero_in_url;
 
#ifdef HAS_FD_SETSIZE_OVERRIDABLE
  int fdset_size;

  bool fdset_size_set_by_app;
#endif /* HAS_FD_SETSIZE_OVERRIDABLE */

  bool sigpipe_blocked;
 
#ifdef HTTPS_SUPPORT
#ifdef UPGRADE_SUPPORT
  struct MHD_UpgradeResponseHandle *urh_head;

  struct MHD_UpgradeResponseHandle *urh_tail;
#endif /* UPGRADE_SUPPORT */

  gnutls_priority_t priority_cache;

  gnutls_credentials_type_t cred_type;

  gnutls_certificate_credentials_t x509_cred;

  gnutls_dh_params_t dh_params;

  gnutls_psk_server_credentials_t psk_cred;
 
#if GNUTLS_VERSION_MAJOR >= 3
  gnutls_certificate_retrieve_function2 *cert_callback;

  MHD_PskServerCredentialsCallback cred_callback;

  void *cred_callback_cls;
#endif
 
#if GNUTLS_VERSION_NUMBER >= 0x030603
  gnutls_certificate_retrieve_function3 *cert_callback2;
#endif

  const char *https_mem_key;

  const char *https_mem_cert;

  const char *https_key_password;

  const char *https_mem_trust;

  gnutls_dh_params_t https_mem_dhparams;

  bool have_dhparams;

  bool disable_alpn;
 
  #endif /* HTTPS_SUPPORT */
 
#ifdef DAUTH_SUPPORT

  const char *digest_auth_random;

  size_t digest_auth_rand_size;

  void *digest_auth_random_copy;

  struct MHD_NonceNc *nnc;
 
#if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
  MHD_mutex_ nnc_lock;
#endif

  unsigned int nonce_nc_size;

  unsigned int dauth_bind_type;

  unsigned int dauth_def_nonce_timeout;

  uint32_t dauth_def_max_nc;
#endif
 
#ifdef TCP_FASTOPEN
  unsigned int fastopen_queue_size;
#endif

  unsigned int listen_backlog_size;
 
  /* TODO: replace with a single member */
  union MHD_DaemonInfo daemon_info_dummy_listen_fd;
 
#ifdef EPOLL_SUPPORT
  union MHD_DaemonInfo daemon_info_dummy_epoll_fd;
#endif /* EPOLL_SUPPORT */

  union MHD_DaemonInfo daemon_info_dummy_num_connections;

  union MHD_DaemonInfo daemon_info_dummy_flags;

  union MHD_DaemonInfo daemon_info_dummy_port;
 
#if defined(_DEBUG) && defined(HAVE_ACCEPT4)
  bool avoid_accept4;
#endif /* _DEBUG */
};
 
 
#if defined(HAVE_POLL) && defined(EPOLL_SUPPORT)
#define MHD_D_IS_USING_SELECT_(d) \
  (0 == (d->options & (MHD_USE_POLL | MHD_USE_EPOLL)))
#define MHD_D_IS_USING_POLL_(d) (0 != ((d)->options & MHD_USE_POLL))
#define MHD_D_IS_USING_EPOLL_(d) (0 != ((d)->options & MHD_USE_EPOLL))
#elif defined(HAVE_POLL)
#define MHD_D_IS_USING_SELECT_(d) (0 == ((d)->options & MHD_USE_POLL))
#define MHD_D_IS_USING_POLL_(d) (0 != ((d)->options & MHD_USE_POLL))
#define MHD_D_IS_USING_EPOLL_(d) ((void) (d), 0)
#elif defined(EPOLL_SUPPORT)
#define MHD_D_IS_USING_SELECT_(d) (0 == ((d)->options & MHD_USE_EPOLL))
#define MHD_D_IS_USING_POLL_(d) ((void) (d), 0)
#define MHD_D_IS_USING_EPOLL_(d) (0 != ((d)->options & MHD_USE_EPOLL))
#else  /* select() only */
#define MHD_D_IS_USING_SELECT_(d) ((void) (d), ! 0)
#define MHD_D_IS_USING_POLL_(d) ((void) (d), 0)
#define MHD_D_IS_USING_EPOLL_(d) ((void) (d), 0)
#endif /* select() only */
 
#if defined(MHD_USE_THREADS)
#define MHD_D_IS_USING_THREADS_(d) \
  (0 != (d->options & (MHD_USE_INTERNAL_POLLING_THREAD)))
#define MHD_D_IS_USING_THREAD_PER_CONN_(d) \
  (0 != ((d)->options & MHD_USE_THREAD_PER_CONNECTION))

#define MHD_D_IS_THREAD_SAFE_(d) \
  (0 == ((d)->options & MHD_USE_NO_THREAD_SAFETY))
#else  /* ! MHD_USE_THREADS */
#define MHD_D_IS_USING_THREADS_(d) ((void) d, 0)
#define MHD_D_IS_USING_THREAD_PER_CONN_(d) ((void) d, 0)

#define MHD_D_IS_THREAD_SAFE_(d) ((void) d, 0)
#endif /* ! MHD_USE_THREADS */
 
#ifdef HAS_FD_SETSIZE_OVERRIDABLE
#define MHD_D_GET_FD_SETSIZE_(d) ((d)->fdset_size)
#else  /* ! HAS_FD_SETSIZE_OVERRIDABLE */
#define MHD_D_GET_FD_SETSIZE_(d) (FD_SETSIZE)
#endif /* ! HAS_FD_SETSIZE_OVERRIDABLE */

#define MHD_D_DOES_SCKT_FIT_FDSET_(sckt,d) \
  MHD_SCKT_FD_FITS_FDSET_SETSIZE_(sckt,NULL,MHD_D_GET_FD_SETSIZE_(d))
 
 
#ifdef DAUTH_SUPPORT

struct MHD_RqDAuthParam
{
  struct _MHD_str_w_len value;
  bool quoted;
};

struct MHD_RqDAuth
{
  struct MHD_RqDAuthParam nonce;
  struct MHD_RqDAuthParam opaque;
  struct MHD_RqDAuthParam response;
  struct MHD_RqDAuthParam username;
  struct MHD_RqDAuthParam username_ext;
  struct MHD_RqDAuthParam realm;
  struct MHD_RqDAuthParam uri;
  /* The raw QOP value, used in the 'response' calculation */
  struct MHD_RqDAuthParam qop_raw;
  struct MHD_RqDAuthParam cnonce;
  struct MHD_RqDAuthParam nc;
 
  /* Decoded values are below */
  bool userhash; /* True if 'userhash' parameter has value 'true'. */
  enum MHD_DigestAuthAlgo3 algo3;
  enum MHD_DigestAuthQOP qop;
};
 
 
#endif /* DAUTH_SUPPORT */

#define DLL_insert(head,tail,element) do { \
    mhd_assert (NULL == (element)->next); \
    mhd_assert (NULL == (element)->prev); \
    (element)->next = (head);       \
    (element)->prev = NULL;         \
    if ((tail) == NULL) {           \
      (tail) = element;             \
    } else {                        \
      (head)->prev = element;       \
    }                               \
    (head) = (element); } while (0)
 

#define DLL_remove(head,tail,element) do { \
    mhd_assert ( (NULL != (element)->next) || ((element) == (tail)));  \
    mhd_assert ( (NULL != (element)->prev) || ((element) == (head)));  \
    if ((element)->prev == NULL) {                                     \
      (head) = (element)->next;                \
    } else {                                   \
      (element)->prev->next = (element)->next; \
    }                                          \
    if ((element)->next == NULL) {             \
      (tail) = (element)->prev;                \
    } else {                                   \
      (element)->next->prev = (element)->prev; \
    }                                          \
    (element)->next = NULL;                    \
    (element)->prev = NULL; } while (0)
 

#define XDLL_insert(head,tail,element) do { \
    mhd_assert (NULL == (element)->nextX); \
    mhd_assert (NULL == (element)->prevX); \
    (element)->nextX = (head);     \
    (element)->prevX = NULL;       \
    if (NULL == (tail)) {          \
      (tail) = element;            \
    } else {                       \
      (head)->prevX = element;     \
    }                              \
    (head) = (element); } while (0)
 

#define XDLL_remove(head,tail,element) do { \
    mhd_assert ( (NULL != (element)->nextX) || ((element) == (tail)));  \
    mhd_assert ( (NULL != (element)->prevX) || ((element) == (head)));  \
    if (NULL == (element)->prevX) {                                     \
      (head) = (element)->nextX;                  \
    } else {                                      \
      (element)->prevX->nextX = (element)->nextX; \
    }                                             \
    if (NULL == (element)->nextX) {               \
      (tail) = (element)->prevX;                  \
    } else {                                      \
      (element)->nextX->prevX = (element)->prevX; \
    }                                             \
    (element)->nextX = NULL;                      \
    (element)->prevX = NULL; } while (0)
 

#define EDLL_insert(head,tail,element) do { \
    (element)->nextE = (head); \
    (element)->prevE = NULL;   \
    if ((tail) == NULL) {      \
      (tail) = element;        \
    } else {                   \
      (head)->prevE = element; \
    }                          \
    (head) = (element); } while (0)
 

#define EDLL_remove(head,tail,element) do {       \
    if ((element)->prevE == NULL) {               \
      (head) = (element)->nextE;                  \
    } else {                                      \
      (element)->prevE->nextE = (element)->nextE; \
    }                                             \
    if ((element)->nextE == NULL) {               \
      (tail) = (element)->prevE;                  \
    } else {                                      \
      (element)->nextE->prevE = (element)->prevE; \
    }                                             \
    (element)->nextE = NULL;                      \
    (element)->prevE = NULL; } while (0)
 

void
MHD_unescape_plus (char *arg);
 

typedef enum MHD_Result
(*MHD_ArgumentIterator_)(void *cls,
                         const char *key,
                         size_t key_size,
                         const char *value,
                         size_t value_size,
                         enum MHD_ValueKind kind);
 

enum MHD_Result
MHD_parse_arguments_ (struct MHD_Connection *connection,
                      enum MHD_ValueKind kind,
                      char *args,
                      MHD_ArgumentIterator_ cb,
                      void *cls);
 

bool
MHD_check_response_header_token_ci (const struct MHD_Response *response,
                                    const char *key,
                                    size_t key_len,
                                    const char *token,
                                    size_t token_len);

#define MHD_check_response_header_s_token_ci(r,k,tkn) \
  MHD_check_response_header_token_ci ((r),(k),MHD_STATICSTR_LEN_ (k), \
                                      (tkn),MHD_STATICSTR_LEN_ (tkn))
 

void
internal_suspend_connection_ (struct MHD_Connection *connection);
 

_MHD_static_inline struct MHD_Daemon *
MHD_get_master (struct MHD_Daemon *const daemon)
{
  struct MHD_Daemon *ret;
 
  if (NULL != daemon->master)
    ret = daemon->master;
  else
    ret = daemon;
  mhd_assert (NULL == ret->master);
 
  return ret;
}
 
 
#ifdef UPGRADE_SUPPORT
void
MHD_upgraded_connection_mark_app_closed_ (struct MHD_Connection *connection);
 
#endif /* UPGRADE_SUPPORT */
 
 
#endif