Get rid of MG_EV_HTTP_CHUNK

examples/file-upload-single-post/main.c

@@ -1,8 +1,8 @@
 // Copyright (c) 2020 Cesanta Software Limited
 // All rights reserved
 //
-// Streaming upload example. Demonstrates how to use MG_EV_HTTP_CHUNK events
-// to send large payload in smaller chunks. To test, use curl utility:
+// Streaming upload example. Demonstrates how to use MG_EV_READ events
+// to get large payload in smaller chunks. To test, use curl utility:
 //
 // curl http://localhost:8000/upload?name=a.txt --data-binary @large_file.txt
 
@@ -12,21 +12,33 @@
 //   /upload - Saves the next file chunk
 //   all other URI - serves web_root/ directory
 static void cb(struct mg_connection *c, int ev, void *ev_data, void *fn_data) {
-  struct mg_http_message *hm = (struct mg_http_message *) ev_data;
-  if (ev == MG_EV_HTTP_CHUNK && mg_http_match_uri(hm, "/upload")) {
-    MG_INFO(("Got chunk len %lu", (unsigned long) hm->chunk.len));
-    MG_INFO(("Query string: [%.*s]", (int) hm->query.len, hm->query.ptr));
-    // MG_INFO(("Chunk data:\n%.*s", (int) hm->chunk.len, hm->chunk.ptr));
-    mg_http_delete_chunk(c, hm);
-    if (hm->chunk.len == 0) {
-      MG_INFO(("Last chunk received, sending response"));
-      mg_http_reply(c, 200, "", "ok (chunked)\n");
+  if (ev == MG_EV_READ) {
+    // Parse the incoming data ourselves. If we can parse the request,
+    // store two size_t variables in the c->data: expected len and recv len.
+    size_t *data = (size_t *) c->data;
+    if (data[0]) {  // Already parsed, simply print received data
+      data[1] += c->recv.len;
+      MG_INFO(("Got chunk len %lu, %lu total", c->recv.len, data[1]));
+      c->recv.len = 0;  // And cleanup the receive buffer. Streaming!
+      if (data[1] >= data[0]) mg_http_reply(c, 200, "", "ok\n");
+    } else {
+      struct mg_http_message hm;
+      int n = mg_http_parse((char *) c->recv.buf, c->recv.len, &hm);
+      if (n < 0) mg_error(c, "Bad response");
+      if (n > 0) {
+        if (mg_http_match_uri(&hm, "/upload")) {
+          MG_INFO(("Got chunk len %lu", c->recv.len - n));
+          data[0] = hm.body.len;
+          data[1] = c->recv.len - n;
+          if (data[1] >= data[0]) mg_http_reply(c, 200, "", "ok\n");
+        } else {
+          struct mg_http_serve_opts opts = {.root_dir = "web_root"};
+          mg_http_serve_dir(c, &hm, &opts);
+        }
+      }
     }
-  } else if (ev == MG_EV_HTTP_MSG) {
-    struct mg_http_serve_opts opts = {.root_dir = "web_root"};
-    mg_http_serve_dir(c, hm, &opts);
   }
-  (void) fn_data;
+  (void) fn_data, (void) ev_data;
 }
 
 int main(void) {

examples/file-upload-single-post/web_root/index.html

@@ -19,12 +19,10 @@
         of RAM to buffer everything.
         <br><br>
         In order to upload large files to a memory-constrained system, use
-        <code>MG_EV_HTTP_CHUNK</code> on a server side. It fires when
-        a partial HTTP message has been received (or a chunk-encoded chunk).
-        Use <code>mg_http_delete_chunk()</code> to release chunk memory.
-        When 0-sized chunk is received, that's the end of the message.
-        Use <code>MG_MAX_RECV_SIZE</code> build constant to limit
-        maximum chunk size on a server side.
+        <code>MG_EV_READ</code> on a server side. It fires when
+        a partial HTTP message has been received. We discourage this method,
+        since the client can send chunked-encoded data. Instead, please
+        split the upload into smaller pieces and send sequentially.
         <br><br>
         In this example, JavaScript code uses "fetch()" browser API.
         Uploaded file is not saved, but rather printed by server side.

examples/http-streaming-client/main.c

@@ -1,14 +1,12 @@
 // Copyright (c) 2021 Cesanta Software Limited
 // All rights reserved
 //
-// Example HTTP client.
-// Instead of buffering the whole HTTP response in memory and wait for the
-// MG_EV_HTTP_MSG event, this client catches MG_EV_HTTP_CHUNK events and
-// prints them. This is useful to download large content without spooling
-// everything to memory, or catch chunked content.
+// Example streaming HTTP client.
+// The default HTTP handler waits until the whole HTTP message is buffered in
+// c->recv IO buffer. It can be large. This example shows how to receive
+// a potentially large response in chunks by handling the MG_EV_READ events.
 //
 // You can change `s_url` from the command line by executing: ./example YOUR_URL
-//
 // To enable SSL/TLS, see https://mongoose.ws/tutorials/tls/#how-to-build
 
 #include "mongoose.h"
@@ -21,13 +19,11 @@ static void fn(struct mg_connection *c, int ev, void *ev_data, void *fn_data) {
   if (ev == MG_EV_CONNECT) {
     // Connected to server. Extract host name from URL
     struct mg_str host = mg_url_host(s_url);
-
     if (mg_url_is_ssl(s_url)) {
       struct mg_tls_opts opts = {.ca = mg_unpacked("/certs/ca.pem"),
                                  .name = host};
       mg_tls_init(c, &opts);
     }
-
     // Send request
     mg_printf(c,
               "GET %s HTTP/1.1\r\n"
@@ -36,21 +32,33 @@ static void fn(struct mg_connection *c, int ev, void *ev_data, void *fn_data) {
               "Host: %.*s\r\n"
               "\r\n",
               mg_url_uri(s_url), (int) host.len, host.ptr);
-  } else if (ev == MG_EV_HTTP_CHUNK) {
-    struct mg_http_message *hm = (struct mg_http_message *) ev_data;
-    fwrite(hm->chunk.ptr, 1, hm->chunk.len, stdout);
-    // fprintf(stderr, "c %u\n", (unsigned) hm->chunk.len);
-    mg_http_delete_chunk(c, hm);
-    if (hm->chunk.len == 0) *(bool *) fn_data = true;  // Last chunk
-  } else if (ev == MG_EV_HTTP_MSG) {
-    // Response is received. Print it
-    struct mg_http_message *hm = (struct mg_http_message *) ev_data;
-    fwrite(hm->body.ptr, 1, hm->body.len, stdout);
-    c->is_draining = 1;        // Tell mongoose to close this connection
-    *(bool *) fn_data = true;  // Tell event loop to stop
+  } else if (ev == MG_EV_READ) {
+    // Parse the incoming data ourselves. If we can parse the request,
+    // store two size_t variables in the c->data: expected len and recv len.
+    size_t *data = (size_t *) c->data;
+    if (data[0]) {  // Already parsed, simply print received data
+      data[1] += c->recv.len;
+      fwrite(c->recv.buf, 1, c->recv.len, stdout);
+      c->recv.len = 0;  // And cleanup the receive buffer. Streming!
+      if (data[1] >= data[0]) * (bool *) fn_data = true;
+    } else {
+      struct mg_http_message hm;
+      int n = mg_http_parse((char *) c->recv.buf, c->recv.len, &hm);
+      if (n < 0) mg_error(c, "Bad response");
+      if (n > 0) {
+        fwrite(c->recv.buf + n, 1, c->recv.len - n, stdout);  // Print body
+        data[0] = n + hm.body.len;
+        data[1] = c->recv.len;
+        c->recv.len = 0;  // Cleanup receive buffer
+        if (data[1] >= data[0]) * (bool *) fn_data = true;
+      }
+    }
+  } else if (ev == MG_EV_CLOSE) {
+    *(bool *) fn_data = true;  // tell event loop to stop
   } else if (ev == MG_EV_ERROR) {
     *(bool *) fn_data = true;  // Error, tell event loop to stop
   }
+  (void) ev_data;
 }
 
 int main(int argc, char *argv[]) {
@@ -59,7 +67,7 @@ int main(int argc, char *argv[]) {
   const char *log_level = getenv("V");  // Log level
 
   mg_mgr_init(&mgr);                       // Initialise event manager
-  if (log_level == NULL) log_level = "3";  // If not set, set to DEBUG
+  if (log_level == NULL) log_level = "2";  // If not set, set to DEBUG
   mg_log_set(atoi(log_level));             // Set to 0 to disable debug log
   if (argc > 1) s_url = argv[1];           // Use URL from command line