internal.h

Go to the documentation of this file.

/*
  This file is part of libmicrohttpd
  (C) 2007, 2008, 2009, 2010, 2011, 2012 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>
#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 2048

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_PollActions
  {
    MHD_POLL_ACTION_NOTHING = 0,

    MHD_POLL_ACTION_IN = 1,

    MHD_POLL_ACTION_OUT = 2
  };


struct MHD_Pollfd 
{
  int fd;

  enum MHD_PollActions events;
};


#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_CLOSED + 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
{

  struct MHD_Connection *next;

  struct MHD_Connection *prev;

  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;

  enum MHD_CONNECTION_STATE state;

  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;

#endif
};

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

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 *cleanup_head;

  struct MHD_Connection *cleanup_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 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;

  int wpipe[2];

  int shutdown;

  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;

  const char *https_mem_key;

  const char *https_mem_cert;

  const char *https_mem_trust;

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


time_t MHD_monotonic_time(void);

#endif