Refactor device-dashboard

examples/device-dashboard/net.c

@@ -1,17 +1,50 @@
-// Copyright (c) 2020-2022 Cesanta Software Limited
+// Copyright (c) 2023 Cesanta Software Limited
 // All rights reserved
 
-#include "mongoose.h"
+#include "net.h"
 
-#if !defined(MQTT_SERVER)
-#if MG_ENABLE_MBEDTLS || MG_ENABLE_OPENSSL
-#define MQTT_SERVER "mqtts://broker.hivemq.com:8883"
-#else
-#define MQTT_SERVER "mqtt://broker.hivemq.com:1883"
-#endif
-#endif
-#define MQTT_PUBLISH_TOPIC "mg/my_device"
-#define MQTT_SUBSCRIBE_TOPIC "mg/#"
+// Authenticated user.
+// A user can be authenticated by:
+//   - a name:pass pair, passed in a header Authorization: Basic .....
+//   - an access_token, passed in a header Cookie: access_token=....
+// When a user is shown a login screen, she enters a user:pass. If successful,
+// a server responds with a http-only access_token cookie set.
+struct user {
+  const char *name, *pass, *access_token;
+};
+
+// Event log entry
+struct event {
+  int type, prio;
+  unsigned long timestamp;
+  const char *text;
+};
+
+// Settings
+struct settings {
+  bool log_enabled;
+  int log_level;
+  long brightness;
+  char *device_name;
+};
+
+static struct settings s_settings = {true, 1, 57, NULL};
+
+// Mocked events
+static struct event s_events[] = {
+    {.type = 0, .prio = 0, .text = "here goes event 1"},
+    {.type = 1, .prio = 2, .text = "event 2..."},
+    {.type = 2, .prio = 1, .text = "another event"},
+    {.type = 1, .prio = 1, .text = "something happened!"},
+    {.type = 2, .prio = 0, .text = "once more..."},
+    {.type = 2, .prio = 0, .text = "more again..."},
+    {.type = 1, .prio = 1, .text = "oops. it happened again"},
+};
+
+static const char *s_json_header =
+    "Content-Type: application/json\r\n"
+    "Cache-Control: no-cache\r\n";
+static uint64_t s_boot_timestamp = 0;  // Updated by SNTP
 
 // Certificate generation procedure:
 // openssl ecparam -name prime256v1 -genkey -noout -out key.pem
@@ -33,252 +66,177 @@ static const char *s_ssl_key =
     "6YbyU/ZGtdGfbaGYYJwatKNMX00OIwtb8A==\n"
     "-----END EC PRIVATE KEY-----\n";
 
