5 files changed, 223 insertions, 233 deletions

diff --git a/src/daemon/connection.c b/src/daemon/connection.c
index dd75771d..8477a9d0 100644
--- a/src/daemon/connection.c
+++ b/src/daemon/connection.c
@@ -410,7 +410,8 @@ try_ready_chunked_body (struct MHD_Connection *connection)
     }
   if (ret > 0xFFFFFF)
     ret = 0xFFFFFF;
-  cblen = snprintf (cbuf, sizeof (cbuf), "%X\r\n", ret);
+  SPRINTF (cbuf, "%X\r\n", ret);
+  cblen = strlen(cbuf);
   EXTRA_CHECK (cblen <= sizeof (cbuf));
   memcpy (&connection->write_buffer[sizeof (cbuf) - cblen], cbuf, cblen);
   memcpy (&connection->write_buffer[sizeof (cbuf) + ret], "\r\n", 2);
@@ -458,10 +459,9 @@ add_extra_headers (struct MHD_Connection *connection)
   else if (NULL == MHD_get_response_header (connection->response,
                                             MHD_HTTP_HEADER_CONTENT_LENGTH))
     {
-      _REAL_SNPRINTF (buf,
-                      128,
-                      "%llu",
-                      (unsigned long long) connection->response->total_size);
+      SPRINTF (buf,
+               "%llu",
+               (unsigned long long) connection->response->total_size);
       MHD_add_response_header (connection->response,
                                MHD_HTTP_HEADER_CONTENT_LENGTH, buf);
     }
@@ -469,11 +469,12 @@ add_extra_headers (struct MHD_Connection *connection)
 
 /**
  * Produce HTTP "Date:" header.
- * @param date where to write the header
- * @param max maximum number of characters to write
+ *
+ * @param date where to write the header, with
+ *        at least 128 bytes available space.
  */
 static void
