/*

  This file is part of libmicrohttpd

  Copyright (C) 2007-2017 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

*/

/**

 * @file microhttpd/internal.h

 * @brief  internal shared structures

 * @author Daniel Pittman

 * @author Christian Grothoff

 */

#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

/**

 * Trigger 'panic' action based on fatal errors.

 *

 * @param msg error message (const char *)

 */

#define MHD_PANIC(msg) do { mhd_panic (mhd_panic_cls, __FILE__, __LINE__, msg); BUILTIN_NOT_REACHED; } while (0)

#else

/**

 * Trigger 'panic' action based on fatal errors.

 *

 * @param msg error message (const char *)

 */

#define MHD_PANIC(msg) do { mhd_panic (mhd_panic_cls, __FILE__, __LINE__, NULL); BUILTIN_NOT_REACHED; } while (0)

#endif

#include "mhd_threads.h"

#include "mhd_locks.h"

#include "mhd_sockets.h"

#include "mhd_itc_types.h"

/**

 * Close FD and abort execution if error is detected.

 * @param fd the FD to close

 */

#define MHD_fd_close_chk_(fd) do {             \

    if (0 == close ((fd)) && (EBADF == errno)) \

      MHD_PANIC(_("Failed to close FD.\n"));   \

  } while(0)

/**

 * Should we perform additional sanity checks at runtime (on our internal

 * invariants)?  This may lead to aborts, but can be useful for debugging.

 */

#define EXTRA_CHECKS MHD_NO

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

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

/**

 * Minimum size by which MHD tries to increment read/write buffers.

 * We usually begin with half the available pool space for the

 * IO-buffer, but if absolutely needed we additively grow by the

 * number of bytes given here (up to -- theoretically -- the full pool

 * space).

 */

#define MHD_BUF_INC_SIZE 1024

/**

 * Handler for fatal errors.

 */

extern MHD_PanicCallback mhd_panic;

/**

 * Closure argument for "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_

/**

 * Determine length of static string / macro strings at compile time.

 */

#define MHD_STATICSTR_LEN_(macro) (sizeof(macro)/sizeof(char) - 1)

#endif /* ! MHD_STATICSTR_LEN_ */

/**

 * State of the socket with respect to epoll (bitmask).

 */

enum MHD_EpollState

{

  /**

   * The socket is not involved with a defined state in epoll() right

   * now.

   */

  MHD_EPOLL_STATE_UNREADY = 0,

  /**

   * epoll() told us that data was ready for reading, and we did

   * not consume all of it yet.

   */

  MHD_EPOLL_STATE_READ_READY = 1,

  /**

   * epoll() told us that space was available for writing, and we did

   * not consume all of it yet.

   */

  MHD_EPOLL_STATE_WRITE_READY = 2,

  /**

   * Is this connection currently in the 'eready' EDLL?

   */

  MHD_EPOLL_STATE_IN_EREADY_EDLL = 4,

  /**

   * Is this connection currently in the epoll() set?

   */

  MHD_EPOLL_STATE_IN_EPOLL_SET = 8,

  /**

   * Is this connection currently suspended?

   */

  MHD_EPOLL_STATE_SUSPENDED = 16,

  /**

   * Is this connection in some error state?

   */

  MHD_EPOLL_STATE_ERROR = 128

};

/**

 * What is this connection waiting for?

 */

enum MHD_ConnectionEventLoopInfo

{

  /**

   * We are waiting to be able to read.

   */

  MHD_EVENT_LOOP_INFO_READ = 0,

  /**

   * We are waiting to be able to write.

   */

  MHD_EVENT_LOOP_INFO_WRITE = 1,

  /**

   * We are waiting for the application to provide data.

   */

  MHD_EVENT_LOOP_INFO_BLOCK = 2,

  /**

   * We are finished and are awaiting cleanup.

   */

  MHD_EVENT_LOOP_INFO_CLEANUP = 3

};

/**

 * Additional test value for enum MHD_FLAG to check only for MHD_ALLOW_SUSPEND_RESUME and

 * NOT for MHD_USE_ITC.

 */

#define MHD_TEST_ALLOW_SUSPEND_RESUME 8192

/**

 * Maximum length of a nonce in digest authentication.  32(MD5 Hex) +

 * 8(Timestamp Hex) + 1(NULL); hence 41 should suffice, but Opera

 * (already) takes more (see Mantis #1633), so we've increased the

 * value to support something longer...

 */

#define MAX_NONCE_LENGTH 129

/**

 * A structure representing the internal holder of the

 * nonce-nc map.

 */

