1 files changed, 105 insertions, 105 deletions
diff --git a/src/daemon/internal.h b/src/daemon/internal.h
index a06d7ae2..37075bc0 100644
--- a/src/daemon/internal.h
+++ b/src/daemon/internal.h
@@ -63,101 +63,101 @@
 * fprintf-like helper function for logging debug
 * messages.
 */
-void MHD_DLOG(const struct MHD_Daemon *daemon, const char *format, ...);
+void MHD_DLOG (const struct MHD_Daemon *daemon, const char *format, ...);
 #endif
 /**
 * Process escape sequences ('+'=space, %HH).
 * Updates val in place.
 */
-void MHD_http_unescape(char *val);
+void MHD_http_unescape (char *val);
 /**
 * Header or cookie in HTTP request or response.
 */
 struct MHD_HTTP_Header
-  {
+{
-    struct MHD_HTTP_Header *next;
+  struct MHD_HTTP_Header *next;
-    char *header;
+  char *header;
-    char *value;
+  char *value;
-    enum MHD_ValueKind kind;
+  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;
+  struct MHD_HTTP_Header *first_header;
    /**
     * Buffer pointing to data that we are supposed
     * to send as a response.
     */
-    char *data;
+  char *data;
    /**
     * Closure to give to the content reader
     * free callback.
     */
-    void *crc_cls;
+  void *crc_cls;
    /**
     * How do we get more data?  NULL if we are
     * given all of the data up front.
     */
-    MHD_ContentReaderCallback crc;
+  MHD_ContentReaderCallback crc;
    /**
     * NULL if data must not be freed, otherwise
     * either user-specified callback or "&free".
     */
-    MHD_ContentReaderFreeCallback crfc;
+  MHD_ContentReaderFreeCallback crfc;
    /**
     * Mutex to synchronize access to data/size and
     * reference counts.
     */
-    pthread_mutex_t mutex;
+  pthread_mutex_t mutex;
    /**
     * Reference count for this response.  Free
     * once the counter hits zero.
     */
-    unsigned int reference_count;
+  unsigned int reference_count;
    /**
     * Set to -1 if size is not known.
     */
-    size_t total_size;
+  size_t total_size;
    /**
     * Size of data.
     */
-    size_t data_size;
+  size_t data_size;
    /**
     * Size of the data buffer.
     */
-    size_t data_buffer_size;
+  size_t data_buffer_size;
    /**
     * At what offset in the stream is the
     * beginning of data located?
     */
-    size_t data_start;
+  size_t data_start;
-  };
+};
 /**
 * States in a state machine for a connection.
@@ -174,151 +174,151 @@ struct MHD_Response
 * 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,
+  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,
+  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,
+  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,
+  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,
+  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,
+  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,
+  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,
+  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,
+  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,
+  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,
+  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,
+  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,
+  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,
+  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,
+  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,
+  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,
+  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,
+  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,
+  MHD_CONNECTION_FOOTERS_SENT = MHD_CONNECTION_FOOTERS_SENDING + 1,
    /**
     * 19: This connection is closed (no more activity
     * allowed).
     */
-    MHD_CONNECTION_CLOSED = MHD_CONNECTION_FOOTERS_SENT + 1,
+  MHD_CONNECTION_CLOSED = MHD_CONNECTION_FOOTERS_SENT + 1,
-  };
+};
 enum MHDS_CONNECTION_STATE
-  {
+{
-    MHDS_CONNECTION_INIT = 0,
+  MHDS_CONNECTION_INIT = 0,
    /**
     * 1: We got the URL (and request type and version).  Wait for a header line.
     */
-    MHDS_HANDSHAKE_COMPLETE = MHDS_CONNECTION_INIT + 1,
+  MHDS_HANDSHAKE_COMPLETE = MHDS_CONNECTION_INIT + 1,
-    MHDS_CONNECTION_CONTINUE_SENDING = MHDS_HANDSHAKE_COMPLETE + 1,
+  MHDS_CONNECTION_CONTINUE_SENDING = MHDS_HANDSHAKE_COMPLETE + 1,
-    MHDS_CONNECTION_CLOSED = MHDS_CONNECTION_CONTINUE_SENDING + 1
+  MHDS_CONNECTION_CLOSED = MHDS_CONNECTION_CONTINUE_SENDING + 1
-  };
+};
 struct MHD_Connection
