5 files changed, 521 insertions, 5 deletions

diff --git a/src/microhttpd/connection.c b/src/microhttpd/connection.c
index 25788414..7f2dcd75 100644
--- a/src/microhttpd/connection.c
+++ b/src/microhttpd/connection.c
@@ -794,11 +794,33 @@ try_ready_normal_body (struct MHD_Connection *connection)
   struct MHD_Response *response;
 
   response = connection->response;
-  if (NULL == response->crc)
-    return MHD_YES;
   if ( (0 == response->total_size) ||
        (connection->response_write_position == response->total_size) )
     return MHD_YES; /* 0-byte response is always ready */
+  if (NULL != response->data_iov)
+  {
+    size_t copy_size;
+    if (NULL != connection->resp_iov.iov)
+      return MHD_YES;
+
+    copy_size = response->data_iovcnt * sizeof(MHD_iovec_);
+    connection->resp_iov.iov = MHD_pool_allocate (connection->pool, copy_size,
+                                                  true);
+    if (NULL == connection->resp_iov.iov)
+    {
+      MHD_mutex_unlock_chk_ (&response->mutex);
+      /* not enough memory */
+      CONNECTION_CLOSE_ERROR (connection,
+                              _ ("Closing connection (out of memory).\n"));
+      return MHD_NO;
+    }
+    memcpy (connection->resp_iov.iov, response->data_iov, copy_size);
+    connection->resp_iov.cnt = response->data_iovcnt;
+    connection->resp_iov.sent = 0;
+    return MHD_YES;
+  }
+  if (NULL == response->crc)
+    return MHD_YES;
   if ( (response->data_start <=
         connection->response_write_position) &&
        (response->data_size + response->data_start >
@@ -2935,6 +2957,7 @@ MHD_connection_handle_write (struct MHD_Connection *connection)
                     connection->response_write_position) );
 
       if ( (NULL == resp->crc) &&
+           (NULL == resp->data_iov) &&
            (0 == connection->response_write_position) )
       {
         mhd_assert (resp->total_size >= resp->data_size);
@@ -3017,12 +3040,16 @@ MHD_connection_handle_write (struct MHD_Connection *connection)
 #if defined(_MHD_HAVE_SENDFILE)
       if (MHD_resp_sender_sendfile == connection->resp_sender)
       {
+        mhd_assert (NULL == response->data_iov);
         ret = MHD_send_sendfile_ (connection);
       }
+      else /* combined with the next 'if' */
+#endif /* _MHD_HAVE_SENDFILE */
+      if (NULL != response->data_iov)
+      {
+        ret = MHD_send_iovec_ (connection, &connection->resp_iov, true);
+      }
       else
-#else  /* ! _MHD_HAVE_SENDFILE */
-      if (1)
-#endif /* ! _MHD_HAVE_SENDFILE */
       {
         data_write_offset = connection->response_write_position
                             - response->data_start;
@@ -3674,6 +3701,8 @@ MHD_connection_handle_idle (struct MHD_Connection *connection)
       connection->write_buffer_size = 0;
       connection->write_buffer_send_offset = 0;
       connection->write_buffer_append_offset = 0;
+      /* iov (if any) was deallocated by MHD_pool_reset */
+      memset (&connection->resp_iov, 0, sizeof(connection->resp_iov));
       continue;
     case MHD_CONNECTION_CLOSED:
       cleanup_connection (connection);
diff --git a/src/microhttpd/internal.h b/src/microhttpd/internal.h
index f3c4cb1e..ba71d1eb 100644
--- a/src/microhttpd/internal.h
+++ b/src/microhttpd/internal.h
@@ -343,6 +343,57 @@ struct MHD_HTTP_Header
 };
 
 
+#if defined(MHD_WINSOCK_SOCKETS)
+/**
+ * Internally used I/O vector type for use with winsock.
+ * Binary matches system "WSABUF".
+ */
+typedef struct _MHD_W32_iovec
+{
+  unsigned long iov_len;
+  char *iov_base;
+} MHD_iovec_;
+#define MHD_IOV_ELMN_MAX_SIZE    ULONG_MAX
+#elif defined(HAVE_SENDMSG) || defined(HAVE_WRITEV)
+/**
+ * Internally used I/O vector type for use when writev or sendmsg
+ * is available. Matches system "struct iovec".
+ */
+typedef struct iovec MHD_iovec_;
+#define MHD_IOV_ELMN_MAX_SIZE    SIZE_MAX
+#else
+/**
+ * Internally used I/O vector type for use when writev or sendmsg
+ * is not available.
+ */
+typedef struct MHD_IoVec MHD_iovec_;
+#define MHD_IOV_ELMN_MAX_SIZE    SIZE_MAX
+#endif
+
+
+struct MHD_iovec_track_
+{
+  /**
+   * The copy of array of iovec elements.
+   * The copy of elements are updated during sending.
+   * The number of elements is not changed during lifetime.
+   */
+  MHD_iovec_ *iov;
+
+  /**
+   * The number of elements in @iov.
+   * This value is not changed during lifetime.
+   */
+  size_t cnt;
+
+  /**
+   * The number of sent elements.
+   * At the same time, it is the index of the next (or current) element
+   * to send.
+   */
+  size_t sent;
+};
+
 /**
  * Representation of a response.
  */
@@ -450,6 +501,15 @@ struct MHD_Response
    */
   bool is_pipe;
 
+  /**
+   * I/O vector used with MHD_create_response_from_iovec.
+   */
+  MHD_iovec_ *data_iov;
+
+  /**
+   * Number of elements in data_iov.
+   */
+  size_t data_iovcnt;
 };
 
 