struct MHD_NonceNc

{

  /**

   * Nonce counter, a value that increases for each subsequent

   * request for the same nonce.

   */

  uint64_t nc;

  /**

   * Bitmask over the nc-64 previous nonce values.  Used to

   * allow out-of-order nonces.

   */

  uint64_t nmask;

  /**

   * Nonce value:

   */

  char nonce[MAX_NONCE_LENGTH];

};

#ifdef HAVE_MESSAGES

/**

 * fprintf()-like helper function for logging debug

 * messages.

 */

void

MHD_DLOG (const struct MHD_Daemon *daemon,

	  const char *format,

          ...);

#endif

/**

 * Header or cookie in HTTP request or response.

 */

struct MHD_HTTP_Header

{

  /**

   * Headers are kept in a linked list.

   */

  struct MHD_HTTP_Header *next;

  /**

   * The name of the header (key), without the colon.

   */

  char *header;

  /**

   * The value of the header.

   */

  char *value;

  /**

   * Type of the header (where in the HTTP protocol is this header

   * from).

   */

  enum MHD_ValueKind kind;

};

/**

 * Representation of a response.

 */

struct MHD_Response

{

  /**

   * Headers to send for the response.  Initially

   * the linked list is created in inverse order;

   * the order should be inverted before sending!

   */

  struct MHD_HTTP_Header *first_header;

  /**

   * Buffer pointing to data that we are supposed

   * to send as a response.

   */

  char *data;

  /**

   * Closure to give to the content reader @e crc

   * and content reader free callback @e crfc.

   */

  void *crc_cls;

  /**

   * How do we get more data?  NULL if we are

   * given all of the data up front.

   */

  MHD_ContentReaderCallback crc;

  /**

   * NULL if data must not be freed, otherwise

   * either user-specified callback or "&free".

   */

  MHD_ContentReaderFreeCallback crfc;

#ifdef UPGRADE_SUPPORT

  /**

   * Application function to call once we are done sending the headers

   * of the response; NULL unless this is a response created with

   * #MHD_create_response_for_upgrade().

   */

  MHD_UpgradeHandler upgrade_handler;

  /**

   * Closure for @e uh.

   */

  void *upgrade_handler_cls;

#endif /* UPGRADE_SUPPORT */

  /**

   * Mutex to synchronize access to @e data, @e size and

   * @e reference_count.

   */

  MHD_mutex_ mutex;

  /**

   * Set to #MHD_SIZE_UNKNOWN if size is not known.

   */

  uint64_t total_size;

  /**

   * At what offset in the stream is the

   * beginning of @e data located?

   */

  uint64_t data_start;

  /**

   * Offset to start reading from when using @e fd.

   */

  uint64_t fd_off;

  /**

   * Number of bytes ready in @e data (buffer may be larger

   * than what is filled with payload).

   */

  size_t data_size;

  /**

   * Size of the data buffer @e data.

   */

  size_t data_buffer_size;

  /**

   * Reference count for this response.  Free once the counter hits

   * zero.

   */

  unsigned int reference_count;

  /**

   * File-descriptor if this response is FD-backed.

   */

  int fd;

  /**

   * Flags set for the MHD response.

   */

  enum MHD_ResponseFlags flags;

};

/**

 * States in a state machine for a connection.

 *

 * The main transitions are any-state to #MHD_CONNECTION_CLOSED, any

 * state to state+1, #MHD_CONNECTION_FOOTERS_SENT to

 * #MHD_CONNECTION_INIT.  #MHD_CONNECTION_CLOSED is the terminal state

 * and #MHD_CONNECTION_INIT the initial state.

 *

 * Note that transitions for *reading* happen only after the input has

 * been processed; transitions for *writing* happen after the

 * respective data has been put into the write buffer (the write does

 * not have to be completed yet).  A transition to

 * #MHD_CONNECTION_CLOSED or #MHD_CONNECTION_INIT requires the write

 * to be complete.

 */

enum MHD_CONNECTION_STATE

{

  /**

   * Connection just started (no headers received).

   * Waiting for the line with the request type, URL and version.

   */

  MHD_CONNECTION_INIT = 0,

  /**

   * 1: We got the URL (and request type and version).  Wait for a header line.

   */

  MHD_CONNECTION_URL_RECEIVED = MHD_CONNECTION_INIT + 1,

  /**

   * 2: We got part of a multi-line request header.  Wait for the rest.

   */

  MHD_CONNECTION_HEADER_PART_RECEIVED = MHD_CONNECTION_URL_RECEIVED + 1,

  /**

   * 3: We got the request headers.  Process them.

   */