-get_date_string (char *date, unsigned int max)
+get_date_string (char *date)
 {
   static const char *days[] =
     { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" };
@@ -486,17 +487,17 @@ get_date_string (char *date, unsigned int max)
 
   time (&t);
   gmtime_r (&t, &now);
-  snprintf (date,
-            max - 1,
-            "Date: %3s, %02u %3s %04u %02u:%02u:%02u GMT\r\n",
-            days[now.tm_wday % 7],
-            now.tm_mday,
-            mons[now.tm_mon % 12],
-            1900 + now.tm_year, now.tm_hour, now.tm_min, now.tm_sec);
+  SPRINTF (date,
+           "Date: %3s, %02u %3s %04u %02u:%02u:%02u GMT\r\n",
+           days[now.tm_wday % 7],
+           now.tm_mday,
+           mons[now.tm_mon % 12],
+           1900 + now.tm_year, now.tm_hour, now.tm_min, now.tm_sec);
 }
 
 /**
- * try growing the read buffer
+ * Try growing the read buffer
+ *
  * @return MHD_YES on success, MHD_NO on failure
  */
 static int
@@ -530,7 +531,7 @@ build_header_response (struct MHD_Connection *connection)
   size_t size;
   size_t off;
   struct MHD_HTTP_Header *pos;
-  char code[128];
+  char code[256];
   char date[128];
   char *data;
   enum MHD_ValueKind kind;
@@ -540,15 +541,18 @@ build_header_response (struct MHD_Connection *connection)
     {
       add_extra_headers (connection);
       reason_phrase = MHD_get_reason_phrase_for (connection->responseCode);
-      _REAL_SNPRINTF (code, 128, "%s %u %s\r\n", MHD_HTTP_VERSION_1_1,
-                      connection->responseCode, reason_phrase);
+      SPRINTF (code,
+               "%s %u %s\r\n", 
+               MHD_HTTP_VERSION_1_1,
+               connection->responseCode,
+               reason_phrase);
       off = strlen (code);
       /* estimate size */
       size = off + 2;           /* extra \r\n at the end */
       kind = MHD_HEADER_KIND;
       if (NULL == MHD_get_response_header (connection->response,
                                            MHD_HTTP_HEADER_DATE))
-        get_date_string (date, sizeof (date));
+        get_date_string (date);
       else
         date[0] = '\0';
       size += strlen (date);
@@ -1138,9 +1142,9 @@ call_connection_handler (struct MHD_Connection *connection)
                 {
                   buffer_head[i] = '\0';
                   malformed =
-                    (1 != sscanf (buffer_head, "%X",
+                    (1 != SSCANF (buffer_head, "%X",
                                   &connection->current_chunk_size)) &&
-                    (1 != sscanf (buffer_head, "%x",
+                    (1 != SSCANF (buffer_head, "%x",
                                   &connection->current_chunk_size));
                 }
               if (malformed)
@@ -1234,8 +1238,9 @@ do_read (struct MHD_Connection *connection)
   if (connection->read_buffer_size == connection->read_buffer_offset)
     return MHD_NO;
 
-  bytes_read = connection->recv_cls (connection);
-
+  bytes_read = connection->recv_cls (connection,
+                                     &connection->read_buffer[connection->read_buffer_offset],
+                                     connection->read_buffer_size - connection->read_buffer_offset);
   if (bytes_read < 0)
     {
       if (errno == EINTR)
@@ -1270,7 +1275,11 @@ do_write (struct MHD_Connection *connection)
 {
   int ret;
 
-  ret = connection->send_cls (connection);
+  ret = connection->send_cls (connection,
+                              &connection->write_buffer
+                              [connection->write_buffer_send_offset],
+                              connection->write_buffer_append_offset
+                              - connection->write_buffer_send_offset);
 
   if (ret < 0)
     {
@@ -1284,7 +1293,7 @@ do_write (struct MHD_Connection *connection)
       return MHD_YES;
     }
 #if DEBUG_SEND_DATA
-  fprintf (stderr,
+  FPRINTF (stderr,
            "Sent response: `%.*s'\n",
            ret,
            &connection->write_buffer[connection->write_buffer_send_offset]);
@@ -1293,15 +1302,6 @@ do_write (struct MHD_Connection *connection)
   return MHD_YES;
 }
 
-static ssize_t
-MHD_con_read (struct MHD_Connection *connection)
-{
-  return RECV (connection->socket_fd,
-               &connection->read_buffer[connection->read_buffer_offset],
-               connection->read_buffer_size -
-               connection->read_buffer_offset, MSG_NOSIGNAL);
-}
-
 /**
  * Check if we are done sending the write-buffer.
  * If so, transition into "next_state".
@@ -1462,7 +1462,7 @@ parse_connection_headers (struct MHD_Connection *connection)
                                       MHD_HTTP_HEADER_CONTENT_LENGTH);
   if (clen != NULL)
     {
-      if (1 != sscanf (clen, "%llu", &cval))
+      if (1 != SSCANF (clen, "%llu", &cval))
         {
 #if HAVE_MESSAGES
           MHD_DLOG (connection->daemon,
@@ -1553,16 +1553,6 @@ MHD_connection_handle_read (struct MHD_Connection *connection)
   return MHD_YES;
 }
 
-static ssize_t
-MHD_con_write (struct MHD_Connection *connection)
-{
-  return SEND (connection->socket_fd,
-               &connection->write_buffer[connection->
-                                         write_buffer_send_offset],
-               connection->write_buffer_append_offset -
-               connection->write_buffer_send_offset, MSG_NOSIGNAL);
-}
-
 /**
  * This function was created to handle writes to sockets when it has
  * been determined that the socket can be written to. All
@@ -1595,12 +1585,11 @@ MHD_connection_handle_write (struct MHD_Connection *connection)
         case MHD_CONNECTION_HEADERS_PROCESSED:
           break;
         case MHD_CONNECTION_CONTINUE_SENDING:
-          ret = SEND (connection->socket_fd,
-                      &HTTP_100_CONTINUE
-                      [connection->continue_message_write_offset],
-                      strlen (HTTP_100_CONTINUE) -
-                      connection->continue_message_write_offset,
-                      MSG_NOSIGNAL);
+          ret = connection->send_cls (connection,
+                                      &HTTP_100_CONTINUE
+                                      [connection->continue_message_write_offset],
+                                      strlen (HTTP_100_CONTINUE) -
+                                      connection->continue_message_write_offset);
           if (ret < 0)
             {
               if (errno == EINTR)
@@ -1613,7 +1602,7 @@ MHD_connection_handle_write (struct MHD_Connection *connection)
               return MHD_NO;
             }
 #if DEBUG_SEND_DATA
-          fprintf (stderr,
+          FPRINTF (stderr,
                    "Sent 100 continue response: `%.*s'\n",
                    ret,
                    &HTTP_100_CONTINUE
@@ -1661,17 +1650,17 @@ MHD_connection_handle_write (struct MHD_Connection *connection)
           else
 #endif
             {
-              ret = SEND (connection->socket_fd,
-                          &response->data[connection->
-                                          response_write_position -
-                                          response->data_start],
-                          response->data_size -
-                          (connection->response_write_position -
-                           response->data_start), MSG_NOSIGNAL);
+              ret = connection->send_cls (connection,
+                                          &response->data[connection->
+                                                          response_write_position -
+                                                          response->data_start],
+                                          response->data_size -
+                                          (connection->response_write_position -
+                                           response->data_start));
             }
 #if DEBUG_SEND_DATA
           if (ret > 0)
-            fprintf (stderr,
+            FPRINTF (stderr,
                      "Sent DATA response: `%.*s'\n",
                      ret,
                      &response->data[connection->response_write_position -
@@ -1748,6 +1737,7 @@ MHD_connection_handle_idle (struct MHD_Connection *connection)
   unsigned int timeout;
   const char *end;
   char *line;
+
   while (1)
     {
 #if DEBUG_STATES
@@ -2072,8 +2062,6 @@ MHD_connection_handle_idle (struct MHD_Connection *connection)
 void
 MHD_set_http_calbacks (struct MHD_Connection *connection)
 {
-  connection->recv_cls = &MHD_con_read;
-  connection->send_cls = &MHD_con_write;
   connection->read_handler = &MHD_connection_handle_read;
   connection->write_handler = &MHD_connection_handle_write;
   connection->idle_handler = &MHD_connection_handle_idle;
diff --git a/src/daemon/connection_https.c b/src/daemon/connection_https.c
index 7504031b..df91af10 100644
--- a/src/daemon/connection_https.c
+++ b/src/daemon/connection_https.c
@@ -87,46 +87,23 @@ MHD_get_connection_info (struct MHD_Connection *connection,
 /**
  * This function is called once a secure connection has been marked
  * for closure.
- *
- * @param connection: the connection to close
- */
-static void
-MHD_tls_connection_close (struct MHD_Connection *connection)
-{
-  MHD_gnutls_bye (connection->tls_session, GNUTLS_SHUT_WR);
-  connection->tls_session->internals.read_eof = 1;
-
-  SHUTDOWN (connection->socket_fd, SHUT_RDWR);
-  CLOSE (connection->socket_fd);
-  connection->socket_fd = -1;
-
-  connection->state = MHD_CONNECTION_CLOSED;
-
-  /* call notify_completed callback if one was registered */
-  if (connection->daemon->notify_completed != NULL)
-    connection->daemon->notify_completed (connection->daemon->
-                                          notify_completed_cls, connection,
-                                          &connection->client_context,
-                                          MHD_REQUEST_TERMINATED_COMPLETED_OK);
-}
-
-/**
- * This function is called once a secure connection has been marked
- * for closure.
+ * 
+ * NOTE: Some code duplication with connection_close_error
+ * in connection.c
  *
  * @param connection: the connection to close
  * @param termination_code: the termination code with which the notify completed callback function is called.
  */
 static void
-MHD_tls_connection_close_err (struct MHD_Connection *connection,
+MHD_tls_connection_close (struct MHD_Connection *connection,
                               enum MHD_RequestTerminationCode
                               termination_code)
 {
+  MHD_gnutls_bye (connection->tls_session, GNUTLS_SHUT_WR);
   connection->tls_session->internals.read_eof = 1;
   SHUTDOWN (connection->socket_fd, SHUT_RDWR);
   CLOSE (connection->socket_fd);
   connection->socket_fd = -1;
-
   connection->state = MHD_CONNECTION_CLOSED;
   if (connection->daemon->notify_completed != NULL)
     connection->daemon->notify_completed (connection->daemon->
@@ -135,39 +112,6 @@ MHD_tls_connection_close_err (struct MHD_Connection *connection,
                                           termination_code);
 }
 
-
-/**
- * @name : MHDS_con_read
- *
- * reads data from the TLS record protocol
- * @param connection: is a %MHD_Connection structure.
- * @return: number of bytes received and zero on EOF.  A negative
- * error code is returned in case of an error.
- **/
-static ssize_t
-MHDS_con_read (struct MHD_Connection *connection)
-{
-  /* no special handling when GNUTLS_E_AGAIN is returned since this function is called from within a select loop */
-  ssize_t size = MHD_gnutls_record_recv (connection->tls_session,
-                                         &connection->read_buffer
-                                         [connection->read_buffer_offset],
-                                         connection->read_buffer_size);
-  return size;
-}
-
-static ssize_t
-MHDS_con_write (struct MHD_Connection *connection)
-{
-  ssize_t sent = MHD_gnutls_record_send (connection->tls_session,
-                                         &connection->write_buffer
-                                         [connection->
-                                          write_buffer_send_offset],
-                                         connection->write_buffer_append_offset
-                                         -
-                                         connection->write_buffer_send_offset);
-  return sent;
-}
-
 /**
  * This function was created to handle per-connection processing that
  * has to happen even if the socket cannot be read or written to.  All
@@ -187,16 +131,14 @@ MHD_tls_connection_handle_idle (struct MHD_Connection *connection)
   MHD_DLOG (connection->daemon, "%s: state: %s\n",
             __FUNCTION__, MHD_state_to_string (connection->state));
 #endif
-
   timeout = connection->daemon->connection_timeout;
   if ((connection->socket_fd != -1) && (timeout != 0)
       && (time (NULL) - timeout > connection->last_activity))
     {
-      MHD_tls_connection_close_err (connection,
-                                    MHD_REQUEST_TERMINATED_TIMEOUT_REACHED);
+      MHD_tls_connection_close (connection,
+                                MHD_REQUEST_TERMINATED_TIMEOUT_REACHED);
       return MHD_NO;
     }
-
   switch (connection->state)
     {
       /* on newly created connections we might reach here before any reply has been received */
@@ -205,10 +147,11 @@ MHD_tls_connection_handle_idle (struct MHD_Connection *connection)
       /* close connection if necessary */
     case MHD_CONNECTION_CLOSED:
       if (connection->socket_fd != -1)
-        MHD_tls_connection_close (connection);
+        MHD_tls_connection_close (connection,
+                                      MHD_REQUEST_TERMINATED_COMPLETED_OK);
       return MHD_NO;
     case MHD_TLS_HANDSHAKE_FAILED:
-      MHD_tls_connection_close_err (connection,
+      MHD_tls_connection_close (connection,
                                     MHD_TLS_REQUEST_TERMINATED_WITH_ERROR);
       return MHD_NO;
       /* some HTTP state */
@@ -293,14 +236,14 @@ MHD_tls_connection_handle_read (struct MHD_Connection *connection)
           MHD_DLOG (connection->daemon,
                     "Error: received handshake message out of context\n");
 #endif
-          MHD_tls_connection_close_err (connection,
+          MHD_tls_connection_close (connection,
                                         MHD_TLS_REQUEST_TERMINATED_WITH_ERROR);
           return MHD_NO;
         }
 
       /* ignore any out of bound change chiper spec messages */
     case GNUTLS_CHANGE_CIPHER_SPEC:
-      MHD_tls_connection_close_err (connection,
+      MHD_tls_connection_close (connection,
                                     MHD_TLS_REQUEST_TERMINATED_WITH_ERROR);
       return MHD_NO;
 
@@ -335,8 +278,8 @@ MHD_tls_connection_handle_read (struct MHD_Connection *connection)
       else if (connection->tls_session->internals.last_alert_level ==
                GNUTLS_AL_FATAL)
         {
-          MHD_tls_connection_close_err (connection,
-                                        MHD_TLS_REQUEST_TERMINATED_WITH_FATAL_ALERT);
+          MHD_tls_connection_close (connection,
+                                    MHD_TLS_REQUEST_TERMINATED_WITH_FATAL_ALERT);
           return MHD_NO;
         }
       /* this should never execute */
@@ -400,16 +343,13 @@ MHD_tls_connection_handle_write (struct MHD_Connection *connection)
   return MHD_NO;
 }
 
-/*
- * set connection callback function to be used through out
+/**
+ * Set connection callback function to be used through out
  * the processing of this secure connection.
- *
  */
 void
 MHD_set_https_calbacks (struct MHD_Connection *connection)
 {
-  connection->recv_cls = &MHDS_con_read;
-  connection->send_cls = &MHDS_con_write;
   connection->read_handler = &MHD_tls_connection_handle_read;
   connection->write_handler = &MHD_tls_connection_handle_write;
   connection->idle_handler = &MHD_tls_connection_handle_idle;
diff --git a/src/daemon/daemon.c b/src/daemon/daemon.c
index 7911be33..34a94922 100644
--- a/src/daemon/daemon.c
+++ b/src/daemon/daemon.c
@@ -60,7 +60,65 @@
 #define DEBUG_CONNECT MHD_NO
 
 #if HTTPS_SUPPORT
-/* TODO unite with code in gnutls_priority.c */
+/**
+ * Note: code duplication with code in gnutls_priority.c 
+ *
+ * @return 0
+ */
+static int
+_set_priority (mhd_gtls_priority_st * st, const int *list)
+{
+  int num = 0;
+
+  while ( (list[num] != 0) &&
+          (num < MAX_ALGOS) )
+    num++;
+  st->num_algorithms = num;
+  memcpy(st->priority, list, num * sizeof(int));
+  return 0;
+}
+
+
+/**
+ * Callback for receiving data from the socket.
+ *
+ * @param conn the MHD connection structure
+ * @param other where to write received data to
+ * @param i maximum size of other (in bytes)
+ * @return number of bytes actually received
+ */
+static ssize_t
+recv_tls_adapter (struct MHD_Connection* connection,
+                  void *other,
+                  size_t i)
+{
+  return MHD_gnutls_record_recv(connection->tls_session,
+                                other, i);
+}
+
+/**
+ * Callback for writing data to the socket.
+ *
+ * @param conn the MHD connection structure
+ * @param other data to write
+ * @param i number of bytes to write
+ * @return actual number of bytes written
+ */
+static ssize_t
+send_tls_adapter (struct MHD_Connection* connection,
+                  const void *other, 
+                    size_t i)
+{
+  return MHD_gnutls_record_send(connection->tls_session, 
+                                other, i);
+}
+
+
+/**
+ * Read and setup our certificate and key.
+ *
+ * @return 0 on success
+ */
 static int
 MHD_init_daemon_certificate (struct MHD_Daemon *daemon)
 {
@@ -132,27 +190,25 @@ MHD_init_daemon_certificate (struct MHD_Daemon *daemon)
 }
 
 /**
- * initialize security aspects of the HTTPS daemon 
+ * Initialize security aspects of the HTTPS daemon 
+ *
+ * @return 0 on success
  */
 static int
 MHD_TLS_init (struct MHD_Daemon *daemon)
 {
-  int ret;
-
   switch (daemon->cred_type)
     {
     case MHD_GNUTLS_CRD_ANON:
-      ret = MHD_gnutls_anon_allocate_server_credentials (&daemon->anon_cred);
-      ret |= MHD_gnutls_dh_params_init (&daemon->dh_params);
-      if (ret != 0)
+      if ( (0 != MHD_gnutls_anon_allocate_server_credentials (&daemon->anon_cred)) ||
+           (0 != MHD_gnutls_dh_params_init (&daemon->dh_params)) )
         return GNUTLS_E_MEMORY_ERROR;        
       MHD_gnutls_dh_params_generate2 (daemon->dh_params, 1024);
       MHD_gnutls_anon_set_server_dh_params (daemon->anon_cred,
                                             daemon->dh_params);
       return 0;
     case MHD_GNUTLS_CRD_CERTIFICATE:
-      ret = MHD_gnutls_certificate_allocate_credentials (&daemon->x509_cred);
-      if (ret != 0)
+      if (0 != MHD_gnutls_certificate_allocate_credentials (&daemon->x509_cred))
         return GNUTLS_E_MEMORY_ERROR;
       return MHD_init_daemon_certificate (daemon);
     default:
@@ -164,19 +220,6 @@ MHD_TLS_init (struct MHD_Daemon *daemon)
       return -1;
     }
 }
-
-static int
-_set_priority (mhd_gtls_priority_st * st, const int *list)
-{
-  int num = 0;
-
-  while ( (list[num] != 0) &&
-          (num < MAX_ALGOS) )
-    num++;
-  st->num_algorithms = num;
-  memcpy(st->priority, list, num * sizeof(int));
-  return 0;
-}
 #endif
 
 /**
@@ -292,9 +335,8 @@ MHD_handle_connection (void *data)
   return NULL;
 }
 
-#if HTTPS_SUPPORT
 /**
- * Callback for receiving data from the socket (for gnutls).
+ * Callback for receiving data from the socket.
  *
  * @param conn the MHD connection structure
  * @param other where to write received data to
@@ -302,19 +344,17 @@ MHD_handle_connection (void *data)
  * @return number of bytes actually received
  */
 static ssize_t
-pull_param_adapter (gnutls_transport_ptr_t conn,
+recv_param_adapter (struct MHD_Connection * connection,
                     void *other,
                     size_t i)
 {
-  struct MHD_Connection * connection = (struct MHD_Connection*) conn;
-
   if (connection->socket_fd == -1)
     return -1;
   return RECV(connection->socket_fd, other, i, MSG_NOSIGNAL);
 }
 
 /**
- * Callback for writing data to the socket (for gnutls).
+ * Callback for writing data to the socket.
  *
  * @param conn the MHD connection structure
  * @param other data to write
@@ -322,61 +362,16 @@ pull_param_adapter (gnutls_transport_ptr_t conn,
  * @return actual number of bytes written
  */
 static ssize_t
-push_param_adapter (void *conn,
+send_param_adapter (struct MHD_Connection *connection,
                     const void *other, 
                     size_t i)
 {
-  struct MHD_Connection * connection = (struct MHD_Connection*) conn;
-
   if (connection->socket_fd == -1)
     return -1;
   return SEND(connection->socket_fd, other, i, MSG_NOSIGNAL);
 }
 
 /**
- * Handle an individual TLS connection (main function
- * of the thread handling a TLS connection).
- */
-static void *
-MHD_TLS_init_connection (void *data)
-{
-  struct MHD_Connection *con = data;
-
-  EXTRA_CHECK (con->state == MHD_CONNECTION_INIT);
-  con->state = MHD_TLS_CONNECTION_INIT;
-  MHD_gnutls_init (&con->tls_session, GNUTLS_SERVER);
-  MHD_gnutls_priority_set (con->tls_session, con->daemon->priority_cache);
-  switch (con->daemon->cred_type)
-    {
-      /* set needed credentials for certificate authentication. */
-    case MHD_GNUTLS_CRD_CERTIFICATE:
-      MHD_gnutls_credentials_set (con->tls_session,
-                                  MHD_GNUTLS_CRD_CERTIFICATE,
-                                  con->daemon->x509_cred);
-      break;
-    case MHD_GNUTLS_CRD_ANON:
-      /* set needed credentials for anonymous authentication. */
-      MHD_gnutls_credentials_set (con->tls_session, MHD_GNUTLS_CRD_ANON,
-                                  con->daemon->anon_cred);
-      MHD_gnutls_dh_set_prime_bits (con->tls_session, 1024);
-      break;
-    default:
-#if HAVE_MESSAGES
-      MHD_DLOG (con->daemon,
-                "Failed to setup TLS credentials: unknown credential type %d\n",
-                con->daemon->cred_type);
-#endif
-      abort();
-    }
-  MHD_gnutls_transport_set_ptr (con->tls_session,
-                                (gnutls_transport_ptr_t) con);
-  MHD_gnutls_transport_set_pull_function(con->tls_session, &pull_param_adapter);
-  MHD_gnutls_transport_set_push_function(con->tls_session, &push_param_adapter);  
-  return MHD_handle_connection (data);
-}
-#endif
-
-/**
  * Accept an incoming connection and create the MHD_Connection object for
  * it.  This function also enforces policy by way of checking with the
  * accept policy callback.
@@ -519,19 +514,52 @@ MHD_accept_connection (struct MHD_Daemon *daemon)
 
   /* set default connection handlers  */
   MHD_set_http_calbacks (connection);
+  connection->recv_cls = &recv_param_adapter;
+  connection->send_cls = &send_param_adapter;
 #if HTTPS_SUPPORT
   if (0 != (daemon->options & MHD_USE_SSL))
-    MHD_set_https_calbacks (connection);    
+    {
+      connection->recv_cls = &recv_tls_adapter;
+      connection->send_cls = &send_tls_adapter;
+      connection->state = MHD_TLS_CONNECTION_INIT;
+      MHD_set_https_calbacks (connection);    
+      MHD_gnutls_init (&connection->tls_session, GNUTLS_SERVER);
+      MHD_gnutls_priority_set (connection->tls_session, connection->daemon->priority_cache);
+      switch (connection->daemon->cred_type)
+        {
+          /* set needed credentials for certificate authentication. */
+        case MHD_GNUTLS_CRD_CERTIFICATE:
+          MHD_gnutls_credentials_set (connection->tls_session,
+                                      MHD_GNUTLS_CRD_CERTIFICATE,
+                                      connection->daemon->x509_cred);
+          break;
+        case MHD_GNUTLS_CRD_ANON:
+          /* set needed credentials for anonymous authentication. */
+          MHD_gnutls_credentials_set (connection->tls_session, MHD_GNUTLS_CRD_ANON,
+                                      connection->daemon->anon_cred);
+          MHD_gnutls_dh_set_prime_bits (connection->tls_session, 1024);
+          break;
+        default:
+#if HAVE_MESSAGES
+          MHD_DLOG (connection->daemon,
+                    "Failed to setup TLS credentials: unknown credential type %d\n",
+                    connection->daemon->cred_type);
+#endif
+          abort();
+        }
+      MHD_gnutls_transport_set_ptr (connection->tls_session,
+                                    (gnutls_transport_ptr_t) connection);
+      MHD_gnutls_transport_set_pull_function(connection->tls_session, 
+                                             (mhd_gtls_pull_func) &recv_param_adapter);
+      MHD_gnutls_transport_set_push_function(connection->tls_session, 
+                                             (mhd_gtls_push_func) &send_param_adapter);  
+    }
 #endif
 
   /* attempt to create handler thread */
   if (0 != (daemon->options & MHD_USE_THREAD_PER_CONNECTION))
     {
       res_thread_create = pthread_create (&connection->pid, NULL,
-#if HTTPS_SUPPORT
-                                          (0 != (daemon->options & MHD_USE_SSL)) ? 
-                                          &MHD_TLS_init_connection : 
-#endif
                                           &MHD_handle_connection,
                                           connection);
       if (res_thread_create != 0)
@@ -855,7 +883,6 @@ MHD_start_daemon_va (unsigned int options,
   retVal->max_connections = MHD_MAX_CONNECTIONS_DEFAULT;
   retVal->pool_size = MHD_POOL_SIZE_DEFAULT;
   retVal->connection_timeout = 0;       /* no timeout */
-
 #if HTTPS_SUPPORT
   if (options & MHD_USE_SSL)
     {
@@ -931,13 +958,13 @@ MHD_start_daemon_va (unsigned int options,
           if ((opt >= MHD_OPTION_HTTPS_KEY_PATH) &&
               (opt <= MHD_OPTION_TLS_COMP_ALGO))
             {
-              fprintf (stderr,
+              FPRINTF (stderr,
                        "MHD HTTPS option %d passed to MHD compiled without HTTPS support\n",
                        opt);
             }
           else
             {
-              fprintf (stderr,
+              FPRINTF (stderr,
                        "Invalid option %d! (Did you terminate the list with MHD_OPTION_END?)\n",
                        opt);
             }
@@ -954,7 +981,7 @@ MHD_start_daemon_va (unsigned int options,
     {
 #if HAVE_MESSAGES
       if ((options & MHD_USE_DEBUG) != 0)
-        fprintf (stderr, "Call to socket failed: %s\n", STRERROR (errno));
+        FPRINTF (stderr, "Call to socket failed: %s\n", STRERROR (errno));
 #endif
       free (retVal);
       return NULL;
@@ -965,7 +992,7 @@ MHD_start_daemon_va (unsigned int options,
                    &on, sizeof (on)) < 0) && (options & MHD_USE_DEBUG) != 0)
     {
 #if HAVE_MESSAGES
-      fprintf (stderr, "setsockopt failed: %s\n", STRERROR (errno));
+      FPRINTF (stderr, "setsockopt failed: %s\n", STRERROR (errno));
 #endif
     }
 
@@ -996,7 +1023,7 @@ MHD_start_daemon_va (unsigned int options,
     {
 #if HAVE_MESSAGES
       if ((options & MHD_USE_DEBUG) != 0)
-        fprintf (stderr,
+        FPRINTF (stderr,
                  "Failed to bind to port %u: %s\n", port, STRERROR (errno));
 #endif
       CLOSE (socket_fd);
@@ -1009,7 +1036,7 @@ MHD_start_daemon_va (unsigned int options,
     {
 #if HAVE_MESSAGES
       if ((options & MHD_USE_DEBUG) != 0)
-        fprintf (stderr,
+        FPRINTF (stderr,
                  "Failed to listen for connections: %s\n", STRERROR (errno));
 #endif
       CLOSE (socket_fd);
@@ -1019,7 +1046,8 @@ MHD_start_daemon_va (unsigned int options,
 
 #if HTTPS_SUPPORT
   /* initialize HTTPS daemon certificate aspects & send / recv functions */
-  if ((options & MHD_USE_SSL) && MHD_TLS_init (retVal))
+  if ( (0 != (options & MHD_USE_SSL)) &&
+       (0 != MHD_TLS_init (retVal)) )
     {
 #if HAVE_MESSAGES
       MHD_DLOG (retVal, "Failed to initialize TLS support\n");
diff --git a/src/daemon/https/tls/gnutls_buffers.c b/src/daemon/https/tls/gnutls_buffers.c
index da44e87c..16be8011 100644
--- a/src/daemon/https/tls/gnutls_buffers.c
+++ b/src/daemon/https/tls/gnutls_buffers.c
@@ -487,6 +487,7 @@ mhd_gtls_io_read_buffered (mhd_gtls_session_t session, opaque ** iptr,
   if (sizeOfPtr > MAX_RECV_SIZE || sizeOfPtr == 0)
     {
       gnutls_assert ();         /* internal error */
+      printf("AT %u\n", __LINE__);
       return GNUTLS_E_INVALID_REQUEST;
     }
 
@@ -537,6 +538,7 @@ mhd_gtls_io_read_buffered (mhd_gtls_session_t session, opaque ** iptr,
       > MAX_RECV_SIZE)
     {
       gnutls_assert ();         /* internal error */
+      printf("AT %u\n", __LINE__);
       return GNUTLS_E_INVALID_REQUEST;
     }
 
@@ -549,12 +551,14 @@ mhd_gtls_io_read_buffered (mhd_gtls_session_t session, opaque ** iptr,
   if (session->internals.record_recv_buffer.data == NULL)
     {
       gnutls_assert ();
+      printf("AT %u\n", __LINE__);
       return GNUTLS_E_MEMORY_ERROR;
     }
 
   buf_pos = session->internals.record_recv_buffer.length;
   buf = session->internals.record_recv_buffer.data;
   *iptr = buf;
+      printf("AT %u\n", __LINE__);
 
   /* READ DATA - but leave RCVLOWAT bytes in the kernel buffer. */
   if (recvdata - recvlowat > 0)
@@ -566,6 +570,7 @@ mhd_gtls_io_read_buffered (mhd_gtls_session_t session, opaque ** iptr,
        */
       if (ret < 0 && MHD_gtls_error_is_fatal (ret) == 0)
         {
+      printf("AT %u\n", __LINE__);
           return ret;
         }
     }
@@ -593,6 +598,7 @@ mhd_gtls_io_read_buffered (mhd_gtls_session_t session, opaque ** iptr,
 
       if (ret2 < 0 && MHD_gtls_error_is_fatal (ret2) == 0)
         {
+      printf("AT %u\n", __LINE__);
           return ret2;
         }
 
@@ -612,6 +618,7 @@ mhd_gtls_io_read_buffered (mhd_gtls_session_t session, opaque ** iptr,
     {
       gnutls_assert ();
       /* that's because they are initialized to 0 */
+      printf("AT %u\n", __LINE__);
       return MIN (ret, ret2);
     }
 
@@ -620,12 +627,14 @@ mhd_gtls_io_read_buffered (mhd_gtls_session_t session, opaque ** iptr,
   if (ret > 0 && ret < recvlowat)
     {
       gnutls_assert ();
+      printf("AT %u\n", __LINE__);
       return GNUTLS_E_AGAIN;
     }
 
   if (ret == 0)
     {                           /* EOF */
       gnutls_assert ();
+      printf("AT %u\n", __LINE__);
       return 0;
     }
 
@@ -635,10 +644,12 @@ mhd_gtls_io_read_buffered (mhd_gtls_session_t session, opaque ** iptr,
     {
       /* Short Read */
       gnutls_assert ();
+      printf("AT %u\n", __LINE__);
       return GNUTLS_E_AGAIN;
     }
   else
     {
+      printf("AT %u\n", __LINE__);
       return ret;
     }
 }
diff --git a/src/daemon/internal.h b/src/daemon/internal.h
index c2d6ab0b..76c17dbc 100644
--- a/src/daemon/internal.h
+++ b/src/daemon/internal.h
@@ -305,6 +305,33 @@ enum MHD_CONNECTION_STATE
 char *MHD_state_to_string (enum MHD_CONNECTION_STATE state);
 #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 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 * write_to,
+                                    size_t max_bytes);
+
+
+
 struct MHD_Connection
 {
 
@@ -538,13 +565,9 @@ struct MHD_Connection
 
   int (*idle_handler) (struct MHD_Connection * connection);
 
-  /**
-   * function pointers to the appropriate send & receive funtions
-   * according to whether this is a HTTPS / HTTP daemon
-   */
-  ssize_t (*recv_cls) (struct MHD_Connection * connection);
-  
-  ssize_t (*send_cls) (struct MHD_Connection * connection);
+  ReceiveCallback recv_cls;
+
+  TransmitCallback send_cls;
   
 #if HTTPS_SUPPORT
   /* TODO rename as this might be an SSL connection */