-  {
+{
    /**
     * This is a linked list.
     */
-    struct MHD_Connection *next;
+  struct MHD_Connection *next;
    /**
     * Reference to the MHD_Daemon struct.
     */
-    struct MHD_Daemon *daemon;
+  struct MHD_Daemon *daemon;
    /**
     * Linked list of parsed headers.
     */
-    struct MHD_HTTP_Header *headers_received;
+  struct MHD_HTTP_Header *headers_received;
    /**
     * Response to transmit (initially NULL).
     */
-    struct MHD_Response *response;
+  struct MHD_Response *response;
    /**
     * The memory pool is created whenever we first read
@@ -330,7 +330,7 @@ struct MHD_Connection
     * connections) and the IP address (which persists
     * across individual requests).
     */
-    struct MemoryPool *pool;
+  struct MemoryPool *pool;
    /**
     * We allow the main application to associate some
@@ -338,25 +338,25 @@ struct MHD_Connection
     * store it.  (MHD does not know or care what it
     * is).
     */
-    void *client_context;
+  void *client_context;
    /**
     * Request method.  Should be GET/POST/etc.  Allocated
     * in pool.
     */
-    char *method;
+  char *method;
    /**
     * Requested URL (everything after "GET" only).  Allocated
     * in pool.
     */
-    char *url;
+  char *url;
    /**
     * HTTP version string (i.e. http/1.1).  Allocated
     * in pool.
     */
-    char *version;
+  char *version;
    /**
     * Buffer for reading requests.   Allocated
@@ -364,20 +364,20 @@ struct MHD_Connection
     * read_buffer_size (if non-NULL) to allow for
     * 0-termination.
     */
-    char *read_buffer;
+  char *read_buffer;
    /**
     * Buffer for writing response (headers only).  Allocated
     * in pool.
     */
-    char *write_buffer;
+  char *write_buffer;
    /**
     * Last incomplete header line during parsing of headers.
     * Allocated in pool.  Only valid if state is
     * either HEADER_PART_RECEIVED or FOOTER_PART_RECEIVED.
     */
-    char *last;
+  char *last;
    /**
     * Position after the colon on the last incomplete header
@@ -385,19 +385,19 @@ struct MHD_Connection
     * Allocated in pool.  Only valid if state is
     * either HEADER_PART_RECEIVED or FOOTER_PART_RECEIVED.
     */
-    char *colon;
+  char *colon;
    /**
     * Foreign address (of length addr_len).  MALLOCED (not
     * in pool!).
     */
-    struct sockaddr_in *addr;
+  struct sockaddr_in *addr;
    /**
     * Thread for this connection (if we are using
     * one thread per connection).
     */
-    pthread_t pid;
+  pthread_t pid;
    /**
     * Size of read_buffer (in bytes).  This value indicates
@@ -405,66 +405,66 @@ struct MHD_Connection
     * the real buffer is one byte longer to allow for
     * adding zero-termination (when needed).
     */
-    size_t read_buffer_size;
+  size_t read_buffer_size;
    /**
     * Position where we currently append data in
     * read_buffer (last valid position).
     */
-    size_t read_buffer_offset;
+  size_t read_buffer_offset;
    /**
     * Size of write_buffer (in bytes).
     */
-    size_t write_buffer_size;
+  size_t write_buffer_size;
    /**
     * Offset where we are with sending from write_buffer.
     */
-    size_t write_buffer_send_offset;
+  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;
+  size_t write_buffer_append_offset;
    /**
     * How many more bytes of the body do we expect
     * to read? "-1" for unknown.
     */
-    size_t remaining_upload_size;
+  size_t remaining_upload_size;
    /**
     * Current write position in the actual response
     * (excluding headers, content only; should be 0
     * while sending headers).
     */
-    size_t response_write_position;
+  size_t response_write_position;
    /**
     * Position in the 100 CONTINUE message that
     * we need to send when receiving http 1.1 requests.
     */
-    size_t continue_message_write_offset;
+  size_t continue_message_write_offset;
    /**
     * Length of the foreign address.
     */
-    socklen_t addr_len;
+  socklen_t addr_len;
    /**
     * Last time this connection had any activity
     * (reading or writing).
     */
-    time_t last_activity;
+  time_t last_activity;
    /**
     * Socket for this connection.  Set to -1 if
     * this connection has died (daemon should clean
     * up in that case).
     */
-    int socket_fd;
+  int socket_fd;
    /**
     * Has this socket been closed for reading (i.e.
@@ -473,18 +473,18 @@ struct MHD_Connection
     * we are done sending our response (and stop
     * trying to read from this socket).
     */
-    int read_closed;
+  int read_closed;
    /**
     * State in the FSM for this connection.
     */
-    enum MHD_CONNECTION_STATE state;
+  enum MHD_CONNECTION_STATE state;
    /**
     * HTTP response code.  Only valid if response object
     * is already set.
     */
-    unsigned int responseCode;
+  unsigned int responseCode;
    /**
     * Set to MHD_YES if the response's content reader
@@ -493,12 +493,12 @@ struct MHD_Connection
     * write socket should be marked as unready until
     * the CRC call succeeds.
     */
-    int response_unready;
+  int response_unready;
    /**
     * Are we sending with chunked encoding?
     */
-    int have_chunked_response;
+  int have_chunked_response;
    /**
     * Are we receiving with chunked encoding?  This will be set to
@@ -507,7 +507,7 @@ struct MHD_Connection
     * processing the footers; once the footers are also done, this will
     * be set to MHD_NO again (before the final call to the handler).
     */
-    int have_chunked_upload;
+  int have_chunked_upload;
    /**
     * If we are receiving with chunked encoding, where are we right
@@ -515,97 +515,97 @@ struct MHD_Connection
     * otherwise, this is the size of the current chunk.  A value of
     * zero is also used when we're at the end of the chunks.
     */
-    unsigned int current_chunk_size;
+  unsigned int current_chunk_size;
    /**
     * If we are receiving with chunked encoding, where are we currently
     * with respect to the current chunk (at what offset / position)?
     */
-    unsigned int current_chunk_offset;
+  unsigned int current_chunk_offset;
-  };
+};
 typedef struct MHD_Connection MHD_Connection_t;
 struct MHD_Daemon