-static time_t s_boot_timestamp = 0;  // Updated by SNTP
-#ifndef DISABLE_ROUTING
-static struct mg_connection *s_sntp_conn = NULL;  // SNTP connection
-#endif
-
-// Define a system time alternative
-time_t ourtime(time_t *tp) {
-  time_t t = s_boot_timestamp + (time_t) (mg_millis() / 1000);
-  if (tp != NULL) *tp = t;
-  return t;
-}
-
-// Authenticated user.
-// A user can be authenticated by:
-//   - a name:pass pair
-//   - a token
-// When a user is shown a login screen, she enters a user:pass. If successful,
-// a server returns user info which includes token. From that point on,
-// client can use token for authentication. Tokens could be refreshed/changed
-// on a server side, forcing clients to re-login.
-struct user {
-  const char *name, *pass, *token;
-};
-
-// This is a configuration structure we're going to show on a dashboard
-static struct config {
-  char *url, *pub, *sub;  // MQTT settings
-} s_config;
-
-static struct mg_connection *s_mqtt = NULL;  // MQTT connection
-static bool s_connected = false;             // MQTT connection established
-
-// Try to update a single configuration value
-static void update_config(struct mg_str *body, const char *name, char **value) {
-  char buf[256];
-  if (mg_http_get_var(body, name, buf, sizeof(buf)) > 0) {
-    free(*value);
-    *value = strdup(buf);
-  }
-}
-
-// Parse HTTP requests, return authenticated user or NULL
-static struct user *getuser(struct mg_http_message *hm) {
-  // In production, make passwords strong and tokens randomly generated
-  // In this example, user list is kept in RAM. In production, it can
-  // be backed by file, database, or some other method.
-  static struct user users[] = {
-      {"admin", "pass0", "admin_token"},
-      {"user1", "pass1", "user1_token"},
-      {"user2", "pass2", "user2_token"},
-      {NULL, NULL, NULL},
-  };
-  char user[256], pass[256];
-  struct user *u;
-  mg_http_creds(hm, user, sizeof(user), pass, sizeof(pass));
-  if (user[0] != '\0' && pass[0] != '\0') {
-    // Both user and password is set, search by user/password
-    for (u = users; u->name != NULL; u++)
-      if (strcmp(user, u->name) == 0 && strcmp(pass, u->pass) == 0) return u;
-  } else if (user[0] == '\0') {
-    // Only password is set, search by token
-    for (u = users; u->name != NULL; u++)
-      if (strcmp(pass, u->token) == 0) return u;
-  }
-  return NULL;
-}
-
-// Notify all config watchers about the config change
-static void send_notification(struct mg_mgr *mgr, const char *fmt, ...) {
-  struct mg_connection *c;
-  for (c = mgr->conns; c != NULL; c = c->next) {
-    if (c->data[0] == 'W') {
-      va_list ap;
-      va_start(ap, fmt);
-      mg_ws_vprintf(c, WEBSOCKET_OP_TEXT, fmt, &ap);
-      va_end(ap);
-    }
-  }
-}
-
-// Send simulated metrics data to the dashboard, for chart rendering
-static void timer_metrics_fn(void *param) {
-  send_notification(param, "{%m:%m,%m:[%lu, %d]}", MG_ESC("name"),
-                    MG_ESC("metrics"), MG_ESC("data"),
-                    (unsigned long) ourtime(NULL),
-                    10 + (int) ((double) rand() * 10 / RAND_MAX));
-}
-
-#ifndef DISABLE_ROUTING
-
-// MQTT event handler function
-static void mqtt_fn(struct mg_connection *c, int ev, void *ev_data, void *fnd) {
-  if (ev == MG_EV_CONNECT && mg_url_is_ssl(s_config.url)) {
-    struct mg_tls_opts opts;
-    memset(&opts, 0, sizeof(opts));
-    opts.srvname = mg_url_host(s_config.url);
-#ifndef DISABLE_PACKEDFS
-    opts.ca = "/ca.pem";
-    opts.fs = &mg_fs_packed;
-#else
-    opts.ca = "ca.pem";
-#endif
-    mg_tls_init(c, &opts);
-  } else if (ev == MG_EV_MQTT_OPEN) {
-    s_connected = true;
-    c->is_hexdumping = 1;
-    struct mg_mqtt_opts sub_opts;
-    memset(&sub_opts, 0, sizeof(sub_opts));
-    sub_opts.topic = mg_str(s_config.sub);
-    sub_opts.qos = 2;
-
-    mg_mqtt_sub(s_mqtt, &sub_opts);
-    send_notification(c->mgr, "{%m:%m,%m:null}", MG_ESC("name"),
-                      MG_ESC("config"), MG_ESC("data"));
-    MG_INFO(("MQTT connected, server %s", MQTT_SERVER));
-  } else if (ev == MG_EV_MQTT_MSG) {
-    struct mg_mqtt_message *mm = ev_data;
-    send_notification(
-        c->mgr, "{%m:%m,%m:{%m: %m, %m: %m, %m: %d}}", MG_ESC("name"),
-        MG_ESC("message"), MG_ESC("data"), MG_ESC("topic"), mg_print_esc,
-        (int) mm->topic.len, mm->topic.ptr, MG_ESC("data"), mg_print_esc,
-        (int) mm->data.len, mm->data.ptr, MG_ESC("qos"), (int) mm->qos);
-  } else if (ev == MG_EV_MQTT_CMD) {
-    struct mg_mqtt_message *mm = (struct mg_mqtt_message *) ev_data;
-    MG_DEBUG(("%lu cmd %d qos %d", c->id, mm->cmd, mm->qos));
-  } else if (ev == MG_EV_CLOSE) {
-    s_mqtt = NULL;
-    if (s_connected) {
-      s_connected = false;
-      send_notification(c->mgr, "{%m:%m,%m:null}", MG_ESC("name"),
-                        MG_ESC("config"), MG_ESC("data"));
-    }
-  }
-  (void) fnd;
-}
-
-// Keep MQTT connection open - reconnect if closed
-static void timer_mqtt_fn(void *param) {
-  struct mg_mgr *mgr = (struct mg_mgr *) param;
-  if (s_mqtt == NULL) {
-    struct mg_mqtt_opts opts;
-    memset(&opts, 0, sizeof(opts));
-    s_mqtt = mg_mqtt_connect(mgr, s_config.url, &opts, mqtt_fn, NULL);
-  }
+static int event_next(int no, struct event *e) {
+  if (no < 0 || no >= (int) (sizeof(s_events) / sizeof(s_events[0]))) return 0;
+  *e = s_events[no];
+  return no + 1;
 }
 
 // SNTP connection event handler. When we get a response from an SNTP server,
 // adjust s_boot_timestamp. We'll get a valid time from that point on
 static void sfn(struct mg_connection *c, int ev, void *ev_data, void *fn_data) {
-  if (ev == MG_EV_SNTP_TIME) {
+  uint64_t *expiration_time = (uint64_t *) c->data;
+  if (ev == MG_EV_OPEN) {
+    *expiration_time = mg_millis() + 3000;  // Store expiration time in 3s
+  } else if (ev == MG_EV_SNTP_TIME) {
     uint64_t t = *(uint64_t *) ev_data;
-    s_boot_timestamp = (time_t) ((t - mg_millis()) / 1000);
+    s_boot_timestamp = t - mg_millis();
     c->is_closing = 1;
-  } else if (ev == MG_EV_CLOSE) {
-    s_sntp_conn = NULL;
+  } else if (ev == MG_EV_POLL) {
+    if (mg_millis() > *expiration_time) c->is_closing = 1;
   }
   (void) fn_data;
 }
 
 static void timer_sntp_fn(void *param) {  // SNTP timer function. Sync up time
-  struct mg_mgr *mgr = (struct mg_mgr *) param;
-  if (s_sntp_conn == NULL && s_boot_timestamp == 0) {
-    s_sntp_conn = mg_sntp_connect(mgr, NULL, sfn, NULL);
-  }
+  mg_sntp_connect(param, "udp://time.google.com:123", sfn, NULL);
 }
 
-#endif
+// Parse HTTP requests, return authenticated user or NULL
+static struct user *authenticate(struct mg_http_message *hm) {
+  // In production, make passwords strong and tokens randomly generated
+  // In this example, user list is kept in RAM. In production, it can
+  // be backed by file, database, or some other method.
+  static struct user users[] = {
+      {"admin", "admin", "admin_token"},
+      {"user1", "user1", "user1_token"},
+      {"user2", "user2", "user2_token"},
+      {NULL, NULL, NULL},
+  };
+  char user[64], pass[64];
+  struct user *u, *result = NULL;
+  mg_http_creds(hm, user, sizeof(user), pass, sizeof(pass));
+  MG_INFO(("user [%s] pass [%s]", user, pass));
+
+  if (user[0] != '\0' && pass[0] != '\0') {
+    // Both user and password is set, search by user/password
+    for (u = users; result == NULL && u->name != NULL; u++)
+      if (strcmp(user, u->name) == 0 && strcmp(pass, u->pass) == 0) result = u;
+  } else if (user[0] == '\0') {
+    // Only password is set, search by token
+    for (u = users; result == NULL && u->name != NULL; u++)
+      if (strcmp(pass, u->access_token) == 0) result = u;
+  }
+  return result;
+}
+
+static void handle_login(struct mg_connection *c, struct user *u) {
+  char cookie[256];
+  mg_snprintf(cookie, sizeof(cookie),
+              "Set-Cookie: access_token=%s;Path=/;"
+              "HttpOnly;SameSite=Lax;Max-Age=%d\r\n",
+              u->access_token, 3600 * 24);
+  mg_http_reply(c, 200, cookie, "{%m:%m}", MG_ESC("user"), MG_ESC(u->name));
+}
+
+static void handle_logout(struct mg_connection *c) {
+  mg_http_reply(c, 200,
+                "Set-Cookie: access_token=; Path=/; "
+                "Expires=Thu, 01 Jan 1970 00:00:00 UTC; "
+                "Secure; HttpOnly; Max-Age=0; \r\n",
+                "true\n");
+}
+
+static void handle_debug(struct mg_connection *c, struct mg_http_message *hm) {
+  int level = mg_json_get_long(hm->body, "$.level", MG_LL_DEBUG);
+  mg_log_set(level);
+  mg_http_reply(c, 200, "", "Debug level set to %d\n", level);
+}
+
+static size_t print_int_arr(void (*out)(char, void *), void *ptr, va_list *ap) {
+  size_t len = 0, num = va_arg(*ap, size_t);  // Number of items in the array
+  int *arr = va_arg(*ap, int *);              // Array ptr
+  for (size_t i = 0; i < num; i++) {
+    len += mg_xprintf(out, ptr, "%s%d", i == 0 ? "" : ",", arr[i]);
+  }
+  return len;
+}
+
+static void handle_stats_get(struct mg_connection *c) {
+  int points[] = {21, 22, 22, 19, 18, 20, 23, 23, 22, 22, 22, 23, 22};
+  mg_http_reply(c, 200, s_json_header, "{%m:%d,%m:%d,%m:[%M]}",
+                MG_ESC("temperature"), 21,  //
+                MG_ESC("humidity"), 67,     //
+                MG_ESC("points"), print_int_arr,
+                sizeof(points) / sizeof(points[0]), points);
+}
+
+static size_t print_events(void (*out)(char, void *), void *ptr, va_list *ap) {
+  size_t len = 0;
+  struct event e;
+  int no = 0;
+  while ((no = event_next(no, &e)) != 0) {
+    len += mg_xprintf(out, ptr, "%s{%m:%lu,%m:%d,%m:%d,%m:%m}",  //
+                      len == 0 ? "" : ",",                       //
+                      MG_ESC("time"), e.timestamp,               //
+                      MG_ESC("type"), e.type,                    //
+                      MG_ESC("prio"), e.prio,                    //
+                      MG_ESC("text"), MG_ESC(e.text));
+  }
+  (void) ap;
+  return len;
+}
+
+static void handle_events_get(struct mg_connection *c) {
+  mg_http_reply(c, 200, s_json_header, "[%M]", print_events);
+}
+
+static void handle_settings_set(struct mg_connection *c, struct mg_str body) {
+  struct settings settings;
+  memset(&settings, 0, sizeof(settings));
+  mg_json_get_bool(body, "$.log_enabled", &settings.log_enabled);
+  settings.log_level = mg_json_get_long(body, "$.log_level", 0);
+  settings.brightness = mg_json_get_long(body, "$.brightness", 0);
+  char *s = mg_json_get_str(body, "$.device_name");
+  if (s) free(settings.device_name), settings.device_name = s;
+
+  // Save to the device flash
+  s_settings = settings;
+  bool ok = true;
+  mg_http_reply(c, 200, s_json_header,
+                "{%m:%s,%m:%m}",                          //
+                MG_ESC("status"), ok ? "true" : "false",  //
+                MG_ESC("message"), MG_ESC(ok ? "Success" : "Failed"));
+}
+
+static void handle_settings_get(struct mg_connection *c) {
+  mg_http_reply(c, 200, s_json_header, "{%m:%s,%m:%hhu,%m:%hhu,%m:%m}",  //
+                MG_ESC("log_enabled"),
+                s_settings.log_enabled ? "true" : "false",    //
+                MG_ESC("log_level"), s_settings.log_level,    //
+                MG_ESC("brightness"), s_settings.brightness,  //
+                MG_ESC("device_name"), MG_ESC(s_settings.device_name));
+}
 
 // HTTP request handler function
-// fn_data: bit0 -> don't start services, bit1 -> use TLS
-void device_dashboard_fn(struct mg_connection *c, int ev, void *ev_data,
-                         void *fn_data) {
-  if (ev == MG_EV_OPEN && c->is_listening && !((size_t) fn_data & (1 << 0))) {
-    mg_timer_add(c->mgr, 1000, MG_TIMER_REPEAT, timer_metrics_fn, c->mgr);
-#ifndef DISABLE_ROUTING
-    mg_timer_add(c->mgr, 1000, MG_TIMER_REPEAT, timer_mqtt_fn, c->mgr);
-    mg_timer_add(c->mgr, 1000, MG_TIMER_REPEAT, timer_sntp_fn, c->mgr);
-#endif
-    s_config.url = strdup(MQTT_SERVER);
-    s_config.pub = strdup(MQTT_PUBLISH_TOPIC);
-    s_config.sub = strdup(MQTT_SUBSCRIBE_TOPIC);
-  } else if (ev == MG_EV_ACCEPT && ((size_t) fn_data & (1 << 1))) {
+static void fn(struct mg_connection *c, int ev, void *ev_data, void *fn_data) {
+  if (ev == MG_EV_ACCEPT && fn_data != NULL) {
     struct mg_tls_opts opts = {.cert = s_ssl_cert, .certkey = s_ssl_key};
     mg_tls_init(c, &opts);
   } else if (ev == MG_EV_HTTP_MSG) {
     struct mg_http_message *hm = (struct mg_http_message *) ev_data;
-    struct user *u = getuser(hm);
-    // MG_INFO(("%p [%.*s] auth %s", c->fd, (int) hm->uri.len, hm->uri.ptr,
-    // u ? u->name : "NULL"));
-    if (mg_http_match_uri(hm, "/api/hi")) {
-      mg_http_reply(c, 200, "", "hi\n");  // Testing endpoint
-    } else if (mg_http_match_uri(hm, "/api/debug")) {
-      int level = mg_json_get_long(hm->body, "$.level", MG_LL_DEBUG);
-      mg_log_set(level);
-      mg_http_reply(c, 200, "", "Debug level set to %d\n", level);
-    } else if (u == NULL && mg_http_match_uri(hm, "/api/#")) {
-      // All URIs starting with /api/ must be authenticated
-      mg_http_reply(c, 403, "", "Denied\n");
-    } else if (mg_http_match_uri(hm, "/api/config/get")) {
-#ifdef DISABLE_ROUTING
-      mg_http_reply(c, 200, NULL, "{%m:%m,%m:%m,%m:%m}\n", MG_ESC("url"),
-                    MG_ESC(s_config.url), MG_ESC("pub"), MG_ESC(s_config.pub),
-                    MG_ESC("sub"), MG_ESC(s_config.sub));
-#else
-      mg_http_reply(c, 200, NULL, "{%m:%m,%m:%m,%m:%m,%m:%s}\n", MG_ESC("url"),
-                    MG_ESC(s_config.url), MG_ESC("pub"), MG_ESC(s_config.pub),
-                    MG_ESC("sub"), MG_ESC(s_config.sub), MG_ESC("connected"),
-                    s_connected ? "true" : "false");
-#endif
-    } else if (mg_http_match_uri(hm, "/api/config/set")) {
-      // Admins only
-      if (strcmp(u->name, "admin") == 0) {
-        update_config(&hm->body, "url", &s_config.url);
-        update_config(&hm->body, "pub", &s_config.pub);
-        update_config(&hm->body, "sub", &s_config.sub);
-        if (s_mqtt) s_mqtt->is_closing = 1;  // Ask to disconnect from MQTT
-        send_notification(c->mgr, "{%m:%m,%m:null}", MG_ESC("name"),
-                          MG_ESC("config"), MG_ESC("data"));
-        mg_http_reply(c, 200, "", "ok\n");
-      } else {
-        mg_http_reply(c, 403, "", "Denied\n");
-      }
-    } else if (mg_http_match_uri(hm, "/api/message/send")) {
-      char buf[256];
-      if (s_connected &&
-          mg_http_get_var(&hm->body, "message", buf, sizeof(buf)) > 0) {
-        struct mg_mqtt_opts pub_opts;
-        memset(&pub_opts, 0, sizeof(pub_opts));
-        pub_opts.topic = mg_str(s_config.pub);
-        pub_opts.message = mg_str(buf);
-        pub_opts.qos = 2, pub_opts.retain = false;
+    struct user *u = authenticate(hm);
 
-        mg_mqtt_pub(s_mqtt, &pub_opts);
-      }
-      mg_http_reply(c, 200, "", "ok\n");
-    } else if (mg_http_match_uri(hm, "/api/watch")) {
-      c->data[0] = 'W';  // Mark ourselves as a event listener
-      mg_ws_upgrade(c, hm, NULL);
+    if (mg_http_match_uri(hm, "/api/#") && u == NULL) {
+      mg_http_reply(c, 403, "", "Not Authorised\n");
     } else if (mg_http_match_uri(hm, "/api/login")) {
-      mg_http_reply(c, 200, NULL, "{%m:%m,%m:%m}\n", MG_ESC("user"),
-                    MG_ESC(u->name), MG_ESC("token"), MG_ESC(u->token));
+      handle_login(c, u);
+    } else if (mg_http_match_uri(hm, "/api/logout")) {
+      handle_logout(c);
+    } else if (mg_http_match_uri(hm, "/api/debug")) {
+      handle_debug(c, hm);
+    } else if (mg_http_match_uri(hm, "/api/stats/get")) {
+      handle_stats_get(c);
+    } else if (mg_http_match_uri(hm, "/api/events/get")) {
+      handle_events_get(c);
+    } else if (mg_http_match_uri(hm, "/api/settings/get")) {
+      handle_settings_get(c);
+    } else if (mg_http_match_uri(hm, "/api/settings/set")) {
+      handle_settings_set(c, hm->body);
     } else {
       struct mg_http_serve_opts opts;
       memset(&opts, 0, sizeof(opts));
-#ifndef DISABLE_PACKEDFS
-      opts.root_dir = "/web_root";
+#if MG_ENABLE_PACKED_FS
       opts.fs = &mg_fs_packed;
 #else
       opts.root_dir = "web_root";
@@ -290,3 +248,16 @@ void device_dashboard_fn(struct mg_connection *c, int ev, void *ev_data,
               &c->send.buf[9]));
   }
 }
+
+void web_init(struct mg_mgr *mgr) {
+  s_settings.device_name = strdup("My Device");
+
+  mg_http_listen(mgr, HTTP_URL, fn, NULL);
+#if MG_ENABLE_MBEDTLS || MG_ENABLE_OPENSSL
+  mg_http_listen(mgr, HTTPS_URL, fn, "");
+#endif
+
+  // mg_timer_add(c->mgr, 1000, MG_TIMER_REPEAT, timer_mqtt_fn, c->mgr);
+  mg_timer_add(mgr, 3600 * 1000, MG_TIMER_RUN_NOW | MG_TIMER_REPEAT,
+               timer_sntp_fn, mgr);
+}