internal.h

Go to the documentation of this file.

/*
  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
*/
 
#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 MHD_PANIC
/* Override any defined MHD_PANIC macro with proper one */
#undef MHD_PANIC
#endif /* MHD_PANIC */
 
#ifdef HAVE_MESSAGES
#define MHD_PANIC(msg) do { mhd_panic (mhd_panic_cls, __FILE__, __LINE__, msg); \
                            BUILTIN_NOT_REACHED; } while (0)
#else
#define MHD_PANIC(msg) do { mhd_panic (mhd_panic_cls, __FILE__, __LINE__, NULL); \
                            BUILTIN_NOT_REACHED; } while (0)
#endif
 
#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"
 
 
#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 1024
 
 
extern MHD_PanicCallback mhd_panic;
 
extern void *mhd_panic_cls;
 
/* If we have Clang or gcc >= 4.5, use __buildin_unreachable() */
#if defined(__clang__) || (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= \
                                             5)
#define BUILTIN_NOT_REACHED __builtin_unreachable ()
#elif defined(_MSC_FULL_VER)
#define BUILTIN_NOT_REACHED __assume (0)
#else
#define BUILTIN_NOT_REACHED
#endif
 
#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   
};
 
 
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
};
 
 
enum MHD_ConnectionEventLoopInfo
{
  MHD_EVENT_LOOP_INFO_READ = 0,
 
  MHD_EVENT_LOOP_INFO_WRITE = 1,
 
  MHD_EVENT_LOOP_INFO_BLOCK = 2,
 
  MHD_EVENT_LOOP_INFO_CLEANUP = 3
};
 
 
#define MHD_TEST_ALLOW_SUSPEND_RESUME 8192
 
#define MAX_NONCE_LENGTH 129
 
 
struct MHD_NonceNc
{
 
  uint64_t nc;
 
  uint64_t nmask;
 
  char nonce[MAX_NONCE_LENGTH];
 
};
 
#ifdef HAVE_MESSAGES
void
MHD_DLOG (const struct MHD_Daemon *daemon,
          const char *format,
          ...);
 
#endif
 
 
struct MHD_HTTP_Header
{
  struct MHD_HTTP_Header *next;
 
  char *header;
 
  size_t header_size;
 
  char *value;
 
  size_t value_size;
 
  enum MHD_ValueKind kind;
 
};
 
 
#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_Header *first_header;
 
  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;
 
  bool is_pipe;
 
  MHD_iovec_ *data_iov;
 
  unsigned int data_iovcnt;
};
 
 
enum MHD_CONNECTION_STATE
{
  MHD_CONNECTION_INIT = 0,
 
  MHD_CONNECTION_URL_RECEIVED = MHD_CONNECTION_INIT + 1,
 
  MHD_CONNECTION_HEADER_PART_RECEIVED = MHD_CONNECTION_URL_RECEIVED + 1,
 
  MHD_CONNECTION_HEADERS_RECEIVED = MHD_CONNECTION_HEADER_PART_RECEIVED + 1,
 
  MHD_CONNECTION_HEADERS_PROCESSED = MHD_CONNECTION_HEADERS_RECEIVED + 1,
 
  MHD_CONNECTION_CONTINUE_SENDING = MHD_CONNECTION_HEADERS_PROCESSED + 1,
 
  MHD_CONNECTION_CONTINUE_SENT = MHD_CONNECTION_CONTINUE_SENDING + 1,
 
  MHD_CONNECTION_BODY_RECEIVED = MHD_CONNECTION_CONTINUE_SENT + 1,
 
  MHD_CONNECTION_FOOTER_PART_RECEIVED = MHD_CONNECTION_BODY_RECEIVED + 1,
 
  MHD_CONNECTION_FOOTERS_RECEIVED = MHD_CONNECTION_FOOTER_PART_RECEIVED + 1,
 
  MHD_CONNECTION_HEADERS_SENDING = MHD_CONNECTION_FOOTERS_RECEIVED + 1,
 
  MHD_CONNECTION_HEADERS_SENT = MHD_CONNECTION_HEADERS_SENDING + 1,
 