-  {
+{
    /**
     * Callback function for all requests.
     */
-    MHD_AccessHandlerCallback default_handler;
+  MHD_AccessHandlerCallback default_handler;
    /**
     * Closure argument to default_handler.
     */
-    void *default_handler_cls;
+  void *default_handler_cls;
    /**
     * Linked list of our current connections.
     */
-    struct MHD_Connection *connections;
+  struct MHD_Connection *connections;
    /**
     * Linked list of our current connections.
     */
-    // TODO switch to a dedicated tls connection struct 
+  // TODO switch to a dedicated tls connection struct 
-    struct MHD_Connection *tls_connections;
+  struct MHD_Connection *tls_connections;
-    MHD_AcceptPolicyCallback apc;
+  MHD_AcceptPolicyCallback apc;
-    void *apc_cls;
+  void *apc_cls;
-    MHD_RequestCompletedCallback notify_completed;
+  MHD_RequestCompletedCallback notify_completed;
-    void *notify_completed_cls;
+  void *notify_completed_cls;
    /**
     * PID of the select thread (if we have internal select)
     */
-    pthread_t pid;
+  pthread_t pid;
    /**
     * Listen socket.
     */
-    int socket_fd;
+  int socket_fd;
    /**
     * Are we shutting down?
     */
-    int shutdown;
+  int shutdown;
    /**
     * Size of the per-connection memory pools.
     */
-    unsigned int pool_size;
+  unsigned int pool_size;
    /**
     * Limit on the number of parallel connections.
     */
-    unsigned int max_connections;
+  unsigned int max_connections;
    /**
     * After how many seconds of inactivity should
     * connections time out?  Zero for no timeout.
     */
-    unsigned int connection_timeout;
+  unsigned int connection_timeout;
    /**
     * Maximum number of connections per IP, or 0 for
     * unlimited.
     */
-    unsigned int per_ip_connection_limit;
+  unsigned int per_ip_connection_limit;
    /**
     * Daemon's options.
     */
-    enum MHD_OPTION options;
+  enum MHD_OPTION options;
    /**
     * Listen port.
     */
-    unsigned short port;
+  unsigned short port;
-  };
+};
 #endif