Refactored API, returned back to event-based handlers. Upload and Websocket API simplified

examples/chat.c

@@ -326,9 +326,12 @@ static void redirect_to_ssl(struct mg_connection *conn,
   }
 }
 
-static int begin_request_handler(struct mg_connection *conn) {
-  const struct mg_request_info *request_info = mg_get_request_info(conn);
-  int processed = 1;
+static int event_handler(struct mg_event *event) {
+  struct mg_request_info *request_info = event->request_info;
+  struct mg_connection *conn = event->conn;
+  int result = 1;
+
+  if (event->type != MG_REQUEST_BEGIN) return 0;
 
   if (!request_info->is_ssl) {
     redirect_to_ssl(conn, request_info);
@@ -343,9 +346,10 @@ static int begin_request_handler(struct mg_connection *conn) {
   } else {
     // No suitable handler found, mark as not processed. Mongoose will
     // try to serve the request.
-    processed = 0;
+    result = 0;
   }
-  return processed;
+
+  return result;
 }
 
 static const char *options[] = {
@@ -357,7 +361,6 @@ static const char *options[] = {
 };
 
 int main(void) {
-  struct mg_callbacks callbacks;
   struct mg_context *ctx;
 
   // Initialize random number generator. It will be used later on for
@@ -365,9 +368,7 @@ int main(void) {
   srand((unsigned) time(0));
 
   // Setup and start Mongoose
-  memset(&callbacks, 0, sizeof(callbacks));
-  callbacks.begin_request = begin_request_handler;
-  if ((ctx = mg_start(&callbacks, NULL, options)) == NULL) {
+  if ((ctx = mg_start(options, event_handler, NULL)) == NULL) {
     printf("%s\n", "Cannot start chat server, fatal exit");
     exit(EXIT_FAILURE);
   }

examples/hello.c

@@ -3,42 +3,42 @@
 #include "mongoose.h"
 
 // This function will be called by mongoose on every new request.
-static int begin_request_handler(struct mg_connection *conn) {
-  const struct mg_request_info *request_info = mg_get_request_info(conn);
-  char content[100];
+static int event_handler(struct mg_event *event) {
 
-  // Prepare the message we're going to send
-  int content_length = snprintf(content, sizeof(content),
-                                "Hello from mongoose! Remote port: %d",
-                                request_info->remote_port);
+  if (event->type == MG_REQUEST_BEGIN) {
+    char content[100];
 
-  // Send HTTP reply to the client
-  mg_printf(conn,
-            "HTTP/1.1 200 OK\r\n"
-            "Content-Type: text/plain\r\n"
-            "Content-Length: %d\r\n"        // Always set Content-Length
-            "\r\n"
-            "%s",
-            content_length, content);
+    // Prepare the message we're going to send
+    int content_length = snprintf(content, sizeof(content),
+        "Hello from mongoose! Requested: [%s] [%s]",
+        event->request_info->request_method, event->request_info->uri);
 
-  // Returning non-zero tells mongoose that our function has replied to
-  // the client, and mongoose should not send client any more data.
-  return 1;
+    // Send HTTP reply to the client
+    mg_printf(event->conn,
+        "HTTP/1.1 200 OK\r\n"
+        "Content-Type: text/plain\r\n"
+        "Content-Length: %d\r\n"        // Always set Content-Length
+        "\r\n"
+        "%s",
+        content_length, content);
+
+    // Returning non-zero tells mongoose that our function has replied to
+    // the client, and mongoose should not send client any more data.
+    return 1;
+  }
+
+  // We do not handle any other event
+  return 0;
 }
 
 int main(void) {
   struct mg_context *ctx;
-  struct mg_callbacks callbacks;
 
   // List of options. Last element must be NULL.
   const char *options[] = {"listening_ports", "8080", NULL};
 
-  // Prepare callbacks structure. We have only one callback, the rest are NULL.
-  memset(&callbacks, 0, sizeof(callbacks));
-  callbacks.begin_request = begin_request_handler;
-
   // Start the web server.
-  ctx = mg_start(&callbacks, NULL, options);
+  ctx = mg_start(options, &event_handler, NULL);
 
   // Wait until user hits "enter". Server is running in separate thread.
   // Navigating to http://localhost:8080 will invoke begin_request_handler().

examples/post.c

@@ -10,45 +10,47 @@ static const char *html_form =
   "<input type=\"submit\" />"
   "</form></body></html>";
 
-static int begin_request_handler(struct mg_connection *conn) {
-  const struct mg_request_info *ri = mg_get_request_info(conn);
+static int event_handler(struct mg_event *event) {
   char post_data[1024], input1[sizeof(post_data)], input2[sizeof(post_data)];
   int post_data_len;
 
-  if (!strcmp(ri->uri, "/handle_post_request")) {
-    // User has submitted a form, show submitted data and a variable value
-    post_data_len = mg_read(conn, post_data, sizeof(post_data));
+  if (event->type == MG_REQUEST_BEGIN) {
+    if (!strcmp(event->request_info->uri, "/handle_post_request")) {
+      // User has submitted a form, show submitted data and a variable value
+      post_data_len = mg_read(event->conn, post_data, sizeof(post_data));
 
-    // Parse form data. input1 and input2 are guaranteed to be NUL-terminated
-    mg_get_var(post_data, post_data_len, "input_1", input1, sizeof(input1));
-    mg_get_var(post_data, post_data_len, "input_2", input2, sizeof(input2));
+      // Parse form data. input1 and input2 are guaranteed to be NUL-terminated
+      mg_get_var(post_data, post_data_len, "input_1", input1, sizeof(input1));
+      mg_get_var(post_data, post_data_len, "input_2", input2, sizeof(input2));
 
-    // Send reply to the client, showing submitted form values.
-    mg_printf(conn, "HTTP/1.0 200 OK\r\n"
-              "Content-Type: text/plain\r\n\r\n"
-              "Submitted data: [%.*s]\n"
-              "Submitted data length: %d bytes\n"
-              "input_1: [%s]\n"
-              "input_2: [%s]\n",
-              post_data_len, post_data, post_data_len, input1, input2);
-  } else {
-    // Show HTML form.
-    mg_printf(conn, "HTTP/1.0 200 OK\r\n"
-              "Content-Length: %d\r\n"
-              "Content-Type: text/html\r\n\r\n%s",
-              (int) strlen(html_form), html_form);
+      // Send reply to the client, showing submitted form values.
+      mg_printf(event->conn, "HTTP/1.0 200 OK\r\n"
+                "Content-Type: text/plain\r\n\r\n"
+                "Submitted data: [%.*s]\n"
+                "Submitted data length: %d bytes\n"
+                "input_1: [%s]\n"
+                "input_2: [%s]\n",
+                post_data_len, post_data, post_data_len, input1, input2);
+    } else {
+      // Show HTML form.
+      mg_printf(event->conn, "HTTP/1.0 200 OK\r\n"
+                "Content-Length: %d\r\n"
+                "Content-Type: text/html\r\n\r\n%s",
+                (int) strlen(html_form), html_form);
+    }
+
+    return 1;  // Mark event as processed
   }
-  return 1;  // Mark request as processed
+
+  // All other events are left not processed
+  return 0;
 }
 
 int main(void) {
   struct mg_context *ctx;
   const char *options[] = {"listening_ports", "8080", NULL};
-  struct mg_callbacks callbacks;
 
-  memset(&callbacks, 0, sizeof(callbacks));
-  callbacks.begin_request = begin_request_handler;
-  ctx = mg_start(&callbacks, NULL, options);
+  ctx = mg_start(options, &event_handler, NULL);
   getchar();  // Wait until user hits "enter"
   mg_stop(ctx);
 

examples/upload.c

@@ -3,57 +3,48 @@
 
 #include <stdio.h>
 #include <string.h>
-#include <fcntl.h>
-#include <stdlib.h>
-#ifdef _WIN32
-#include <windows.h>
-#include <io.h>
-#define strtoll strtol
-typedef __int64 int64_t;
-#else
-#include <inttypes.h>
-#include <unistd.h>
-#endif // !_WIN32
-
 #include "mongoose.h"
 
-static int begin_request_handler(struct mg_connection *conn) {
-  if (!strcmp(mg_get_request_info(conn)->uri, "/handle_post_request")) {
-    mg_printf(conn, "%s", "HTTP/1.0 200 OK\r\n\r\n");
-    mg_upload(conn, "/tmp");
-  } else {
-    // Show HTML form. Make sure it has enctype="multipart/form-data" attr.
-    static const char *html_form =
-      "<html><body>Upload example."
-      "<form method=\"POST\" action=\"/handle_post_request\" "
-      "  enctype=\"multipart/form-data\">"
-      "<input type=\"file\" name=\"file\" /> <br/>"
-      "<input type=\"submit\" value=\"Upload\" />"
-      "</form></body></html>";
+static int event_handler(struct mg_event *event) {
 
-    mg_printf(conn, "HTTP/1.0 200 OK\r\n"
-              "Content-Length: %d\r\n"
-              "Content-Type: text/html\r\n\r\n%s",
-              (int) strlen(html_form), html_form);
+  if (event->type == MG_REQUEST_BEGIN) {
+    if (!strcmp(event->request_info->uri, "/handle_post_request")) {
+      char path[200];
+      FILE *fp = mg_upload(event->conn, "/tmp", path, sizeof(path));
+      if (fp != NULL) {
+        fclose(fp);
+        mg_printf(event->conn, "HTTP/1.0 200 OK\r\n\r\nSaved: [%s]", path);
+      } else {
+        mg_printf(event->conn, "%s", "HTTP/1.0 200 OK\r\n\r\nNo files sent");
+      }
+    } else {
+      // Show HTML form. Make sure it has enctype="multipart/form-data" attr.
+      static const char *html_form =
+        "<html><body>Upload example."
+        "<form method=\"POST\" action=\"/handle_post_request\" "
+        "  enctype=\"multipart/form-data\">"
+        "<input type=\"file\" name=\"file\" /> <br/>"
+        "<input type=\"submit\" value=\"Upload\" />"
+        "</form></body></html>";
+
+      mg_printf(event->conn, "HTTP/1.0 200 OK\r\n"
+          "Content-Length: %d\r\n"
+          "Content-Type: text/html\r\n\r\n%s",
+          (int) strlen(html_form), html_form);
+    }
+
+    // Mark request as processed
+    return 1;
   }
 
-  // Mark request as processed
+  // All other events left unprocessed
   return 1;
 }
 
-static void upload_handler(struct mg_connection *conn, const char *path) {
-  mg_printf(conn, "Saved [%s]", path);
-}
-
 int main(void) {
   struct mg_context *ctx;
   const char *options[] = {"listening_ports", "8080", NULL};
-  struct mg_callbacks callbacks;
-
-  memset(&callbacks, 0, sizeof(callbacks));
-  callbacks.begin_request = begin_request_handler;
-  callbacks.upload = upload_handler;
-  ctx = mg_start(&callbacks, NULL, options);
+  ctx = mg_start(options, event_handler, NULL);
   getchar();  // Wait until user hits "enter"
   mg_stop(ctx);
 

examples/websocket.c

@@ -5,38 +5,52 @@
 #include <string.h>
 #include "mongoose.h"
 
-static void websocket_ready_handler(struct mg_connection *conn) {
-  static const char *message = "server ready";
-  mg_websocket_write(conn, WEBSOCKET_OPCODE_TEXT, message, strlen(message));
-}
+static int event_handler(struct mg_event *event) {
 
-// Arguments:
-//   flags: first byte of websocket frame, see websocket RFC,
-//          http://tools.ietf.org/html/rfc6455, section 5.2
-//   data, data_len: payload data. Mask, if any, is already applied.
-static int websocket_data_handler(struct mg_connection *conn, int flags,
-                                  char *data, size_t data_len) {
-  (void) flags; // Unused
-  mg_websocket_write(conn, WEBSOCKET_OPCODE_TEXT, data, data_len);
+  if (event->type == MG_REQUEST_BEGIN) {
+    const char *version_header = mg_get_header(event->conn,
+                                               "Sec-WebSocket-Version");
 
-  // Returning zero means stoping websocket conversation.
-  // Close the conversation if client has sent us "exit" string.
-  return memcmp(data, "exit", 4);
+    if (version_header != NULL) {
+      // Websocket request, process it
+      if (strcmp(version_header, "13") != 0) {
+        mg_printf(event->conn, "%s", "HTTP/1.1 426 Upgrade Required\r\n\r\n");
+      } else {
+        static const char *server_ready_message = "server ready";
+        char *data;
+        int bits, len;
+
+        // Handshake, and send initial server message
+        mg_websocket_handshake(event->conn);
+        mg_websocket_write(event->conn, WEBSOCKET_OPCODE_TEXT,
+                           server_ready_message, strlen(server_ready_message));
+
+        while ((len = mg_websocket_read(event->conn, &bits, &data)) > 0) {
+          // Echo message back to the client
+          mg_websocket_write(event->conn, WEBSOCKET_OPCODE_TEXT, data, len);
+          if (memcmp(data, "exit", 4) == 0) {
+            mg_websocket_write(event->conn,
+                               WEBSOCKET_OPCODE_CONNECTION_CLOSE, "", 0);
+            break;
+          }
+        }
+      }
+      return 1;
+    }
+  }
+
+  return 0;
 }
 
 int main(void) {
   struct mg_context *ctx;
-  struct mg_callbacks callbacks;
   const char *options[] = {
     "listening_ports", "8080",
     "document_root", "websocket_html_root",
     NULL
   };
 
-  memset(&callbacks, 0, sizeof(callbacks));
-  callbacks.websocket_ready = websocket_ready_handler;
-  callbacks.websocket_data = websocket_data_handler;
-  ctx = mg_start(&callbacks, NULL, options);
+  ctx = mg_start(options, &event_handler, NULL);
   getchar();  // Wait until user hits "enter"
   mg_stop(ctx);