@@ -873,6 +933,15 @@ struct MHD_Connection
    */
   uint64_t response_write_position;
 
+  /**
+   * The copy of iov response.
+   * Valid if iovec response is used.
+   * Updated during send.
+   * Members are allocated in the pool.
+   */
+  struct MHD_iovec_track_ resp_iov;
+
+
 #if defined(_MHD_HAVE_SENDFILE)
   enum MHD_resp_sender_
   {
diff --git a/src/microhttpd/mhd_send.c b/src/microhttpd/mhd_send.c
index 0d979c0a..fd67300c 100644
--- a/src/microhttpd/mhd_send.c
+++ b/src/microhttpd/mhd_send.c
@@ -51,6 +51,15 @@
 
 #include "mhd_limits.h"
 
+#ifdef MHD_VECT_SEND
+#if (! defined (HAVE_SENDMSG) || ! defined(MSG_NOSIGNAL)) && \
+  defined (MHD_SEND_SPIPE_SUPPRESS_POSSIBLE) && \
+  defined (MHD_SEND_SPIPE_SUPPRESS_NEEDED)
+#define _MHD_VECT_SEND_NEEDS_SPIPE_SUPPRESSED 1
+#endif /* (!HAVE_SENDMSG || !MSG_NOSIGNAL) &&
+          MHD_SEND_SPIPE_SUPPRESS_POSSIBLE && MHD_SEND_SPIPE_SUPPRESS_NEEDED */
+#endif /* MHD_VECT_SEND */
+
 /**
  * sendfile() chuck size
  */
@@ -1243,3 +1252,237 @@ MHD_send_sendfile_ (struct MHD_Connection *connection)
 
 
 #endif /* _MHD_HAVE_SENDFILE */
+
+#if defined(MHD_VECT_SEND)
+
+
+/**
+ * Function sends iov data by system sendmsg or writev function.
+ *
+ * Connection must be in non-TLS (non-HTTPS) mode.
+ *
+ * @param connection the MHD connection structure
+ * @param r_iov the pointer to iov data structure with tracking
+ * @param push_data set to true to force push the data to the network from
+ *                  system buffers (usually set for the last piece of data),
+ *                  set to false to prefer holding incomplete network packets
+ *                  (more data will be send for the same reply).
+ * @return actual number of bytes sent
+ */
+static ssize_t
+send_iov_nontls (struct MHD_Connection *connection,
+                 struct MHD_iovec_track_ *const r_iov,
+                 bool push_data)
+{
+  ssize_t res;
+  ssize_t total_sent;
+  size_t items_to_send;
+#ifdef HAVE_SENDMSG
+  struct msghdr msg;
+#elif defined(MHD_WINSOCK_SOCKETS)
+  DWORD bytes_sent;
+  DWORD cnt_w;
+#endif /* MHD_WINSOCK_SOCKETS */
+
+  mhd_assert (0 == (connection->daemon->options & MHD_USE_TLS));
+
+  if ( (MHD_INVALID_SOCKET == connection->socket_fd) ||
+       (MHD_CONNECTION_CLOSED == connection->state) )
+  {
+    return MHD_ERR_NOTCONN_;
+  }
+
+  pre_send_setopt (connection, false, push_data);
+
+  items_to_send = r_iov->cnt - r_iov->sent;
+#ifdef HAVE_SENDMSG
+  memset (&msg, 0, sizeof(struct msghdr));
+  msg.msg_iov = r_iov->iov + r_iov->sent;
+  msg.msg_iovlen = items_to_send;
+
+  res = sendmsg (connection->socket_fd, &msg, MSG_NOSIGNAL_OR_ZERO);
+#elif defined(HAVE_WRITEV)
+  res = writev (connection->socket_fd, r_iov->iov + r_iov->sent,
+                items_to_send);
+#elif defined(MHD_WINSOCK_SOCKETS)
+#ifdef _WIN64
+  cnt_w = (items_to_send > UINT32_MAX) ? UINT32_MAX : (DWORD) items_to_send;
+#else  /* ! _WIN64 */
+  cnt_w = (DWORD) items_to_send;
+#endif /* ! _WIN64 */
+  if (0 == WSASend (connection->socket_fd,
+                    (LPWSABUF) (r_iov->iov + r_iov->sent),
+                    cnt_w,
+                    &bytes_sent, 0, NULL, NULL))
+    res = (ssize_t) bytes_sent;
+  else
+    res = -1;
+#else /* !HAVE_SENDMSG && !HAVE_WRITEV && !MHD_WINSOCK_SOCKETS */
+#error No vector-send function available
+#endif
+
+  if (0 > res)
+  {
+    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_;
+    if (MHD_SCKT_ERR_IS_ (err, MHD_SCKT_ECONNRESET_))
+      return MHD_ERR_CONNRESET_;
+    /* Treat any other error as hard error. */
+    return MHD_ERR_NOTCONN_;
+  }
+
+  /* Some data has been sent */
+  total_sent = res;
+  /* Adjust the internal tracking information for the iovec to
+   * take this last send into account. */
+  while ((0 != res) && (r_iov->iov[r_iov->sent].iov_len <= (size_t) res))
+  {
+    res -= r_iov->iov[r_iov->sent].iov_len;
+    r_iov->sent++; /* The iov element has been completely sent */
+    mhd_assert ((r_iov->cnt > r_iov->sent) || (0 == res));
+  }
+
+  if (r_iov->cnt == r_iov->sent)
+    post_send_setopt (connection, false, push_data);
+  else
+  {
+#ifdef EPOLL_SUPPORT
+    connection->epoll_state &= ~MHD_EPOLL_STATE_WRITE_READY;
+#endif /* EPOLL_SUPPORT */
+    if (0 != res)
+    {
+      mhd_assert (r_iov->cnt > r_iov->sent);
+      /* The last iov element has been partially sent */
+      r_iov->iov[r_iov->sent].iov_base =
+        (void*) ((uint8_t*) r_iov->iov[r_iov->sent].iov_base + (size_t) res);
+      r_iov->iov[r_iov->sent].iov_len -= res;
+    }
+  }
+
+  return total_sent;
+}
+
+
+#endif /* MHD_VECT_SEND */
+
+#if ! defined(MHD_VECT_SEND) || defined(HTTPS_SUPPORT) || \
+  defined(_MHD_VECT_SEND_NEEDS_SPIPE_SUPPRESSED)
+
+
+/**
+ * Function sends iov data by sending buffers one-by-one by standard
+ * data send function.
+ *
+ * Connection could be in HTTPS or non-HTTPS mode.
+ *
+ * @param connection the MHD connection structure
+ * @param r_iov the pointer to iov data structure with tracking
+ * @param push_data set to true to force push the data to the network from
+ *                  system buffers (usually set for the last piece of data),
+ *                  set to false to prefer holding incomplete network packets
+ *                  (more data will be send for the same reply).
+ * @return actual number of bytes sent
+ */
+static ssize_t
+send_iov_emu (struct MHD_Connection *connection,
+              struct MHD_iovec_track_ *const r_iov,
+              bool push_data)
+{
+  const bool non_blk = connection->sk_nonblck;
+  size_t total_sent;
+  ssize_t res;
+
+  mhd_assert (NULL != r_iov->iov);
+  total_sent = 0;
+  do
+  {
+    if ((size_t) SSIZE_MAX - total_sent < r_iov->iov[r_iov->sent].iov_len)
+      return total_sent; /* return value would overflow */
+
+    res = MHD_send_data_ (connection,
+                          r_iov->iov[r_iov->sent].iov_base,
+                          r_iov->iov[r_iov->sent].iov_len,
+                          push_data && (r_iov->cnt == r_iov->sent + 1));
+    if (0 > res)
+    {
+      /* Result is an error */
+      if (0 == total_sent)
+        return res; /* Nothing was sent, return result as is */
+
+      if (MHD_ERR_AGAIN_ == res)
+        return total_sent; /* Some data has been sent, return the amount */
+
+      return res; /* Any kind of a hard error */
+    }
+
+    total_sent += (size_t) res;
+
+    if (r_iov->iov[r_iov->sent].iov_len != (size_t) res)
+    {
+      /* Incomplete buffer has been sent.
+       * Adjust buffer of the last element. */
+      r_iov->iov[r_iov->sent].iov_base =
+        (void*) ((uint8_t*) r_iov->iov[r_iov->sent].iov_base + (size_t) res);
+      r_iov->iov[r_iov->sent].iov_len -= res;
+
+      return total_sent;
+    }
+    /* The iov element has been completely sent */
+    r_iov->sent++;
+  } while ((r_iov->cnt > r_iov->sent) && (non_blk));
+
+  return (ssize_t) total_sent;
+}
+
+
+#endif /* !MHD_VECT_SEND || HTTPS_SUPPORT
+          || _MHD_VECT_SEND_NEEDS_SPIPE_SUPPRESSED */
+
+
+ssize_t
+MHD_send_iovec_ (struct MHD_Connection *connection,
+                 struct MHD_iovec_track_ *const r_iov,
+                 bool push_data)
+{
+#ifdef MHD_VECT_SEND
+#if defined(HTTPS_SUPPORT) || \
+  defined(_MHD_VECT_SEND_NEEDS_SPIPE_SUPPRESSED)
+  bool use_iov_send = true;
+#endif /* HTTPS_SUPPORT || _MHD_VECT_SEND_NEEDS_SPIPE_SUPPRESSED */
+#endif /* MHD_VECT_SEND */
+
+  mhd_assert (NULL != connection->resp_iov.iov);
+  mhd_assert (NULL != connection->response->data_iov);
+  mhd_assert (connection->resp_iov.cnt > connection->resp_iov.sent);
+#ifdef MHD_VECT_SEND
+#if defined(HTTPS_SUPPORT) || \
+  defined(_MHD_VECT_SEND_NEEDS_SPIPE_SUPPRESSED)
+#ifdef HTTPS_SUPPORT
+  use_iov_send = use_iov_send &&
+                 (0 == (connection->daemon->options & MHD_USE_TLS));
+#endif /* HTTPS_SUPPORT */
+#ifdef _MHD_VECT_SEND_NEEDS_SPIPE_SUPPRESSED
+  use_iov_send = use_iov_send && (connection->daemon->sigpipe_blocked ||
+                                  connection->sk_spipe_suppress);
+#endif /* _MHD_VECT_SEND_NEEDS_SPIPE_SUPPRESSED */
+  if (use_iov_send)
+#endif /* HTTPS_SUPPORT || _MHD_VECT_SEND_NEEDS_SPIPE_SUPPRESSED */
+  return send_iov_nontls (connection, r_iov, push_data);
+#endif /* MHD_VECT_SEND */
+
+#if ! defined(MHD_VECT_SEND) || defined(HTTPS_SUPPORT) || \
+  defined(_MHD_VECT_SEND_NEEDS_SPIPE_SUPPRESSED)
+  return send_iov_emu (connection, r_iov, push_data);
+#endif /* !MHD_VECT_SEND || HTTPS_SUPPORT
+          || _MHD_VECT_SEND_NEEDS_SPIPE_SUPPRESSED */
+}
diff --git a/src/microhttpd/mhd_send.h b/src/microhttpd/mhd_send.h
index 54b5c1fe..d4ee8de7 100644
--- a/src/microhttpd/mhd_send.h
+++ b/src/microhttpd/mhd_send.h
@@ -41,6 +41,11 @@
 #include "connection_https.h"
 #endif
 
+#if defined(HAVE_SENDMSG) || defined(HAVE_WRITEV) || \
+  defined(MHD_WINSOCK_SOCKETS)
+#define MHD_VECT_SEND 1
+#endif /* HAVE_SENDMSG || HAVE_WRITEV || MHD_WINSOCK_SOCKETS */
+
 #ifdef HAVE_FREEBSD_SENDFILE
 /**
  * Initialises static variables
@@ -125,4 +130,21 @@ MHD_connection_set_nodelay_state_ (struct MHD_Connection *connection,
                                    bool nodelay_state);
 
 
+/**
+ * Function for sending responses backed by a an array of memory buffers.
+ *
+ * @param connection the MHD connection structure
+ * @param r_iov the pointer to iov response structure with tracking
+ * @param push_data set to true to force push the data to the network from
+ *                  system buffers (usually set for the last piece of data),
+ *                  set to false to prefer holding incomplete network packets
+ *                  (more data will be send for the same reply).
+ * @return actual number of bytes sent
+ */
+ssize_t
+MHD_send_iovec_ (struct MHD_Connection *connection,
+                 struct MHD_iovec_track_ *r_iov,
+                 bool push_data);
+
+
 #endif /* MHD_SEND_H */
diff --git a/src/microhttpd/response.c b/src/microhttpd/response.c
index 4ae46bf3..3dbcd245 100644
--- a/src/microhttpd/response.c
+++ b/src/microhttpd/response.c
@@ -846,6 +846,153 @@ MHD_create_response_from_buffer_with_free_callback (size_t size,
 }
 
 
+/**
+ * Create a response object from an array of memory buffers.
+ * The response object can be extended with header information and then be used
+ * any number of times.
+ *
+ * @param iov the array for response data buffers, an internal copy of this
+ *        will be made
+ * @param iovcnt the number of elements in @a iov
+ * @param free_cb the callback to clean up any data associated with @a iov when
+ *        the response is destroyed.
+ * @param cls the argument passed to @a free_cb
+ * @return NULL on error (i.e. invalid arguments, out of memory)
+ */
+_MHD_EXTERN struct MHD_Response *
+MHD_create_response_from_iovec (const struct MHD_IoVec *iov,
+                                int iovcnt,
+                                MHD_ContentReaderFreeCallback free_cb,
+                                void *cls)
+{
+  struct MHD_Response *response;
+
+  if ((NULL == iov) && (0 < iovcnt))
+    return NULL;
+
+  response = MHD_calloc_ (1, sizeof (struct MHD_Response));
+  if (NULL != response)
+  {
+    if (MHD_mutex_init_ (&response->mutex))
+    {
+      int i;
+      int i_cp; /**< Index in the copy of iov */
+      uint64_t total_size;
+      void *last_valid_buffer;
+
+      i_cp = 0;
+      total_size = 0;
+      last_valid_buffer = NULL;
+      /* Calculate final size, number of valid elements, and check 'iov' */
+      for (i = 0; iovcnt > i; ++i)
+      {
+#if defined(MHD_WINSOCK_SOCKETS) && defined(_WIN64)
+        int64_t i_add;
+#endif /* ! MHD_WINSOCK_SOCKETS && _WIN64 */
+        if (0 == iov[i].iov_len)
+          continue; /* skip zero-sized elements */
+
+        if (NULL == iov[i].iov_base)
+        {
+          i_cp = -1; /* error */
+          break;
+        }
+        if ( (total_size > (total_size + iov[i].iov_len)) ||
+             (INT_MAX == i_cp) ||
+             (SSIZE_MAX < iov[i].iov_len) )
+        {
+          i_cp = -1; /* overflow */
+          break;
+        }
+        last_valid_buffer = iov[i].iov_base;
+        total_size += iov[i].iov_len;
+#if defined(MHD_POSIX_SOCKETS) || ! defined(_WIN64)
+        i_cp++;
+#else  /* ! MHD_POSIX_SOCKETS && _WIN64 */
+        i_add = iov[i].iov_len / ULONG_MAX;
+        if (0 != iov[i].iov_len % ULONG_MAX)
+          i_add++;
+        if (INT_MAX < (i_add + i_cp))
+        {
+          i_cp = -1; /* overflow */
+          break;
+        }
+        i_cp += (int) i_add;
+#endif /* ! MHD_POSIX_SOCKETS && _WIN64 */
+      }
+      if (0 <= i_cp)
+      {
+        response->fd = -1;
+        response->reference_count = 1;
+        response->total_size = total_size;
+        response->crc_cls = cls;
+        response->crfc = free_cb;
+        if (1 < i_cp)
+        {
+          MHD_iovec_ *iov_copy;
+          int num_copy_elements = i_cp;
+
+          iov_copy = MHD_calloc_ (num_copy_elements, sizeof(MHD_iovec_));
+          if (NULL != iov_copy)
+          {
+            i_cp = 0;
+            for (i = 0; iovcnt > i; ++i)
+            {
+              size_t element_size;
+              uint8_t *buf;
+
+              if (0 == iov[i].iov_len)
+                continue; /* skip zero-sized elements */
+
+              buf = (uint8_t*) iov[i].iov_base;
+              element_size = iov[i].iov_len;
+#if defined(MHD_WINSOCK_SOCKETS) && defined(_WIN64)
+              while (ULONG_MAX < element_size)
+              {
+                iov_copy[i_cp].iov_base = (void*) buf;
+                iov_copy[i_cp].iov_len = ULONG_MAX;
+                buf += ULONG_MAX;
+                element_size -= ULONG_MAX;
+                i_cp++;
+              }
+#endif /* MHD_WINSOCK_SOCKETS && _WIN64 */
+              iov_copy[i_cp].iov_base = (void*) buf;
+              iov_copy[i_cp].iov_len = element_size;
+              i_cp++;
+            }
+
+            mhd_assert (num_copy_elements == i_cp);
+            response->data_iov = iov_copy;
+            response->data_iovcnt = i_cp;
+
+            return response;
+          }
+
+        }
+        else if (1 == i_cp)
+        {
+          mhd_assert (NULL != last_valid_buffer);
+          response->data = last_valid_buffer;
+          response->data_size = total_size;
+
+          return response;
+        }
+        else /* if (0 == i_nz) */
+        {
+          mhd_assert (0 == total_size);
+
+          return response;
+        }
+      }
+      /* Some error condition */
+      MHD_mutex_destroy_chk_ (&response->mutex);
+    }
+    free (response);
+  }
+  return NULL;
+}
+
+
 #ifdef UPGRADE_SUPPORT
 /**
  * This connection-specific callback is provided by MHD to
@@ -1287,6 +1434,12 @@ MHD_destroy_response (struct MHD_Response *response)
 #endif
   if (NULL != response->crfc)
     response->crfc (response->crc_cls);
+
+  if (NULL != response->data_iov)
+  {
+    free (response->data_iov);
+  }
+
   while (NULL != response->first_header)
   {
     pos = response->first_header;