  MHD_CONNECTION_HEADERS_RECEIVED = MHD_CONNECTION_HEADER_PART_RECEIVED + 1,

  /**

   * 4: We have processed the request headers.  Send 100 continue.

   */

  MHD_CONNECTION_HEADERS_PROCESSED = MHD_CONNECTION_HEADERS_RECEIVED + 1,

  /**

   * 5: We have processed the headers and need to send 100 CONTINUE.

   */

  MHD_CONNECTION_CONTINUE_SENDING = MHD_CONNECTION_HEADERS_PROCESSED + 1,

  /**

   * 6: We have sent 100 CONTINUE (or do not need to).  Read the message body.

   */

  MHD_CONNECTION_CONTINUE_SENT = MHD_CONNECTION_CONTINUE_SENDING + 1,

  /**

   * 7: We got the request body.  Wait for a line of the footer.

   */

  MHD_CONNECTION_BODY_RECEIVED = MHD_CONNECTION_CONTINUE_SENT + 1,

  /**

   * 8: We got part of a line of the footer.  Wait for the

   * rest.

   */

  MHD_CONNECTION_FOOTER_PART_RECEIVED = MHD_CONNECTION_BODY_RECEIVED + 1,

  /**

   * 9: We received the entire footer.  Wait for a response to be queued

   * and prepare the response headers.

   */

  MHD_CONNECTION_FOOTERS_RECEIVED = MHD_CONNECTION_FOOTER_PART_RECEIVED + 1,

  /**

   * 10: We have prepared the response headers in the writ buffer.

   * Send the response headers.

   */

  MHD_CONNECTION_HEADERS_SENDING = MHD_CONNECTION_FOOTERS_RECEIVED + 1,

  /**

   * 11: We have sent the response headers.  Get ready to send the body.

   */

  MHD_CONNECTION_HEADERS_SENT = MHD_CONNECTION_HEADERS_SENDING + 1,

  /**

   * 12: We are ready to send a part of a non-chunked body.  Send it.

   */

  MHD_CONNECTION_NORMAL_BODY_READY = MHD_CONNECTION_HEADERS_SENT + 1,

  /**

   * 13: We are waiting for the client to provide more

   * data of a non-chunked body.

   */

  MHD_CONNECTION_NORMAL_BODY_UNREADY = MHD_CONNECTION_NORMAL_BODY_READY + 1,

  /**

   * 14: We are ready to send a chunk.

   */

  MHD_CONNECTION_CHUNKED_BODY_READY = MHD_CONNECTION_NORMAL_BODY_UNREADY + 1,

  /**

   * 15: We are waiting for the client to provide a chunk of the body.

   */

  MHD_CONNECTION_CHUNKED_BODY_UNREADY = MHD_CONNECTION_CHUNKED_BODY_READY + 1,

  /**

   * 16: We have sent the response body. Prepare the footers.

   */

  MHD_CONNECTION_BODY_SENT = MHD_CONNECTION_CHUNKED_BODY_UNREADY + 1,

  /**

   * 17: We have prepared the response footer.  Send it.

   */

  MHD_CONNECTION_FOOTERS_SENDING = MHD_CONNECTION_BODY_SENT + 1,

  /**

   * 18: We have sent the response footer.  Shutdown or restart.

   */

  MHD_CONNECTION_FOOTERS_SENT = MHD_CONNECTION_FOOTERS_SENDING + 1,

  /**

   * 19: This connection is to be closed.

   */

  MHD_CONNECTION_CLOSED = MHD_CONNECTION_FOOTERS_SENT + 1,

  /**

   * 20: This connection is finished (only to be freed)

   */

  MHD_CONNECTION_IN_CLEANUP = MHD_CONNECTION_CLOSED + 1,

#ifdef UPGRADE_SUPPORT

  /**

   * Connection was "upgraded" and socket is now under the

   * control of the application.

   */

  MHD_CONNECTION_UPGRADE

#endif /* UPGRADE_SUPPORT */

};

/**

 * States of TLS transport layer.

 */

enum MHD_TLS_CONN_STATE

{

  MHD_TLS_CONN_NO_TLS = 0,  /**< Not a TLS connection (plain socket).   */

  MHD_TLS_CONN_INIT,        /**< TLS connection is not established yet. */

  MHD_TLS_CONN_HANDSHAKING, /**< TLS is in handshake process.           */

  MHD_TLS_CONN_CONNECTED,   /**< TLS is established.                    */

  MHD_TLS_CONN_WR_CLOSING,  /**< Closing WR side of TLS layer.          */

