1 files changed, 78 insertions, 390 deletions

diff --git a/src/microhttpd/connection.c b/src/microhttpd/connection.c
index 6f33dbc1..7b630b77 100644
--- a/src/microhttpd/connection.c
+++ b/src/microhttpd/connection.c
@@ -53,7 +53,7 @@
 /* For FreeBSD version identification */
 #include <sys/param.h>
 #endif /* HAVE_SYS_PARAM_H */
-
+#include "mhd_send.h"
 
 /**
  * Message to transmit when http 1.1 request is received
@@ -278,187 +278,6 @@ send_param_adapter (struct MHD_Connection *connection,
 }
 
 
-#if defined(_MHD_HAVE_SENDFILE)
-/**
- * Function for sending responses backed by file FD.
- *
- * @param connection the MHD connection structure
- * @return actual number of bytes sent
- */
-static ssize_t
-sendfile_adapter (struct MHD_Connection *connection)
-{
-  ssize_t ret;
-  const int file_fd = connection->response->fd;
-  uint64_t left;
-  uint64_t offsetu64;
-#ifndef HAVE_SENDFILE64
-  const uint64_t max_off_t = (uint64_t)OFF_T_MAX;
-#else  /* HAVE_SENDFILE64 */
-  const uint64_t max_off_t = (uint64_t)OFF64_T_MAX;
-#endif /* HAVE_SENDFILE64 */
-#ifdef MHD_LINUX_SOLARIS_SENDFILE
-#ifndef HAVE_SENDFILE64
-  off_t offset;
-#else  /* HAVE_SENDFILE64 */
-  off64_t offset;
-#endif /* HAVE_SENDFILE64 */
-#endif /* MHD_LINUX_SOLARIS_SENDFILE */
-#ifdef HAVE_FREEBSD_SENDFILE
-  off_t sent_bytes;
-  int flags = 0;
-#endif
-#ifdef HAVE_DARWIN_SENDFILE
-  off_t len;
-#endif /* HAVE_DARWIN_SENDFILE */
-  const bool used_thr_p_c = (0 != (connection->daemon->options & MHD_USE_THREAD_PER_CONNECTION));
-  const size_t chunk_size = used_thr_p_c ? MHD_SENFILE_CHUNK_THR_P_C_ : MHD_SENFILE_CHUNK_;
-  size_t send_size = 0;
-  mhd_assert (MHD_resp_sender_sendfile == connection->resp_sender);
-
-  offsetu64 = connection->response_write_position + connection->response->fd_off;
-  left = connection->response->total_size - connection->response_write_position;
-  /* Do not allow system to stick sending on single fast connection:
-   * use 128KiB chunks (2MiB for thread-per-connection). */
-  send_size = (left > chunk_size) ? chunk_size : (size_t) left;
-  if (max_off_t < offsetu64)
-    { /* Retry to send with standard 'send()'. */
-      connection->resp_sender = MHD_resp_sender_std;
-      return MHD_ERR_AGAIN_;
-    }
-#ifdef MHD_LINUX_SOLARIS_SENDFILE
-#ifndef HAVE_SENDFILE64
-  offset = (off_t) offsetu64;
-  ret = sendfile (connection->socket_fd,
-                  file_fd,
-                  &offset,
-                  send_size);
-#else  /* HAVE_SENDFILE64 */
-  offset = (off64_t) offsetu64;
-  ret = sendfile64 (connection->socket_fd,
-                    file_fd,
-                    &offset,
-                    send_size);
-#endif /* HAVE_SENDFILE64 */
-  if (0 > ret)
-    {
-      const int err = MHD_socket_get_error_();
-      if (MHD_SCKT_ERR_IS_EAGAIN_(err))
-        {
-#ifdef EPOLL_SUPPORT
-          /* EAGAIN --- no longer write-ready */
-          connection->epoll_state &= ~MHD_EPOLL_STATE_WRITE_READY;
-#endif /* EPOLL_SUPPORT */
-          return MHD_ERR_AGAIN_;
-        }
-      if (MHD_SCKT_ERR_IS_EINTR_ (err))
-        return MHD_ERR_AGAIN_;
-#ifdef HAVE_LINUX_SENDFILE
-      if (MHD_SCKT_ERR_IS_(err,
-                           MHD_SCKT_EBADF_))
-        return MHD_ERR_BADF_;
-      /* sendfile() failed with EINVAL if mmap()-like operations are not
-         supported for FD or other 'unusual' errors occurred, so we should try
-         to fall back to 'SEND'; see also this thread for info on
-         odd libc/Linux behavior with sendfile:
-         http://lists.gnu.org/archive/html/libmicrohttpd/2011-02/msg00015.html */
-      connection->resp_sender = MHD_resp_sender_std;
-      return MHD_ERR_AGAIN_;
-#else  /* HAVE_SOLARIS_SENDFILE */
-      if ( (EAFNOSUPPORT == err) ||
-           (EINVAL == err) ||
-           (EOPNOTSUPP == err) )
-        { /* Retry with standard file reader. */
-          connection->resp_sender = MHD_resp_sender_std;
-          return MHD_ERR_AGAIN_;
-        }
-      if ( (ENOTCONN == err) ||
-           (EPIPE == err) )
-        {
-          return MHD_ERR_CONNRESET_;
-        }
-      return MHD_ERR_BADF_; /* Fail hard */
-#endif /* HAVE_SOLARIS_SENDFILE */
-    }
-#ifdef EPOLL_SUPPORT
-  else if (send_size > (size_t)ret)
-        connection->epoll_state &= ~MHD_EPOLL_STATE_WRITE_READY;
-#endif /* EPOLL_SUPPORT */
-#elif defined(HAVE_FREEBSD_SENDFILE)
-#ifdef SF_FLAGS
-  flags = used_thr_p_c ?
-      freebsd_sendfile_flags_thd_p_c_ : freebsd_sendfile_flags_;
-#endif /* SF_FLAGS */
-  if (0 != sendfile (file_fd,
-                     connection->socket_fd,
-                     (off_t) offsetu64,
-                     send_size,
-                     NULL,
-                     &sent_bytes,
-                     flags))
-    {
-      const int err = MHD_socket_get_error_();
-      if (MHD_SCKT_ERR_IS_EAGAIN_(err) ||
-          MHD_SCKT_ERR_IS_EINTR_(err) ||
-          EBUSY == err)
-        {
-          mhd_assert (SSIZE_MAX >= sent_bytes);
-          if (0 != sent_bytes)
-            return (ssize_t)sent_bytes;
-
-          return MHD_ERR_AGAIN_;
-        }
-      /* Some unrecoverable error. Possibly file FD is not suitable
-       * for sendfile(). Retry with standard send(). */
-      connection->resp_sender = MHD_resp_sender_std;
-      return MHD_ERR_AGAIN_;
-    }
-  mhd_assert (0 < sent_bytes);
-  mhd_assert (SSIZE_MAX >= sent_bytes);
-  ret = (ssize_t)sent_bytes;
-#elif defined(HAVE_DARWIN_SENDFILE)
-  len = (off_t)send_size; /* chunk always fit */
-  if (0 != sendfile (file_fd,
-                     connection->socket_fd,
-                     (off_t) offsetu64,
-                     &len,
-                     NULL,
-                     0))
-    {
-      const int err = MHD_socket_get_error_();
-      if (MHD_SCKT_ERR_IS_EAGAIN_(err) ||
-          MHD_SCKT_ERR_IS_EINTR_(err))
-        {
-          mhd_assert (0 <= len);
-          mhd_assert (SSIZE_MAX >= len);
-          mhd_assert (send_size >= (size_t)len);
-          if (0 != len)
-            return (ssize_t)len;
-
-          return MHD_ERR_AGAIN_;
-        }
-      if (ENOTCONN == err ||
-          EPIPE == err)
-        return MHD_ERR_CONNRESET_;
-      if (ENOTSUP == err ||
-          EOPNOTSUPP == err)
-        { /* This file FD is not suitable for sendfile().
-           * Retry with standard send(). */
-          connection->resp_sender = MHD_resp_sender_std;
-          return MHD_ERR_AGAIN_;
-        }
-      return MHD_ERR_BADF_; /* Return hard error. */
-    }
-  mhd_assert (0 <= len);
-  mhd_assert (SSIZE_MAX >= len);
-  mhd_assert (send_size >= (size_t)len);
-  ret = (ssize_t)len;
-#endif /* HAVE_FREEBSD_SENDFILE */
-  return ret;
-}
-#endif /* _MHD_HAVE_SENDFILE */
-
-
 /**
  * Check whether is possible to force push socket buffer content as
  * partial packet.
@@ -501,89 +320,6 @@ _MHD_static_inline bool
 socket_start_extra_buffering (struct MHD_Connection *connection)
 {
   mhd_assert(NULL != connection);
-#if defined(TCP_NODELAY)
-  if (connection->sk_tcp_nodelay_on)
-    {
-      const MHD_SCKT_OPT_BOOL_ off_val = 0;
-      /* Enable Nagle's algorithm */
-      /* TCP_NODELAY may interfere with TCP_NOPUSH */
-      if (0 == setsockopt (connection->socket_fd,
-                           IPPROTO_TCP,
-                           TCP_NODELAY,
-                           (const void *) &off_val,
-                           sizeof (off_val)))
-        {
-          connection->sk_tcp_nodelay_on = false;
-        }
-    }
-#endif /* TCP_NODELAY */
-
-#if defined(MHD_TCP_CORK_NOPUSH)
-  if (!connection->sk_tcp_cork_nopush_on)
-    {
-      const MHD_SCKT_OPT_BOOL_ on_val = 1;
-      /* Buffer data before sending (TCP_CORK) or
-       * Send only full frames (TCP_NOPUSH) */
-      if (0 == setsockopt (connection->socket_fd,
-                           IPPROTO_TCP,
-                           MHD_TCP_CORK_NOPUSH,
-                           (const void *) &on_val,
-                           sizeof (on_val)))
-        {
-          connection->sk_tcp_cork_nopush_on = true;
-        }
-    }
-#endif /* MHD_TCP_CORK_NOPUSH */
-
-#if defined(TCP_NODELAY)
-   return connection->sk_tcp_cork_nopush_on && !connection->sk_tcp_nodelay_on;
-#else  /* ! TCP_NODELAY */
-   return connection->sk_tcp_cork_nopush_on;
-#endif /* ! TCP_NODELAY */
-}
-
-
-/**
- * Activate no buffering mode (no delay sending) on connection socket.
- *
- * @param connection connection to be processed
- * @return true on success, false otherwise
- */
-_MHD_static_inline bool
-socket_start_no_buffering (struct MHD_Connection *connection)
-{
-#if defined(MHD_TCP_CORK_NOPUSH)
-  if (connection->sk_tcp_cork_nopush_on)
-    {
-      const MHD_SCKT_OPT_BOOL_ off_val = 0;
-      /* Disable extra buffering */
-      if (0 == setsockopt (connection->socket_fd,
-                           IPPROTO_TCP,
-                           MHD_TCP_CORK_NOPUSH,
-                           (const void *) &off_val,
-                           sizeof (off_val)))
-        {
-          connection->sk_tcp_cork_nopush_on = false;
-        }
-    }
-#endif /* MHD_TCP_CORK_NOPUSH */
-
-#if defined(TCP_NODELAY)
-  if (!connection->sk_tcp_nodelay_on)
-    {
-      const MHD_SCKT_OPT_BOOL_ on_val = 1;
-      /* Enable sending without delay */
-      if (0 == setsockopt (connection->socket_fd,
-                           IPPROTO_TCP,
-                           TCP_NODELAY,
-                           (const void *) &on_val,
-                           sizeof (on_val)))
-        {
-          connection->sk_tcp_nodelay_on = true;
-        }
-    }
-#endif /* TCP_NODELAY */
-  return connection->sk_tcp_nodelay_on && !connection->sk_tcp_cork_nopush_on;
 }
 
 
