move to new skeleton

tutorials/http/file-upload-single-post/Makefile

@@ -0,0 +1,25 @@
+PROG ?= example                   # Program we are building
+DELETE = rm -rf                   # Command to remove files
+OUT ?= -o $(PROG)                 # Compiler argument for output file
+SOURCES = main.c mongoose.c       # Source code files
+CFLAGS = -W -Wall -Wextra -g -I.  # Build options
+
+# Mongoose build options. See https://mongoose.ws/documentation/#build-options
+#CFLAGS_MONGOOSE += -DMG_ENABLE_LINES
+
+ifeq ($(OS),Windows_NT)   # Windows settings. Assume MinGW compiler. To use VC: make CC=cl CFLAGS=/MD OUT=/Feprog.exe
+  PROG ?= example.exe           # Use .exe suffix for the binary
+  CC = gcc                      # Use MinGW gcc compiler
+  CFLAGS += -lws2_32            # Link against Winsock library
+  DELETE = cmd /C del /Q /F /S  # Command prompt command to delete files
+  OUT ?= -o $(PROG)             # Build output
+endif
+
+all: $(PROG)              # Default target. Build and run program
+	$(RUN) ./$(PROG) $(ARGS)
+
+$(PROG): $(SOURCES)       # Build program from sources
+	$(CC) $(SOURCES) $(CFLAGS) $(CFLAGS_MONGOOSE) $(CFLAGS_EXTRA) $(OUT)
+
+clean:                    # Cleanup. Delete built program and all build artifacts
+	$(DELETE) $(PROG) *.o *.obj *.exe *.dSYM

tutorials/http/file-upload-single-post/README.md

@@ -0,0 +1 @@
+See detailed tutorial at https://mongoose.ws/tutorials/http/file-uploads/

tutorials/http/file-upload-single-post/main.c

@@ -0,0 +1,80 @@
+// Copyright (c) 2020-2024 Cesanta Software Limited
+// All rights reserved
+//
+// Streaming upload example. Demonstrates how to use MG_EV_READ events
+// to save a large file without buffering it fully in memory.
+//
+// curl http://localhost:8000/upload?name=a.txt --data-binary @large_file.txt
+
+#include "mongoose.h"
+
+#define UPLOAD_DIR "/tmp"
+
+struct upload_state {
+  size_t expected;  // POST data length, bytes
+  size_t received;  // Already received bytes
+  void *fp;         // Opened uploaded file
+};
+
+static void handle_uploads(struct mg_connection *c, int ev, void *ev_data) {
+  struct upload_state *us = (struct upload_state *) c->data;
+  struct mg_fs *fs = &mg_fs_posix;
+
+  // Catch /upload requests early, without buffering whole body
+  // When we receive MG_EV_HTTP_HDRS event, that means we've received all
+  // HTTP headers but not necessarily full HTTP body
+  if (ev == MG_EV_HTTP_HDRS) {
+    struct mg_http_message *hm = (struct mg_http_message *) ev_data;
+    if (mg_match(hm->uri, mg_str("/upload/*"), NULL)) {
+      char path[MG_PATH_MAX];
+      mg_snprintf(path, sizeof(path), "%s/%.*s", UPLOAD_DIR, hm->uri.len - 8,
+                  hm->uri.buf + 8);
+      us->expected = hm->body.len;  // Store number of bytes we expect
+      mg_iobuf_del(&c->recv, 0, hm->head.len);  // Delete HTTP headers
+      c->pfn = NULL;  // Silence HTTP protocol handler, we'll use MG_EV_READ
+      if (mg_path_is_sane(mg_str(path))) {
+        fs->rm(path);                        // Delete file if it exists
+        us->fp = fs->op(path, MG_FS_WRITE);  // Open file for writing
+      }
+    }
+  }
+
+  // Catch uploaded file data for both MG_EV_READ and MG_EV_HTTP_HDRS
+  if (us->expected > 0 && c->recv.len > 0) {
+    us->received += c->recv.len;
+    if (us->fp) fs->wr(us->fp, c->recv.buf, c->recv.len);  // Write to file
+    c->recv.len = 0;  // Delete received data
+    if (us->received >= us->expected) {
+      // Uploaded everything. Send response back
+      MG_INFO(("Uploaded %lu bytes", us->received));
+      mg_http_reply(c, 200, NULL, "%lu ok\n", us->received);
+      if (us->fp) fs->cl(us->fp);  // Close file
+      memset(us, 0, sizeof(*us));  // Cleanup upload state
+      c->is_draining = 1;          // Close connection when response gets sent
+    }
+  }
+}
+
+static void fn(struct mg_connection *c, int ev, void *ev_data) {
+  handle_uploads(c, ev, ev_data);
+
+  // Non-upload requests, we serve normally
+  // NOTE: handle_uploads() may delete request and reset c->pfn
+  if (ev == MG_EV_HTTP_MSG && c->pfn != NULL) {
+    struct mg_http_serve_opts opts = {.root_dir = "web_root"};
+    mg_http_serve_dir(c, ev_data, &opts);
+  }
+}
+
+int main(void) {
+  struct mg_mgr mgr;
+
+  mg_mgr_init(&mgr);
+  mg_log_set(MG_LL_DEBUG);  // Set debug log level
+  mg_http_listen(&mgr, "http://localhost:8000", fn, NULL);
+
+  for (;;) mg_mgr_poll(&mgr, 50);
+  mg_mgr_free(&mgr);
+
+  return 0;
+}