  MHD_TLS_CONN_WR_CLOSED,   /**< WR side of TLS layer is closed.        */

  MHD_TLS_CONN_TLS_CLOSING, /**< TLS session is terminating.            */

  MHD_TLS_CONN_TLS_CLOSED,  /**< TLS session is terminated.             */

  MHD_TLS_CONN_TLS_FAILED,  /**< TLS session failed.                    */

  MHD_TLS_CONN_INVALID_STATE/**< Sentinel. Not a valid value.           */

};

/**

 * Should all state transitions be printed to stderr?

 */

#define DEBUG_STATES MHD_NO

#ifdef HAVE_MESSAGES

#if DEBUG_STATES

const char *

MHD_state_to_string (enum MHD_CONNECTION_STATE state);

#endif

#endif

/**

 * Function to receive plaintext data.

 *

 * @param conn the connection struct

 * @param write_to where to write received data

 * @param max_bytes maximum number of bytes to receive

 * @return number of bytes written to @a write_to

 */

typedef ssize_t

(*ReceiveCallback) (struct MHD_Connection *conn,

                    void *write_to,

                    size_t max_bytes);

/**

 * Function to transmit plaintext data.

 *

 * @param conn the connection struct

 * @param read_from where to read data to transmit

 * @param max_bytes maximum number of bytes to transmit

 * @return number of bytes transmitted

 */

typedef ssize_t

(*TransmitCallback) (struct MHD_Connection *conn,

                     const void *read_from,

                     size_t max_bytes);

/**

 * Ability to use same connection for next request

 */

enum MHD_ConnKeepAlive

{

  /**

   * Connection must be closed after sending response.

   */

  MHD_CONN_MUST_CLOSE = -1,

  /**

   * KeelAlive state is not yet determined

   */

  MHD_CONN_KEEPALIVE_UNKOWN = 0,

  /**

   * Connection can be used for serving next request

   */

  MHD_CONN_USE_KEEPALIVE = 1

};

/**

 * State kept for each HTTP request.

 */

struct MHD_Connection

{

#ifdef EPOLL_SUPPORT

  /**

   * Next pointer for the EDLL listing connections that are epoll-ready.

   */

  struct MHD_Connection *nextE;

  /**

   * Previous pointer for the EDLL listing connections that are epoll-ready.

   */

  struct MHD_Connection *prevE;

#endif

  /**

   * Next pointer for the DLL describing our IO state.

   */

  struct MHD_Connection *next;

  /**

   * Previous pointer for the DLL describing our IO state.

   */

  struct MHD_Connection *prev;

  /**

   * Next pointer for the XDLL organizing connections by timeout.

   * This DLL can be either the

   * 'manual_timeout_head/manual_timeout_tail' or the

   * 'normal_timeout_head/normal_timeout_tail', depending on whether a

   * custom timeout is set for the connection.

   */

  struct MHD_Connection *nextX;

  /**

   * Previous pointer for the XDLL organizing connections by timeout.

   */

  struct MHD_Connection *prevX;

  /**

   * Reference to the MHD_Daemon struct.

   */

  struct MHD_Daemon *daemon;

  /**

   * Linked list of parsed headers.

   */

  struct MHD_HTTP_Header *headers_received;

  /**

   * Tail of linked list of parsed headers.

   */

  struct MHD_HTTP_Header *headers_received_tail;

  /**

   * Response to transmit (initially NULL).

   */

  struct MHD_Response *response;

  /**

   * The memory pool is created whenever we first read from the TCP

   * stream and destroyed at the end of each request (and re-created

   * for the next request).  In the meantime, this pointer is NULL.

   * The pool is used for all connection-related data except for the

   * response (which maybe shared between connections) and the IP

   * address (which persists across individual requests).

   */

  struct MemoryPool *pool;

  /**

   * We allow the main application to associate some pointer with the

   * HTTP request, which is passed to each #MHD_AccessHandlerCallback

   * and some other API calls.  Here is where we store it.  (MHD does

   * not know or care what it is).

   */

  void *client_context;

  /**

   * We allow the main application to associate some pointer with the

   * TCP connection (which may span multiple HTTP requests).  Here is

   * where we store it.  (MHD does not know or care what it is).

   * The location is given to the #MHD_NotifyConnectionCallback and

   * also accessible via #MHD_CONNECTION_INFO_SOCKET_CONTEXT.

   */

  void *socket_context;

  /**

   * Request method.  Should be GET/POST/etc.  Allocated in pool.

   */

  char *method;

  /**

   * Requested URL (everything after "GET" only).  Allocated

   * in pool.

   */