@@ -601,21 +337,7 @@ socket_start_no_buffering_flush (struct MHD_Connection *connection)
 #if defined(TCP_NOPUSH) && !defined(TCP_CORK)
   const int dummy = 0;
 #endif /* !TCP_CORK */
-#if defined(TCP_CORK) || (defined(__FreeBSD__) &&  __FreeBSD__+0 >= 9)
-  const MHD_SCKT_OPT_BOOL_ off_val = 0;
-  /* Switching off TCP_CORK flush buffer even
-   * if TCP_CORK was not enabled */
-  if (0 == setsockopt (connection->socket_fd,
-                       IPPROTO_TCP,
-                       MHD_TCP_CORK_NOPUSH,
-                       (const void *) &off_val,
-                       sizeof (off_val)))
-    {
-      connection->sk_tcp_cork_nopush_on = false;
-    }
-#endif /* MHD_TCP_CORK_NOPUSH */
 
-  res = socket_start_no_buffering (connection);
 #if defined(__FreeBSD__) &&  __FreeBSD__+0 >= 9
   /* FreeBSD do not need zero-send for flushing starting from version 9 */
 #elif defined(TCP_NOPUSH) && !defined(TCP_CORK)
@@ -631,51 +353,6 @@ socket_start_no_buffering_flush (struct MHD_Connection *connection)
 
 
 /**
- * Activate normal buffering mode on connection socket.
- *
- * @param connection connection to be processed
- * @return true on success, false otherwise
- */
-_MHD_static_inline bool
-socket_start_normal_buffering (struct MHD_Connection *connection)
-{
-  mhd_assert(NULL != connection);
-#if defined(MHD_TCP_CORK_NOPUSH)
-  if (connection->sk_tcp_cork_nopush_on)
-    {
-      const MHD_SCKT_OPT_BOOL_ off_val = 0;
-      /* Disable extra buffering */
-      if (0 == setsockopt (connection->socket_fd,
-                           IPPROTO_TCP,
-                           MHD_TCP_CORK_NOPUSH,
-                           (const void *) &off_val,
-                           sizeof (off_val)))
-        {
-          connection->sk_tcp_cork_nopush_on = false;
-        }
-    }
-#endif /* MHD_TCP_CORK_NOPUSH */
-
-#if defined(TCP_NODELAY)
-  if (connection->sk_tcp_nodelay_on)
-    {
-      const MHD_SCKT_OPT_BOOL_ off_val = 0;
-      /* Enable Nagle's algorithm */
-      if (0 == setsockopt (connection->socket_fd,
-                           IPPROTO_TCP,
-                           TCP_NODELAY,
-                           (const void *) &off_val,
-                           sizeof (off_val)))
-        {
-          connection->sk_tcp_nodelay_on = false;
-        }
-    }
-#endif /* TCP_NODELAY */
-  return !connection->sk_tcp_nodelay_on && !connection->sk_tcp_cork_nopush_on;
-}
-
-
-/**
  * Get all of the headers from the request.
  *
  * @param connection connection to get values from
@@ -3315,11 +2992,12 @@ MHD_connection_handle_write (struct MHD_Connection *connection)
     case MHD_CONNECTION_HEADERS_PROCESSED:
       return;
     case MHD_CONNECTION_CONTINUE_SENDING:
-      ret = connection->send_cls (connection,
-                                  &HTTP_100_CONTINUE
-                                  [connection->continue_message_write_offset],
-                                  MHD_STATICSTR_LEN_ (HTTP_100_CONTINUE) -
-                                  connection->continue_message_write_offset);
+      ret = MHD_send_on_connection_ (connection,
+                                     &HTTP_100_CONTINUE
+                                     [connection->continue_message_write_offset],
+                                     MHD_STATICSTR_LEN_ (HTTP_100_CONTINUE) -
+                                     connection->continue_message_write_offset,
+                                     MHD_SSO_NO_CORK);
       if (ret < 0)
         {
           if (MHD_ERR_AGAIN_ == ret)
@@ -3349,26 +3027,55 @@ MHD_connection_handle_write (struct MHD_Connection *connection)
       mhd_assert (0);
       return;
     case MHD_CONNECTION_HEADERS_SENDING:
-      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)
-        {
-          if (MHD_ERR_AGAIN_ == ret)
+      {
+        const size_t wb_ready = connection->write_buffer_append_offset -
+          connection->write_buffer_send_offset;
+
+        /* if the response body is not available, we use MHD_send_on_connection_() */
+        if (NULL != connection->response->crc)
+          {
+            ret = MHD_send_on_connection_ (connection,
+                                           &connection->write_buffer
+                                           [connection->write_buffer_send_offset],
+                                           wb_ready,
+                                           MHD_SSO_MAY_CORK);
+          }
+        else
+          {
+            ret = MHD_send_on_connection2_ (connection,
+                                            &connection->write_buffer
+                                            [connection->write_buffer_send_offset],
+                                            wb_ready,
+                                            connection->response->data,
+                                            connection->response->data_buffer_size);
+          }
+
+        if (ret < 0)
+          {
+            if (MHD_ERR_AGAIN_ == ret)
+              return;
+            CONNECTION_CLOSE_ERROR (connection,
+                                    _("Connection was closed while sending response headers.\n"));
             return;
-          CONNECTION_CLOSE_ERROR (connection,
-                                  _("Connection was closed while sending response headers.\n"));
+          }
+        if (ret > wb_ready)
+          {
+            mhd_assert (NULL == connection->repsonse->crc);
+            /* We sent not just header data but also some response data,
+               update both offsets! */
+            connection->write_buffer_send_offset += wb_ready;
+            ret -= wb_ready;
+            connection->response_write_position += ret;
+          }
+        else
+          connection->write_buffer_send_offset += ret;
+        MHD_update_last_activity_ (connection);
+        if (MHD_CONNECTION_HEADERS_SENDING != connection->state)
           return;