tutorials/http/file-upload-single-post/mongoose.c

@@ -0,0 +1 @@
+../../../mongoose.c

tutorials/http/file-upload-single-post/mongoose.h

@@ -0,0 +1 @@
+../../../mongoose.h

tutorials/http/file-upload-single-post/web_root/index.html

@@ -0,0 +1,71 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <title>example</title>
+    <meta charset="utf-8" />
+    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <style>
+      #container { margin-right: auto; margin-left: auto; max-width: 480px; }
+      #info { background: #e0f0f0; border-radius: .5em; padding: 2em;  }
+      #wrapper { margin-top: 1em; }
+    </style>
+  </head>
+  <body>
+    <div id="container">
+      <div id="info">
+        Mongoose always buffers a full HTTP message before invoking
+        MG_EV_HTTP_MSG event. Big POST request require of lot
+        of RAM to buffer everything.
+        <br><br>
+        In order to upload large files to a memory-constrained system, use
+        <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.
+      </div>
+      <div id="wrapper">
+        <input type="file" id="el1" style="display: none"/>
+        <button id="el2">choose file...</button>
+        <span>Selected file:</span> <span id="el4"></span> <br/>
+        <button id="el5" style="margin: 0.5em 0;" disabled>upload file</button>
+        <div id="el3" style="margin-top: 1em;"></div>
+      </div>
+    </div>
+  </body>
+  <script>
+    var f; // selected file
+
+    // When user clicks on a button, trigger file selection dialog
+    document.getElementById('el2').onclick = function(ev) {
+      document.getElementById('el1').click();
+    };
+
+    document.getElementById('el5').onclick = function(ev) {
+      var r = new FileReader();
+      r.readAsArrayBuffer(f);
+      r.onload = function() {
+        ev.target.value = '';
+        document.getElementById('el3').innerText = 'Uploading...';
+        fetch(`/upload/${encodeURIComponent(f.name)}`, {
+          method: 'POST',
+          body: r.result,
+        }).then(function(res) {
+          document.getElementById('el3').innerText = 'Uploaded ' + r.result.byteLength + ' bytes';
+        });
+      };
+    };
+
+    // If user selected a file, read it into memory and trigger sendFileData()
+    document.getElementById('el1').onchange = function(ev) {
+      f = ev.target.files[0];
+      if (!f) return;
+      document.getElementById('el4').innerText = f.name;
+      document.getElementById('el5').removeAttribute('disabled');
+    };
+
+  </script>
+</html>