allowing error signalling for chunked responses

6 files changed, 54 insertions, 18 deletions

diff --git a/src/daemon/connection.c b/src/daemon/connection.c
index cd8b6141..247ec178 100644
--- a/src/daemon/connection.c
+++ b/src/daemon/connection.c
@@ -357,14 +357,15 @@ try_ready_normal_body (struct MHD_Connection *connection)
                NULL
 #endif
                );
-  if (ret == -1)
+  if ( (ret == MHD_CONTENT_READER_END_OF_STREAM) ||
+       (ret == MHD_CONTENT_READER_END_WITH_ERROR) )
     {
       /* either error or http 1.0 transfer, close
          socket! */
 #if DEBUG_CLOSE
 #if HAVE_MESSAGES
       MHD_DLOG (connection->daemon, 
-                "Closing connection (end of response)\n");
+                "Closing connection (end of response or error)\n");
 #endif
 #endif
       response->total_size = connection->response_write_position;
@@ -444,7 +445,20 @@ try_ready_chunked_body (struct MHD_Connection *connection)
                            &connection->write_buffer[sizeof (cbuf)],
                            connection->write_buffer_size - sizeof (cbuf) - 2);
     }
-  if (ret == -1)
+  if (ret == MHD_CONTENT_READER_END_WITH_ERROR) 
+    {
+      /* error, close socket! */
+#if DEBUG_CLOSE
+#if HAVE_MESSAGES
+      MHD_DLOG (connection->daemon, 
+                "Closing connection (error generating response)\n");
+#endif
+#endif
+      response->total_size = connection->response_write_position;
+      connection_close_error (connection);
+      return MHD_NO;
+    }
+  if (ret == MHD_CONTENT_READER_END_OF_STREAM) 
     {
       /* end of message, signal other side! */
       strcpy (connection->write_buffer, "0\r\n");
diff --git a/src/examples/fileserver_example_dirs.c b/src/examples/fileserver_example_dirs.c
index 8c874994..836c0623 100644
--- a/src/examples/fileserver_example_dirs.c
+++ b/src/examples/fileserver_example_dirs.c
@@ -66,7 +66,7 @@ dir_reader (void *cls, uint64_t pos, char *buf, size_t max)
     {
       e = readdir (dir);
       if (e == NULL)
-        return -1;
+        return MHD_CONTENT_READER_END_OF_STREAM;
   } while (e->d_name[0] == '.');
   return snprintf (buf, max,
                    "<a href=\"/%s\">%s</a><br>",
diff --git a/src/examples/minimal_example_comet.c b/src/examples/minimal_example_comet.c
index 9b25889e..83493243 100644
--- a/src/examples/minimal_example_comet.c
+++ b/src/examples/minimal_example_comet.c
@@ -56,7 +56,7 @@ ahc_echo (void *cls,
       return MHD_YES;
     }
   *ptr = NULL;                  /* reset when done */
-  response = MHD_create_response_from_callback (-1,
+  response = MHD_create_response_from_callback (MHD_SIZE_UNKNOWN,
                                                 80,
                                                 &data_generator, NULL, NULL);
   ret = MHD_queue_response (connection, MHD_HTTP_OK, response);
diff --git a/src/include/microhttpd.h b/src/include/microhttpd.h
index 1b1a986d..7d99948e 100644
--- a/src/include/microhttpd.h
+++ b/src/include/microhttpd.h
@@ -133,6 +133,15 @@ extern "C"
 #define MHD_SIZE_UNKNOWN  ((uint64_t) -1LL)
 #endif
 
+#ifdef SIZE_MAX
+#define MHD_CONTENT_READER_END_OF_STREAM SIZE_MAX
+#define MHD_CONTENT_READER_END_WITH_ERROR (SIZE_MAX - 1)
+#else
+#define MHD_CONTENT_READER_END ((size_t) -1LL)
+#define MHD_CONTENT_READER_END_WITH_ERROR (((size_t) -LL) - 1)
+#endif
+
+
 /**
  * HTTP response codes.
  */
@@ -868,15 +877,28 @@ typedef int
  *        obtained from the content reader so far.
  * @param buf where to copy the data
  * @param max maximum number of bytes to copy to buf (size of buf)
- * @return -1 for the end of transmission (or on error);
- *  if a content transfer size was pre-set and the callback
- *  has provided fewer than that amount of data,
- *  MHD will close the connection with the client;
- *  if no content size was specified and this is an
- *  http 1.1 connection using chunked encoding, MHD will
- *  interpret "-1" as the normal end of the transfer
- *  (possibly allowing the client to perform additional
- *  requests using the same TCP connection).
+ * @return number of bytes written to 'buf'; 
+ *  0 is legal unless we are running in internal select mode (since
+ *    this would cause busy-waiting); 0 in external select mode
+ *    will cause this function to be called again once the external
+ *    select calls MHD again;
+ *  MHD_CONTENT_READER_END_OF_STREAM (-1) for the regular
+ *    end of transmission (with chunked encoding, MHD will then
+ *    terminate the chunk and send any HTTP footers that might be
+ *    present; without chunked encoding and given an unknown 
+ *    response size, MHD will simply close the connection; note
+ *    that while returning END_OF_STREAM is not technically
+ *    legal if a response size was specified, MHD accepts this
+ *    and treats it just as MHD_CONTENT_READER_END_WITH_ERROR;
+ *  MHD_CONTENT_READER_END_WITH_ERROR (-2) to indicate a server
+ *    error generating the response; this will cause MHD to simply
+ *    close the connection immediately.  If a response size was
+ *    given or if chunked encoding is in use, this will indicate
+ *    an error to the client.  Note, however, that if the client
+ *    does not know a response size and chunked encoding is not in
+ *    use, then clients will not be able to tell the difference between
+ *    MHD_CONTENT_READER_END_WITH_ERROR and MHD_CONTENT_READER_END_OF_STREAM.
+ *    This is not a limitation of MHD but rather of the HTTP protocol.
  */
 typedef ssize_t
   (*MHD_ContentReaderCallback) (void *cls,
diff --git a/src/testcurl/daemontest_get_chunked.c b/src/testcurl/daemontest_get_chunked.c
index e5b1a73a..fd2561ca 100644
--- a/src/testcurl/daemontest_get_chunked.c
+++ b/src/testcurl/daemontest_get_chunked.c
@@ -71,7 +71,7 @@ crc (void *cls, uint64_t pos, char *buf, size_t max)
   if (pos == 128 * 10)
     {
       MHD_add_response_header (*responseptr, "Footer", "working");
-      return -1;                /* end of stream */
+      return MHD_CONTENT_READER_END_OF_STREAM;
     }
   if (max < 128)
     abort ();                   /* should not happen in this testcase... */
@@ -113,7 +113,7 @@ ahc_echo (void *cls,
   responseptr = malloc (sizeof (struct MHD_Response *));
   if (responseptr == NULL)
     return MHD_NO;
-  response = MHD_create_response_from_callback (-1,
+  response = MHD_create_response_from_callback (MHD_SIZE_UNKNOWN,
                                                 1024,
                                                 &crc, responseptr, &crcf);
   *responseptr = response;
diff --git a/src/testzzuf/daemontest_get_chunked.c b/src/testzzuf/daemontest_get_chunked.c
index 655f402a..35eed49d 100644
--- a/src/testzzuf/daemontest_get_chunked.c
+++ b/src/testzzuf/daemontest_get_chunked.c
@@ -69,7 +69,7 @@ crc (void *cls, uint64_t pos, char *buf, size_t max)
   if (pos == 128 * 10)
     {
       MHD_add_response_header (*responseptr, "Footer", "working");
-      return -1;                /* end of stream */
+      return MHD_CONTENT_READER_END_OF_STREAM;
     }
   if (max < 128)
     abort ();                   /* should not happen in this testcase... */
@@ -109,7 +109,7 @@ ahc_echo (void *cls,
       return MHD_YES;
     }
   responseptr = malloc (sizeof (struct MHD_Response *));
-  response = MHD_create_response_from_callback (-1,
+  response = MHD_create_response_from_callback (MHD_SIZE_UNKNOWN,
                                                 1024,
                                                 &crc, responseptr, &crcf);
   *responseptr = response;