-        }
-      connection->write_buffer_send_offset += ret;
-      MHD_update_last_activity_ (connection);
-      if (MHD_CONNECTION_HEADERS_SENDING != connection->state)
+        check_write_done (connection,
+                          MHD_CONNECTION_HEADERS_SENT);
         return;
-      check_write_done (connection,
-                        MHD_CONNECTION_HEADERS_SENT);
-      return;
+      }
     case MHD_CONNECTION_HEADERS_SENT:
       return;
     case MHD_CONNECTION_NORMAL_BODY_READY:
@@ -3390,7 +3097,7 @@ MHD_connection_handle_write (struct MHD_Connection *connection)
 #if defined(_MHD_HAVE_SENDFILE)
           if (MHD_resp_sender_sendfile == connection->resp_sender)
             {
-              ret = sendfile_adapter (connection);
+              ret = MHD_send_sendfile_ (connection);
             }
           else
 #else  /* ! _MHD_HAVE_SENDFILE */
@@ -3401,11 +3108,12 @@ MHD_connection_handle_write (struct MHD_Connection *connection)
                                   - response->data_start;
               if (data_write_offset > (uint64_t)SIZE_MAX)
                 MHD_PANIC (_("Data offset exceeds limit"));
-              ret = connection->send_cls (connection,
-                                          &response->data
-                                          [(size_t)data_write_offset],
-                                          response->data_size -
-                                          (size_t)data_write_offset);
+              ret = MHD_send_on_connection_ (connection,
+                                             &response->data
+                                             [(size_t)data_write_offset],
+                                             response->data_size -
+                                             (size_t)data_write_offset,
+                                             MHD_SSO_NO_CORK);
 #if DEBUG_SEND_DATA
               if (ret > 0)
                 fprintf (stderr,
@@ -3444,11 +3152,12 @@ MHD_connection_handle_write (struct MHD_Connection *connection)
       mhd_assert (0);
       return;
     case MHD_CONNECTION_CHUNKED_BODY_READY:
-      ret = connection->send_cls (connection,
-                                  &connection->write_buffer
-                                  [connection->write_buffer_send_offset],
-                                  connection->write_buffer_append_offset -
-                                    connection->write_buffer_send_offset);
+      ret = MHD_send_on_connection_ (connection,
+                                     &connection->write_buffer
+                                     [connection->write_buffer_send_offset],
+                                     connection->write_buffer_append_offset -
+                                     connection->write_buffer_send_offset,
+                                     MHD_SSO_NO_CORK);
       if (ret < 0)
         {
           if (MHD_ERR_AGAIN_ == ret)
@@ -3472,11 +3181,12 @@ MHD_connection_handle_write (struct MHD_Connection *connection)
       mhd_assert (0);
       return;
     case MHD_CONNECTION_FOOTERS_SENDING:
-      ret = connection->send_cls (connection,
-                                  &connection->write_buffer
-                                  [connection->write_buffer_send_offset],
-                                  connection->write_buffer_append_offset -
-                                    connection->write_buffer_send_offset);
+      ret = MHD_send_on_connection_ (connection,
+                                     &connection->write_buffer
+                                     [connection->write_buffer_send_offset],
+                                     connection->write_buffer_append_offset -
+                                     connection->write_buffer_send_offset,
+                                     MHD_SSO_HDR_CORK);
       if (ret < 0)
         {
           if (MHD_ERR_AGAIN_ == ret)
@@ -3723,11 +3433,6 @@ MHD_connection_handle_idle (struct MHD_Connection *connection)
           if (need_100_continue (connection))
             {
               connection->state = MHD_CONNECTION_CONTINUE_SENDING;
-              if (socket_flush_possible (connection))
-                socket_start_extra_buffering (connection);
-              else
-                socket_start_no_buffering (connection);
-
               break;
             }
           if ( (NULL != connection->response) &&
@@ -3752,9 +3457,7 @@ MHD_connection_handle_idle (struct MHD_Connection *connection)
             {
               connection->state = MHD_CONNECTION_CONTINUE_SENT;
               if (socket_flush_possible (connection))
-                socket_start_no_buffering_flush (connection);
-              else
-                socket_start_normal_buffering (connection);
+                socket_start_no_buffering_flush (connection); /* REMOVE: Dead */
 
               continue;
             }
@@ -3855,11 +3558,6 @@ MHD_connection_handle_idle (struct MHD_Connection *connection)
               continue;
             }
           connection->state = MHD_CONNECTION_HEADERS_SENDING;
-          if (socket_flush_possible (connection))
-            socket_start_extra_buffering (connection);
-          else
-            socket_start_no_buffering (connection);
-
           break;
         case MHD_CONNECTION_HEADERS_SENDING:
           /* no default action */
@@ -3867,12 +3565,11 @@ MHD_connection_handle_idle (struct MHD_Connection *connection)
         case MHD_CONNECTION_HEADERS_SENT:
           /* Some clients may take some actions right after header receive */
           if (socket_flush_possible (connection))
-            socket_start_no_buffering_flush (connection);
+            socket_start_no_buffering_flush (connection); /* REMOVE: Dead */
 
 #ifdef UPGRADE_SUPPORT
           if (NULL != connection->response->upgrade_handler)
             {
-              socket_start_normal_buffering (connection);
               connection->state = MHD_CONNECTION_UPGRADE;
               /* This connection is "upgraded".  Pass socket to application. */
               if (MHD_YES !=
@@ -3894,10 +3591,6 @@ MHD_connection_handle_idle (struct MHD_Connection *connection)
               continue;
             }
 #endif /* UPGRADE_SUPPORT */
-          if (socket_flush_possible (connection))
-            socket_start_extra_buffering (connection);
-          else
-            socket_start_normal_buffering (connection);
 
           if (connection->have_chunked_upload)
             connection->state = MHD_CONNECTION_CHUNKED_BODY_UNREADY;
@@ -3929,8 +3622,7 @@ MHD_connection_handle_idle (struct MHD_Connection *connection)
 #endif
               connection->state = MHD_CONNECTION_NORMAL_BODY_READY;
               /* Buffering for flushable socket was already enabled*/
-              if (socket_flush_possible (connection))
-                socket_start_no_buffering (connection);
+
               break;
             }
           /* mutex was already unlocked by "try_ready_normal_body */
@@ -3963,8 +3655,7 @@ MHD_connection_handle_idle (struct MHD_Connection *connection)
 #endif
               connection->state = MHD_CONNECTION_CHUNKED_BODY_READY;
               /* Buffering for flushable socket was already enabled */
-              if (socket_flush_possible (connection))
-                socket_start_no_buffering (connection);
+
               continue;
             }
           /* mutex was already unlocked by try_ready_chunked_body */
@@ -3998,9 +3689,7 @@ MHD_connection_handle_idle (struct MHD_Connection *connection)
             continue;
           }
           if (socket_flush_possible (connection))
-            socket_start_no_buffering_flush (connection);
-          else
-            socket_start_normal_buffering (connection);
+            socket_start_no_buffering_flush (connection); /* REMOVE: Dead */
 
           MHD_destroy_response (connection->response);
           connection->response = NULL;
@@ -4028,8 +3717,7 @@ MHD_connection_handle_idle (struct MHD_Connection *connection)
           else
             {
               /* can try to keep-alive */
-              if (socket_flush_possible (connection))
-                socket_start_normal_buffering (connection);
+
               connection->version = NULL;
               connection->state = MHD_CONNECTION_INIT;
               connection->last = NULL;