  const char *url;

  /**

   * HTTP version string (i.e. http/1.1).  Allocated

   * in pool.

   */

  char *version;

  /**

   * Close connection after sending response?

   * Functions may change value from "Unknown" or "KeepAlive" to "Must close",

   * but no functions reset value "Must Close" to any other value.

   */

  enum MHD_ConnKeepAlive keepalive;

  /**

   * Buffer for reading requests.  Allocated in pool.  Actually one

   * byte larger than @e read_buffer_size (if non-NULL) to allow for

   * 0-termination.

   */

  char *read_buffer;

  /**

   * Buffer for writing response (headers only).  Allocated

   * in pool.

   */

  char *write_buffer;

  /**

   * Last incomplete header line during parsing of headers.

   * Allocated in pool.  Only valid if state is

   * either #MHD_CONNECTION_HEADER_PART_RECEIVED or

   * #MHD_CONNECTION_FOOTER_PART_RECEIVED.

   */

  char *last;

  /**

   * Position after the colon on the last incomplete header

   * line during parsing of headers.

   * Allocated in pool.  Only valid if state is

   * either #MHD_CONNECTION_HEADER_PART_RECEIVED or

   * #MHD_CONNECTION_FOOTER_PART_RECEIVED.

   */

  char *colon;

  /**

   * Foreign address (of length @e addr_len).  MALLOCED (not

   * in pool!).

   */

  struct sockaddr *addr;

  /**

   * Thread handle for this connection (if we are using

   * one thread per connection).

   */

  MHD_thread_handle_ID_ pid;

  /**

   * Size of @e read_buffer (in bytes).  This value indicates

   * how many bytes we're willing to read into the buffer;

   * the real buffer is one byte longer to allow for

   * adding zero-termination (when needed).

   */

  size_t read_buffer_size;

  /**

   * Position where we currently append data in

   * @e read_buffer (last valid position).

   */

  size_t read_buffer_offset;

  /**

   * Size of @e write_buffer (in bytes).

   */

  size_t write_buffer_size;

  /**

   * Offset where we are with sending from @e write_buffer.

   */

  size_t write_buffer_send_offset;

  /**

   * Last valid location in write_buffer (where do we

   * append and up to where is it safe to send?)

   */

  size_t write_buffer_append_offset;

  /**

   * Number of bytes we had in the HTTP header, set once we

   * pass #MHD_CONNECTION_HEADERS_RECEIVED.

   */

  size_t header_size;

  /**

   * How many more bytes of the body do we expect

   * to read? #MHD_SIZE_UNKNOWN for unknown.

   */

  uint64_t remaining_upload_size;

  /**

   * Current write position in the actual response

   * (excluding headers, content only; should be 0

   * while sending headers).

   */

  uint64_t response_write_position;

#if defined(_MHD_HAVE_SENDFILE)

  enum MHD_resp_sender_

  {

    MHD_resp_sender_std = 0,

    MHD_resp_sender_sendfile

  } resp_sender;

#endif /* _MHD_HAVE_SENDFILE */

  /**

   * Position in the 100 CONTINUE message that

   * we need to send when receiving http 1.1 requests.

   */

  size_t continue_message_write_offset;

  /**

   * Length of the foreign address.

   */

  socklen_t addr_len;

  /**

   * Last time this connection had any activity

   * (reading or writing).

   */

  time_t last_activity;

  /**

   * After how many seconds of inactivity should

   * this connection time out?  Zero for no timeout.

   */

  time_t connection_timeout;

  /**

   * Special member to be returned by #MHD_get_connection_info()

   */

  unsigned int connection_timeout_dummy;

  /**

   * Did we ever call the "default_handler" on this connection?  (this

   * flag will determine if we call the #MHD_OPTION_NOTIFY_COMPLETED

   * handler when the connection closes down).

   */

  bool client_aware;

  /**

   * Socket for this connection.  Set to #MHD_INVALID_SOCKET if

   * this connection has died (daemon should clean

   * up in that case).

   */

  MHD_socket socket_fd;

  /**

   * true if #socket_fd is non-blocking, false otherwise.

   */

  bool sk_nonblck;

  /**

   * Has this socket been closed for reading (i.e.  other side closed

   * the connection)?  If so, we must completely close the connection

   * once we are done sending our response (and stop trying to read

   * from this socket).

   */

  bool read_closed;

  /**

   * Set to `true` if the thread has been joined.

   */

  bool thread_joined;

  /**

   * Are we currently inside the "idle" handler (to avoid recursively

   * invoking it).

   */