internal.h

Go to the documentation of this file.

/*
  This file is part of libmicrohttpd
  (C) 2007-2013 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 "platform.h"
#include "microhttpd.h"
#if HTTPS_SUPPORT
#include <gnutls/gnutls.h>
#if GNUTLS_VERSION_MAJOR >= 3
#include <gnutls/abstract.h>
#endif
#endif
#if EPOLL_SUPPORT
#include <sys/epoll.h>
#endif


#define EXTRA_CHECKS MHD_NO

#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 HAVE_MESSAGES

#define MHD_PANIC(msg) mhd_panic (mhd_panic_cls, __FILE__, __LINE__, msg)
#else

#define MHD_PANIC(msg) mhd_panic (mhd_panic_cls, __FILE__, __LINE__, NULL)
#endif


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
  };


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 MAX_NONCE_LENGTH 129


struct MHD_NonceNc
{

  unsigned long int nc;

  char nonce[MAX_NONCE_LENGTH];

};

#if HAVE_MESSAGES

void
MHD_DLOG (const struct MHD_Daemon *daemon,
          const char *format, ...);
#endif

size_t
MHD_http_unescape (void *cls,
                   struct MHD_Connection *connection,
                   char *val);


struct MHD_HTTP_Header
{
  struct MHD_HTTP_Header *next;

  char *header;

  char *value;

  enum MHD_ValueKind kind;

};


struct MHD_Response
{

  struct MHD_HTTP_Header *first_header;

  char *data;

  void *crc_cls;

  MHD_ContentReaderCallback crc;

  MHD_ContentReaderFreeCallback crfc;

  pthread_mutex_t mutex;

  uint64_t total_size;

  uint64_t data_start;

  off_t fd_off;

  size_t data_size;

  size_t data_buffer_size;

  unsigned int reference_count;

  int fd;

};


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,

  MHD_CONNECTION_IN_CLEANUP = MHD_CONNECTION_CLOSED + 1,

  /*
   *  SSL/TLS connection states
   */

  MHD_TLS_CONNECTION_INIT = MHD_CONNECTION_IN_CLEANUP + 1

};

#define DEBUG_STATES MHD_NO


#if 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 *write_to, size_t max_bytes);


struct MHD_Connection
{

#if 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;

  char *method;

  char *url;

  char *version;

  char *read_buffer;

  char *write_buffer;

  char *last;

  char *colon;

  struct sockaddr *addr;

  pthread_t pid;

  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;

  uint64_t remaining_upload_size;

  uint64_t response_write_position;

  size_t continue_message_write_offset;

  socklen_t addr_len;

  time_t last_activity;

  unsigned int connection_timeout;

  int client_aware;

  int socket_fd;

  int read_closed;

  int thread_joined;

  int in_idle;

#if EPOLL_SUPPORT

  enum MHD_EpollState epoll_state;
#endif

  enum MHD_CONNECTION_STATE state;

  enum MHD_ConnectionEventLoopInfo event_loop_info;

  unsigned int responseCode;

  int response_unready;

  int have_chunked_upload;

  unsigned int current_chunk_size;

  unsigned int current_chunk_offset;

  int (*read_handler) (struct MHD_Connection * connection);

  int (*write_handler) (struct MHD_Connection * connection);

  int (*idle_handler) (struct MHD_Connection * connection);

  ReceiveCallback recv_cls;

  TransmitCallback send_cls;

#if HTTPS_SUPPORT

  gnutls_session_t tls_session;

  int protocol;

  int cipher;

  int tls_read_ready;
#endif

  int suspended;

  int resuming;
};

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;

  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;

#if EPOLL_SUPPORT

  struct MHD_Connection *eready_head;

  struct MHD_Connection *eready_tail;
#endif

  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;

  LogCallback uri_log_callback;

  void *uri_log_callback_cls;

  UnescapeCallback unescape_callback;

  void *unescape_callback_cls;

#if HAVE_MESSAGES

  void (*custom_error_log) (void *cls, const char *fmt, va_list va);

  void *custom_error_log_cls;
#endif

  struct MHD_Daemon *master;

  struct MHD_Daemon *worker_pool;

  void *per_ip_connection_count;

  size_t pool_size;

  size_t pool_increment;

  size_t thread_stack_size;

  unsigned int worker_pool_size;

  pthread_t pid;

  pthread_mutex_t per_ip_connection_mutex;

  pthread_mutex_t cleanup_connection_mutex;

  int socket_fd;

#if EPOLL_SUPPORT

  int epoll_fd;

  int listen_socket_in_epoll;
#endif

  int wpipe[2];

  int shutdown;

  /*
   * Do we need to process resuming connections?
   */
  int resuming;

  unsigned int max_connections;

  unsigned int connection_timeout;

  unsigned int per_ip_connection_limit;

  enum MHD_OPTION options;

  uint16_t port;

#if HTTPS_SUPPORT

  gnutls_priority_t priority_cache;

  gnutls_credentials_type_t cred_type;

  gnutls_certificate_credentials_t x509_cred;

  gnutls_dh_params_t dh_params;

#if GNUTLS_VERSION_MAJOR >= 3

  gnutls_certificate_retrieve_function2 *cert_callback;
#endif

  const char *https_mem_key;

  const char *https_mem_cert;

  const char *https_mem_trust;

  unsigned int num_tls_read_ready;

#endif

#ifdef DAUTH_SUPPORT

  const char *digest_auth_random;

  struct MHD_NonceNc *nnc;

  pthread_mutex_t nnc_lock;

  unsigned int digest_auth_rand_size;

  unsigned int nonce_nc_size;

#endif

};


#if EXTRA_CHECKS
#define EXTRA_CHECK(a) if (!(a)) abort();
#else
#define EXTRA_CHECK(a)
#endif


#define DLL_insert(head,tail,element) do { \
  (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 { \
  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 { \
  (element)->nextX = (head); \
  (element)->prevX = NULL; \
  if ((tail) == NULL) \
    (tail) = element; \
  else \
    (head)->prevX = element; \
  (head) = (element); } while (0)


#define XDLL_remove(head,tail,element) do { \
  if ((element)->prevX == NULL) \
    (head) = (element)->nextX;  \
  else \
    (element)->prevX->nextX = (element)->nextX; \
  if ((element)->nextX == NULL) \
    (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)


time_t MHD_monotonic_time(void);

#endif