  MHD_CONNECTION_NORMAL_BODY_READY = MHD_CONNECTION_HEADERS_SENT + 1,
 
  MHD_CONNECTION_NORMAL_BODY_UNREADY = MHD_CONNECTION_NORMAL_BODY_READY + 1,
 
  MHD_CONNECTION_CHUNKED_BODY_READY = MHD_CONNECTION_NORMAL_BODY_UNREADY + 1,
 
  MHD_CONNECTION_CHUNKED_BODY_UNREADY = MHD_CONNECTION_CHUNKED_BODY_READY + 1,
 
  MHD_CONNECTION_BODY_SENT = MHD_CONNECTION_CHUNKED_BODY_UNREADY + 1,
 
  MHD_CONNECTION_FOOTERS_SENDING = MHD_CONNECTION_BODY_SENT + 1,
 
  MHD_CONNECTION_FOOTERS_SENT = MHD_CONNECTION_FOOTERS_SENDING + 1,
 
  MHD_CONNECTION_CLOSED = MHD_CONNECTION_FOOTERS_SENT + 1,
 
#ifdef UPGRADE_SUPPORT
  MHD_CONNECTION_UPGRADE
#endif /* UPGRADE_SUPPORT */
 
};
 
 
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
};
 
#define DEBUG_STATES MHD_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
};
 
 
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_HTTP_Header *headers_received;
 
  struct MHD_HTTP_Header *headers_received_tail;
 
  struct MHD_Response *response;
 
  struct MemoryPool *pool;
 
  void *client_context;
 
  void *socket_context;
 
  char *method;
 
  const char *url;
 
  char *version;
 
  enum MHD_ConnKeepAlive keepalive;
 
  char *read_buffer;
 
  char *write_buffer;
 
  char *last;
 
  char *colon;
 
  struct sockaddr *addr;
 
#if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
  MHD_thread_handle_ID_ pid;
#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 header_size;
 
  uint64_t remaining_upload_size;
 
  uint64_t response_write_position;
 
  struct MHD_iovec_track_ resp_iov;
 
 
#if defined(_MHD_HAVE_SENDFILE)
  enum MHD_resp_sender_
  {
    MHD_resp_sender_std = 0,
    MHD_resp_sender_sendfile
  } resp_sender;
#endif /* _MHD_HAVE_SENDFILE */
 
  size_t continue_message_write_offset;
 
  socklen_t addr_len;
 
  time_t last_activity;
 
  time_t connection_timeout;
 
  unsigned int connection_timeout_dummy;
 
  bool client_aware;
 
  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;
 
#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;
 
  unsigned int responseCode;
 
  bool have_chunked_upload;
 
  uint64_t current_chunk_size;
 
  uint64_t current_chunk_offset;
 
  ReceiveCallback recv_cls;
 
#ifdef UPGRADE_SUPPORT
  struct MHD_UpgradeResponseHandle *urh;
#endif /* UPGRADE_SUPPORT */
 
#ifdef HTTPS_SUPPORT
 
  gnutls_session_t tls_session;
 
  int protocol;
 
  int cipher;
 
  enum MHD_TLS_CONN_STATE tls_state;
 
  bool tls_read_ready;
#endif /* HTTPS_SUPPORT */
 
  bool suspended;
 
  int suspended_dummy;
 
  volatile bool resuming;
};
 
 
#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;
 
#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_ pid;
 
  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;
 
  time_t connection_timeout;
 
  unsigned int per_ip_connection_limit;
 
  int strict_for_client;
 
  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;
 
  struct MHD_NonceNc *nnc;
 
#if defined(MHD_USE_POSIX_THREADS) || defined(MHD_USE_W32_THREADS)
  MHD_mutex_ nnc_lock;
#endif
 
  size_t digest_auth_rand_size;
 
  unsigned int nonce_nc_size;
 
#endif
 
#ifdef TCP_FASTOPEN
  unsigned int fastopen_queue_size;
#endif
 
  unsigned int listen_backlog_size;
 
  size_t num_opts;
};
 
 
#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_)(struct MHD_Connection *connection,
                         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,
                      unsigned int *num_headers);
 
 
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);
 
#endif