internal.h

Go to the documentation of this file.

/*
 This file is part of libmicrohttpd
 (C) 2007 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.h"
#endif

#define EXTRA_CHECKS MHD_YES

#define MHD_MAX(a,b) ((a)<(b)) ? (b) : (a)
#define MHD_MIN(a,b) ((a)<(b)) ? (a) : (b)

#define MHD_BUF_INC_SIZE 2048

#if HAVE_MESSAGES

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

#endif
void MHD_tls_log_func (int level, const char *str);

void MHD_http_unescape (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;

  unsigned int reference_count;

  size_t total_size;

  size_t data_size;

  size_t data_buffer_size;

  size_t data_start;

};

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,

  /*
   *  SSL/TLS connection states
   */

  /*
   * The initial connection state for all secure connectoins
   * Handshake messages will be processed in this state & while
   * in the 'MHD_TLS_HELLO_REQUEST' state
   */
  MHD_TLS_CONNECTION_INIT = MHD_CONNECTION_CLOSED + 1,

  /*
   * This state indicates the server has send a 'Hello Request' to
   * the client & a renegotiation of the handshake is in progress.
   *
   * Handshake messages will processed in this state & while
   * in the 'MHD_TLS_CONNECTION_INIT' state
   */
  MHD_TLS_HELLO_REQUEST,

  MHD_TLS_HANDSHAKE_FAILED,

  MHD_TLS_HANDSHAKE_COMPLETE,

};

#define DEBUG_STATES MHD_NO

#if HAVE_MESSAGES
char *MHD_state_to_string (enum MHD_CONNECTION_STATE state);
#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_Daemon *daemon;

  struct MHD_HTTP_Header *headers_received;

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

  size_t remaining_upload_size;

  size_t response_write_position;

  size_t continue_message_write_offset;

  socklen_t addr_len;

  time_t last_activity;

  int socket_fd;

  int read_closed;

  enum MHD_CONNECTION_STATE state;

  unsigned int responseCode;

  int response_unready;

  int have_chunked_response;

  int have_chunked_upload;

  unsigned int current_chunk_size;

  unsigned int current_chunk_offset;

  /* handlers used for processing read, write & idle connection operations */
  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
  /* TODO rename as this might be an SSL connection */
  MHD_gtls_session_t tls_session;
#endif
};

struct MHD_Daemon
{

  MHD_AccessHandlerCallback default_handler;

  void *default_handler_cls;

  struct MHD_Connection *connections;

  MHD_AcceptPolicyCallback apc;

  void *apc_cls;

  MHD_RequestCompletedCallback notify_completed;

  void *notify_completed_cls;

  void * (*uri_log_callback)(void * cls, const char * uri);

  void * uri_log_callback_cls;

  pthread_t pid;

  int socket_fd;

  int shutdown;

  unsigned int pool_size;

  unsigned int max_connections;

  unsigned int connection_timeout;

  unsigned int per_ip_connection_limit;

  enum MHD_OPTION options;

  unsigned short port;

#if HTTPS_SUPPORT
  enum MHD_GNUTLS_CredentialsType cred_type;

  /* server x509 credintials */
  MHD_gtls_cert_credentials_t x509_cred;

  /* cipher priority cache */
  MHD_gnutls_priority_t priority_cache;

  /* Diffie-Hellman parameters */
  MHD_gtls_dh_params_t dh_params;

  const char *https_mem_key;

  const char *https_mem_cert;
#endif
};


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



#endif

---