Files
led-driver/main/web.cpp
T
jimmyandClaude Haiku 5.5 d32f3d69cf feat: control several drivers from one web UI
- Device dropdown: All devices, this device by name, then drivers found by
  mDNS (tagged app=led-strip) and any added by hand.
- POST /api/relay: a driver calls another driver's API for the page, so the
  browser only talks to its own board. Limited to /api/*, /ota and /reboot.
- All devices sends brightness and preset plays to every device.
- Settings: sync this device's presets, order and startup to the others.
- CORS for LAN and localhost origins, and an OPTIONS handler for /ota.
- Header labels are removed; the controls keep aria-labels.

Co-Authored-By: Claude Haiku 5.5 <noreply@anthropic.com>
2026-11-11 02:48:48 +13:00

916 lines
31 KiB
C++

/*
* SPDX-License-Identifier: Apache-2.0
*/
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include "cJSON.h"
#include "esp_http_client.h"
#include "mdns.h"
#include "esp_http_server.h"
#include "esp_log.h"
#include "esp_netif.h"
#include "esp_wifi.h"
#include "net.h"
#include "ota.h"
#include "ddp.h"
#include "patterns.h"
#include "effects.h"
#include "presets.h"
#include "settings.h"
#include "web.h"
static const char *TAG = "web";
// Files embedded from web/ (see main/CMakeLists.txt EMBED_TXTFILES)
extern const char index_html_start[] asm("_binary_index_html_start");
extern const char index_html_end[] asm("_binary_index_html_end");
extern const char app_js_start[] asm("_binary_app_js_start");
extern const char app_js_end[] asm("_binary_app_js_end");
extern const char style_css_start[] asm("_binary_style_css_start");
extern const char style_css_end[] asm("_binary_style_css_end");
static httpd_handle_t s_server;
#define MAX_BODY 1024
#define MAX_SCAN 20
static esp_err_t send_embedded(httpd_req_t *req, const char *type, const char *start, const char *end)
{
httpd_resp_set_type(req, type);
httpd_resp_set_hdr(req, "Cache-Control", "no-cache");
// EMBED_TXTFILES includes the file's terminating NUL; don't send it
size_t len = end - start;
if (len > 0 && start[len - 1] == '\0') {
len--;
}
return httpd_resp_send(req, start, len);
}
// True for http://<private IPv4>, http://<name>.local and localhost, with an optional port.
// Pages on the internet are refused, so only the LAN and this computer can read the API cross-origin.
static bool origin_is_lan(const char *o)
{
static const char prefix[] = "http://";
if (strncmp(o, prefix, sizeof(prefix) - 1) != 0) {
return false;
}
char host[64];
const char *p = o + sizeof(prefix) - 1;
size_t n = 0;
while (p[n] && p[n] != ':') {
if (n + 1 >= sizeof(host)) {
return false;
}
host[n] = p[n];
n++;
}
host[n] = '\0';
if (p[n] == ':') { // port: digits only
for (const char *q = p + n + 1; *q; q++) {
if (*q < '0' || *q > '9') {
return false;
}
}
}
if (n == 0) {
return false;
}
if (strcmp(host, "localhost") == 0) {
return true;
}
size_t len = strlen(host);
if (len > 6 && strcmp(host + len - 6, ".local") == 0) {
for (size_t i = 0; i < len - 6; i++) {
char c = host[i];
bool ok = (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || c == '-' || c == '.';
if (!ok) {
return false;
}
}
return true;
}
unsigned a, b, c, d;
char extra;
if (sscanf(host, "%u.%u.%u.%u%c", &a, &b, &c, &d, &extra) != 4) {
return false;
}
for (const char *q = host; *q; q++) {
if (!((*q >= '0' && *q <= '9') || *q == '.')) {
return false;
}
}
if (a > 255 || b > 255 || c > 255 || d > 255) {
return false;
}
return a == 10 || (a == 192 && b == 168) || (a == 172 && b >= 16 && b <= 31);
}
void web_allow_lan_origin(httpd_req_t *req)
{
// The httpd server runs one handler at a time, and the header keeps a pointer to this buffer
// until the reply is sent, so a static buffer is safe here.
static char origin[96];
if (httpd_req_get_hdr_value_str(req, "Origin", origin, sizeof(origin)) != ESP_OK) {
return;
}
if (!origin_is_lan(origin)) {
return;
}
httpd_resp_set_hdr(req, "Access-Control-Allow-Origin", origin);
httpd_resp_set_hdr(req, "Vary", "Origin");
}
static esp_err_t send_json(httpd_req_t *req, cJSON *obj)
{
char *s = cJSON_PrintUnformatted(obj);
cJSON_Delete(obj);
web_allow_lan_origin(req);
if (!s) {
return httpd_resp_send_500(req);
}
httpd_resp_set_type(req, "application/json");
esp_err_t err = httpd_resp_sendstr(req, s);
cJSON_free(s);
return err;
}
static esp_err_t send_error(httpd_req_t *req, const char *status, const char *msg)
{
httpd_resp_set_status(req, status);
cJSON *o = cJSON_CreateObject();
cJSON_AddStringToObject(o, "error", msg);
return send_json(req, o);
}
// Read the request body into buf (NUL-terminated). False if missing, too big or unreadable.
static bool read_body(httpd_req_t *req, char *buf, size_t cap)
{
int len = req->content_len;
if (len <= 0 || (size_t)len >= cap) {
return false;
}
int got = 0;
while (got < len) {
int r = httpd_req_recv(req, buf + got, len - got);
if (r <= 0) {
return false;
}
got += r;
}
buf[got] = '\0';
return true;
}
// Read a JSON body; NULL (no reply sent) if missing, too big or not JSON. Caller frees with cJSON_Delete.
static cJSON *read_json(httpd_req_t *req)
{
char body[MAX_BODY];
if (!read_body(req, body, sizeof(body))) {
return NULL;
}
return cJSON_Parse(body);
}
// GET / , /app.js , /style.css
static esp_err_t index_get(httpd_req_t *req)
{
return send_embedded(req, "text/html", index_html_start, index_html_end);
}
static esp_err_t app_js_get(httpd_req_t *req)
{
return send_embedded(req, "application/javascript", app_js_start, app_js_end);
}
static esp_err_t style_css_get(httpd_req_t *req)
{
return send_embedded(req, "text/css", style_css_start, style_css_end);
}
// GET /api/status : the running preset (same fields as a preset), plus device and network state
static esp_err_t status_get(httpd_req_t *req)
{
preset_t p;
patterns_get(&p);
char ap[16], ip[16];
net_ap_ssid(ap, sizeof(ap));
bool up = net_sta_status(ip, sizeof(ip));
net_cfg_t n;
settings_load_net(&n);
cJSON *o = preset_to_json(&p);
cJSON_AddStringToObject(o, "ap_ssid", ap);
cJSON_AddStringToObject(o, "hostname", n.hostname);
cJSON_AddBoolToObject(o, "sta_connected", up);
cJSON_AddStringToObject(o, "sta_ip", ip);
cJSON_AddStringToObject(o, "selected", presets_selected());
cJSON_AddNumberToObject(o, "global_brightness", patterns_get_global());
cJSON *modes = cJSON_AddArrayToObject(o, "patterns");
for (int i = 0; i < patterns_count(); i++) {
cJSON_AddItemToArray(modes, cJSON_CreateString(patterns_name(i)));
}
return send_json(req, o);
}
// POST /api/pattern : change the running settings. Fields missing from the body keep their value.
static esp_err_t pattern_post(httpd_req_t *req)
{
cJSON *in = read_json(req);
if (!in) {
return send_error(req, "400 Bad Request", "empty, too large or invalid JSON");
}
preset_t p;
patterns_get(&p);
bool ok = preset_from_json(in, &p);
cJSON_Delete(in);
if (!ok) {
return send_error(req, "400 Bad Request", "unknown pattern");
}
patterns_set(p);
return send_json(req, cJSON_CreateObject());
}
// GET /api/wifi : saved client SSID and connection state
static esp_err_t wifi_get(httpd_req_t *req)
{
wifi_creds_t c = {};
settings_load_wifi(&c);
char ip[16];
bool up = net_sta_status(ip, sizeof(ip));
cJSON *o = cJSON_CreateObject();
cJSON_AddStringToObject(o, "ssid", c.ssid);
cJSON_AddBoolToObject(o, "connected", up);
cJSON_AddStringToObject(o, "ip", ip);
return send_json(req, o);
}
// POST /api/wifi {"ssid","password"} : save and connect
static esp_err_t wifi_post(httpd_req_t *req)
{
char body[MAX_BODY];
if (!read_body(req, body, sizeof(body))) {
return send_error(req, "400 Bad Request", "empty or too large body");
}
cJSON *in = cJSON_Parse(body);
if (!in) {
return send_error(req, "400 Bad Request", "invalid JSON");
}
cJSON *ssid = cJSON_GetObjectItem(in, "ssid");
cJSON *pass = cJSON_GetObjectItem(in, "password");
const char *pw = cJSON_IsString(pass) ? pass->valuestring : "";
if (!cJSON_IsString(ssid) || !ssid->valuestring[0] || strlen(ssid->valuestring) > 32) {
cJSON_Delete(in);
return send_error(req, "400 Bad Request", "SSID must be 1-32 characters");
}
size_t plen = strlen(pw);
if (plen > 0 && (plen < 8 || plen > 64)) {
cJSON_Delete(in);
return send_error(req, "400 Bad Request", "password must be empty or 8-64 characters");
}
wifi_creds_t c = {};
strncpy(c.ssid, ssid->valuestring, sizeof(c.ssid) - 1);
strncpy(c.pass, pw, sizeof(c.pass) - 1);
cJSON_Delete(in);
esp_err_t err = net_sta_connect(&c);
if (err != ESP_OK) {
ESP_LOGW(TAG, "Connect to %s failed: %s", c.ssid, esp_err_to_name(err));
return send_error(req, "500 Internal Server Error", esp_err_to_name(err));
}
cJSON *o = cJSON_CreateObject();
cJSON_AddStringToObject(o, "message", "saved; connecting");
return send_json(req, o);
}
// GET /api/wifi/scan : visible networks
static esp_err_t wifi_scan_get(httpd_req_t *req)
{
static wifi_ap_record_t recs[MAX_SCAN];
uint16_t count = MAX_SCAN;
esp_err_t err = net_scan(recs, &count);
if (err != ESP_OK) {
return send_error(req, "500 Internal Server Error", esp_err_to_name(err));
}
cJSON *arr = cJSON_CreateArray();
for (int i = 0; i < count; i++) {
cJSON *o = cJSON_CreateObject();
cJSON_AddStringToObject(o, "ssid", (const char *)recs[i].ssid);
cJSON_AddNumberToObject(o, "rssi", recs[i].rssi);
cJSON_AddBoolToObject(o, "open", recs[i].authmode == WIFI_AUTH_OPEN);
cJSON_AddItemToArray(arr, o);
}
cJSON *root = cJSON_CreateObject();
cJSON_AddItemToObject(root, "networks", arr);
return send_json(req, root);
}
// A DNS label: 1-63 letters, digits or hyphens, not starting or ending with a hyphen
static bool valid_hostname(const char *s)
{
size_t n = strlen(s);
if (n == 0 || n > 63 || s[0] == '-' || s[n - 1] == '-') {
return false;
}
for (size_t i = 0; i < n; i++) {
char c = s[i];
bool ok = (c >= 'a' && c <= 'z') || (c >= '0' && c <= '9') || c == '-';
if (!ok) {
return false;
}
}
return true;
}
static bool valid_ipv4(const char *s)
{
esp_ip4_addr_t a;
return s && s[0] && esp_netif_str_to_ip4(s, &a) == ESP_OK;
}
// GET /api/network : mDNS name and client address settings, with the current address
static esp_err_t network_get(httpd_req_t *req)
{
net_cfg_t n;
settings_load_net(&n);
char ip[16];
bool up = net_sta_status(ip, sizeof(ip));
cJSON *o = cJSON_CreateObject();
cJSON_AddStringToObject(o, "hostname", n.hostname);
cJSON_AddStringToObject(o, "mode", n.use_static ? "static" : "dhcp");
cJSON_AddStringToObject(o, "ip", n.ip);
cJSON_AddStringToObject(o, "netmask", n.netmask);
cJSON_AddStringToObject(o, "gateway", n.gateway);
cJSON_AddStringToObject(o, "dns", n.dns);
cJSON_AddBoolToObject(o, "connected", up);
cJSON_AddStringToObject(o, "current_ip", ip);
return send_json(req, o);
}
// POST /api/network {"hostname","mode":"dhcp"|"static","ip","netmask","gateway","dns"}
// Missing fields keep their current value. Saves, applies and reconnects the client.
static esp_err_t network_post(httpd_req_t *req)
{
cJSON *in = read_json(req);
if (!in) {
return send_error(req, "400 Bad Request", "empty, too large or invalid JSON");
}
net_cfg_t n;
settings_load_net(&n);
cJSON *h = cJSON_GetObjectItem(in, "hostname");
if (cJSON_IsString(h)) {
char name[64];
strncpy(name, h->valuestring, sizeof(name) - 1);
name[sizeof(name) - 1] = '\0';
for (char *p = name; *p; p++) {
if (*p >= 'A' && *p <= 'Z') *p = *p - 'A' + 'a';
}
if (!valid_hostname(name)) {
cJSON_Delete(in);
return send_error(req, "400 Bad Request", "hostname: 1-63 letters, digits or hyphens");
}
strncpy(n.hostname, name, sizeof(n.hostname) - 1);
}
cJSON *mode = cJSON_GetObjectItem(in, "mode");
if (cJSON_IsString(mode)) {
if (strcmp(mode->valuestring, "static") == 0) {
n.use_static = true;
} else if (strcmp(mode->valuestring, "dhcp") == 0) {
n.use_static = false;
} else {
cJSON_Delete(in);
return send_error(req, "400 Bad Request", "mode must be dhcp or static");
}
}
struct { const char *key; char *dst; size_t len; } fields[] = {
{ "ip", n.ip, sizeof(n.ip) },
{ "netmask", n.netmask, sizeof(n.netmask) },
{ "gateway", n.gateway, sizeof(n.gateway) },
{ "dns", n.dns, sizeof(n.dns) },
};
for (auto &f : fields) {
cJSON *v = cJSON_GetObjectItem(in, f.key);
if (cJSON_IsString(v)) {
strncpy(f.dst, v->valuestring, f.len - 1);
f.dst[f.len - 1] = '\0';
}
}
cJSON_Delete(in);
if (n.use_static) {
if (!valid_ipv4(n.ip) || !valid_ipv4(n.netmask) || !valid_ipv4(n.gateway)) {
return send_error(req, "400 Bad Request", "static mode needs ip, netmask and gateway as IPv4 addresses");
}
if (n.dns[0] && !valid_ipv4(n.dns)) {
return send_error(req, "400 Bad Request", "dns must be an IPv4 address or empty");
}
}
esp_err_t err = net_save_network(&n);
if (err != ESP_OK) {
ESP_LOGW(TAG, "Network apply failed: %s", esp_err_to_name(err));
return send_error(req, "500 Internal Server Error", esp_err_to_name(err));
}
// With a static address the page's current address changes, so say where to go next
char addr[80];
if (n.use_static) {
snprintf(addr, sizeof(addr), "%s", n.ip);
} else {
snprintf(addr, sizeof(addr), "%s.local", n.hostname);
}
cJSON *o = cJSON_CreateObject();
cJSON_AddStringToObject(o, "message", "saved; reconnecting");
cJSON_AddStringToObject(o, "address", addr);
return send_json(req, o);
}
// ---- presets -----------------------------------------------------------------------------------
// ---- LED strip hardware ------------------------------------------------------------------------
static bool valid_order(const char *s)
{
if (strlen(s) != 3) return false;
bool seen[3] = { false, false, false };
for (int i = 0; i < 3; i++) {
int k = s[i] == 'r' ? 0 : (s[i] == 'g' ? 1 : (s[i] == 'b' ? 2 : -1));
if (k < 0 || seen[k]) return false;
seen[k] = true;
}
return true;
}
// GPIOs that can drive the strip on the ESP32-C3: not the flash (11-17) or the USB (18, 19)
static bool valid_pin(int pin)
{
return (pin >= 0 && pin <= 10) || pin == 20 || pin == 21;
}
// GET /api/hardware : LED strip settings
static esp_err_t hardware_get(httpd_req_t *req)
{
hw_cfg_t hw;
settings_load_hw(&hw);
cJSON *o = cJSON_CreateObject();
cJSON_AddStringToObject(o, "rgb_order", hw.order);
cJSON_AddNumberToObject(o, "max_brightness", hw.max_brightness);
cJSON_AddNumberToObject(o, "num_leds", hw.num_leds);
cJSON_AddNumberToObject(o, "pin", hw.pin);
return send_json(req, o);
}
// POST /api/hardware {"rgb_order","max_brightness":0-255,"num_leds":1-512}. Missing fields keep their value.
static esp_err_t hardware_post(httpd_req_t *req)
{
cJSON *in = read_json(req);
if (!in) {
return send_error(req, "400 Bad Request", "empty, too large or invalid JSON");
}
hw_cfg_t hw;
settings_load_hw(&hw);
cJSON *v = cJSON_GetObjectItem(in, "rgb_order");
if (cJSON_IsString(v)) {
char order[4];
for (int i = 0; i < 3; i++) order[i] = (char)(v->valuestring[i] >= 'A' && v->valuestring[i] <= 'Z' ? v->valuestring[i] + 32 : v->valuestring[i]);
order[3] = '\0';
if (!valid_order(order)) {
cJSON_Delete(in);
return send_error(req, "400 Bad Request", "rgb_order must be rgb, rbg, grb, gbr, brg or bgr");
}
strncpy(hw.order, order, sizeof(hw.order));
}
v = cJSON_GetObjectItem(in, "max_brightness");
if (cJSON_IsNumber(v)) {
if (v->valueint < 0 || v->valueint > 255) {
cJSON_Delete(in);
return send_error(req, "400 Bad Request", "max_brightness must be 0-255");
}
hw.max_brightness = (uint8_t)v->valueint;
}
v = cJSON_GetObjectItem(in, "num_leds");
if (cJSON_IsNumber(v)) {
if (v->valueint < 1 || v->valueint > FX_LEDS_MAX) {
cJSON_Delete(in);
return send_error(req, "400 Bad Request", "num_leds must be 1-512");
}
hw.num_leds = v->valueint;
}
v = cJSON_GetObjectItem(in, "pin");
if (cJSON_IsNumber(v)) {
if (!valid_pin(v->valueint)) {
cJSON_Delete(in);
return send_error(req, "400 Bad Request", "pin must be 0-10 or 20-21 (not 11-19, which the flash and USB use)");
}
hw.pin = v->valueint;
}
cJSON_Delete(in);
esp_err_t err = patterns_set_hardware(hw);
if (err != ESP_OK) {
return send_error(req, "500 Internal Server Error", esp_err_to_name(err));
}
err = settings_save_hw(&hw);
if (err != ESP_OK) {
return send_error(req, "500 Internal Server Error", esp_err_to_name(err));
}
cJSON *o = cJSON_CreateObject();
cJSON_AddStringToObject(o, "message", "saved");
return send_json(req, o);
}
// GET /api/ddp[?led=N] : DDP receiver state, and the colour shown on LED N (for checks)
static esp_err_t ddp_get(httpd_req_t *req)
{
bool active;
uint32_t packets;
patterns_ddp_status(&active, &packets);
int led = 0;
char q[32];
if (httpd_req_get_url_query_str(req, q, sizeof(q)) == ESP_OK) {
char v[8];
if (httpd_query_key_value(q, "led", v, sizeof(v)) == ESP_OK) {
led = atoi(v);
}
}
uint8_t px[3];
patterns_shown_pixel(led, px);
cJSON *o = cJSON_CreateObject();
cJSON_AddBoolToObject(o, "active", active);
cJSON_AddNumberToObject(o, "packets", packets);
cJSON_AddNumberToObject(o, "port", DDP_PORT);
cJSON_AddNumberToObject(o, "led", led);
cJSON *px_arr = cJSON_AddArrayToObject(o, "rgb");
for (int i = 0; i < 3; i++) {
cJSON_AddItemToArray(px_arr, cJSON_CreateNumber(px[i]));
}
return send_json(req, o);
}
// POST /api/presets/order {"names":[...]} : the presets' order on the front page
static esp_err_t presets_order_post(httpd_req_t *req)
{
cJSON *in = read_json(req);
if (!in) {
return send_error(req, "400 Bad Request", "empty, too large or invalid JSON");
}
cJSON *arr = cJSON_GetObjectItem(in, "names");
if (!cJSON_IsArray(arr)) {
cJSON_Delete(in);
return send_error(req, "400 Bad Request", "names must be a list");
}
const char *names[PRESETS_MAX];
size_t n = 0;
cJSON *item;
cJSON_ArrayForEach(item, arr) {
if (n < PRESETS_MAX && cJSON_IsString(item)) {
names[n++] = item->valuestring;
}
}
presets_set_order(names, n);
cJSON_Delete(in);
cJSON *o = cJSON_CreateObject();
cJSON_AddStringToObject(o, "message", "saved");
return send_json(req, o);
}
// POST /api/presets/defaults : add the default presets that are missing
static esp_err_t presets_defaults_post(httpd_req_t *req)
{
cJSON *o = cJSON_CreateObject();
cJSON_AddNumberToObject(o, "added", presets_add_defaults());
return send_json(req, o);
}
// GET /api/presets
static esp_err_t presets_get(httpd_req_t *req)
{
cJSON *o = cJSON_CreateObject();
cJSON *arr = cJSON_AddArrayToObject(o, "presets");
for (size_t i = 0; i < presets_count(); i++) {
cJSON_AddItemToArray(arr, preset_to_json(presets_at(i)));
}
cJSON_AddStringToObject(o, "selected", presets_selected());
cJSON_AddStringToObject(o, "startup", presets_startup());
cJSON_AddNumberToObject(o, "max", PRESETS_MAX);
return send_json(req, o);
}
// POST /api/brightness {"brightness":0-255} : live brightness for every pattern, saved
static esp_err_t brightness_post(httpd_req_t *req)
{
cJSON *in = read_json(req);
if (!in) {
return send_error(req, "400 Bad Request", "empty, too large or invalid JSON");
}
cJSON *v = cJSON_GetObjectItem(in, "brightness");
if (!cJSON_IsNumber(v) || v->valueint < 0 || v->valueint > 255) {
cJSON_Delete(in);
return send_error(req, "400 Bad Request", "brightness must be 0-255");
}
uint8_t level = (uint8_t)v->valueint;
cJSON_Delete(in);
patterns_set_global(level);
hw_cfg_t hw;
settings_load_hw(&hw);
hw.global_brightness = level;
settings_save_hw(&hw);
cJSON *o = cJSON_CreateObject();
cJSON_AddStringToObject(o, "message", "saved");
return send_json(req, o);
}
// POST /api/presets : create or update by name. Missing fields take the running settings.
static esp_err_t presets_post(httpd_req_t *req)
{
cJSON *in = read_json(req);
if (!in) {
return send_error(req, "400 Bad Request", "empty, too large or invalid JSON");
}
cJSON *name = cJSON_GetObjectItem(in, "name");
if (!cJSON_IsString(name) || !name->valuestring[0] || strlen(name->valuestring) >= 32) {
cJSON_Delete(in);
return send_error(req, "400 Bad Request", "name must be 1-31 characters");
}
preset_t pr;
patterns_get(&pr);
bool ok = preset_from_json(in, &pr);
cJSON_Delete(in);
if (!ok) {
return send_error(req, "400 Bad Request", "unknown pattern");
}
esp_err_t err = presets_save(&pr);
if (err == ESP_ERR_NO_MEM) {
return send_error(req, "400 Bad Request", "preset list is full");
}
if (err != ESP_OK) {
return send_error(req, "500 Internal Server Error", esp_err_to_name(err));
}
cJSON *o = cJSON_CreateObject();
cJSON_AddStringToObject(o, "message", "saved");
return send_json(req, o);
}
// Shared body for select, delete and startup: {"name"}
static esp_err_t preset_name_action(httpd_req_t *req, esp_err_t (*action)(const char *), const char *ok_msg)
{
cJSON *in = read_json(req);
if (!in) {
return send_error(req, "400 Bad Request", "empty, too large or invalid JSON");
}
cJSON *name = cJSON_GetObjectItem(in, "name");
if (!cJSON_IsString(name)) {
cJSON_Delete(in);
return send_error(req, "400 Bad Request", "name is required");
}
char buf[32];
strncpy(buf, name->valuestring, sizeof(buf) - 1);
buf[sizeof(buf) - 1] = '\0';
cJSON_Delete(in);
esp_err_t err = action(buf);
if (err == ESP_ERR_NOT_FOUND) {
return send_error(req, "404 Not Found", "no such preset");
}
if (err != ESP_OK) {
return send_error(req, "500 Internal Server Error", esp_err_to_name(err));
}
cJSON *o = cJSON_CreateObject();
cJSON_AddStringToObject(o, "message", ok_msg);
return send_json(req, o);
}
static esp_err_t select_post(httpd_req_t *req)
{
return preset_name_action(req, presets_select, "selected");
}
static esp_err_t delete_post(httpd_req_t *req)
{
return preset_name_action(req, presets_delete, "deleted");
}
static esp_err_t startup_post(httpd_req_t *req)
{
return preset_name_action(req, presets_set_startup, "startup set");
}
static void add_uri(httpd_handle_t srv, const char *uri, httpd_method_t method, esp_err_t (*handler)(httpd_req_t *))
{
httpd_uri_t u = { .uri = uri, .method = method, .handler = handler, .user_ctx = NULL };
httpd_register_uri_handler(srv, &u);
}
// Host part of a relay target: letters, digits, dots, dashes and an optional :port.
static bool relay_host_ok(const char *h)
{
size_t n = strlen(h);
if (n == 0 || n > 80) {
return false;
}
for (const char *p = h; *p; p++) {
char c = *p;
bool ok = (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || c == '.' || c == '-' || c == ':';
if (!ok) {
return false;
}
}
return true;
}
// Only this driver's own API and its firmware info and reboot, so the relay cannot reach other services.
static bool relay_path_ok(const char *p)
{
if (strcmp(p, "/ota") == 0 || strcmp(p, "/reboot") == 0) {
return true;
}
if (strncmp(p, "/api/", 5) != 0 || strcmp(p, "/api/relay") == 0 || strlen(p) > 120) {
return false;
}
return strstr(p, "..") == NULL && strchr(p, ' ') == NULL && strchr(p, '\r') == NULL && strchr(p, '\n') == NULL;
}
// POST /api/relay {"host": "10.1.1.50", "method": "GET" or "POST", "path": "/api/status", "body": "..."}
// Calls another driver from here and answers {"status": n, "body": "..."}. A page on this driver only
// talks to this driver, so the browser never has to reach the other device itself.
static esp_err_t relay_post(httpd_req_t *req)
{
// Heap buffers: the HTTP server task has an 8 KB stack
char *in = (char *)malloc(2048);
char *out = (char *)malloc(4096);
if (!in || !out) {
free(in);
free(out);
return send_error(req, "503 Service Unavailable", "out of memory");
}
esp_err_t result = ESP_FAIL;
if (!read_body(req, in, 2048)) {
result = send_error(req, "400 Bad Request", "empty, too large or invalid JSON");
goto done;
} else {
cJSON *top = cJSON_Parse(in);
const cJSON *jh = top ? cJSON_GetObjectItem(top, "host") : NULL;
const cJSON *jm = top ? cJSON_GetObjectItem(top, "method") : NULL;
const cJSON *jp = top ? cJSON_GetObjectItem(top, "path") : NULL;
const cJSON *jb = top ? cJSON_GetObjectItem(top, "body") : NULL;
if (!cJSON_IsString(jh) || !cJSON_IsString(jm) || !cJSON_IsString(jp) || !relay_host_ok(jh->valuestring)
|| !relay_path_ok(jp->valuestring) || (strcmp(jm->valuestring, "GET") != 0 && strcmp(jm->valuestring, "POST") != 0)) {
cJSON_Delete(top);
result = send_error(req, "400 Bad Request", "need host, method GET or POST, and a path under /api/");
goto done;
}
const bool is_post = strcmp(jm->valuestring, "POST") == 0;
const char *body = (is_post && cJSON_IsString(jb)) ? jb->valuestring : "";
const int body_len = (int)strlen(body);
char url[200];
snprintf(url, sizeof(url), "http://%s%s", jh->valuestring, jp->valuestring);
esp_http_client_config_t ccfg = {};
ccfg.url = url;
ccfg.method = is_post ? HTTP_METHOD_POST : HTTP_METHOD_GET;
ccfg.timeout_ms = 4000;
esp_http_client_handle_t cl = esp_http_client_init(&ccfg);
if (!cl) {
cJSON_Delete(top);
result = send_error(req, "502 Bad Gateway", "could not start the request");
goto done;
}
esp_http_client_set_header(cl, "Content-Type", "text/plain");
esp_err_t err = esp_http_client_open(cl, is_post ? body_len : 0);
if (err == ESP_OK && is_post && body_len > 0) {
if (esp_http_client_write(cl, body, body_len) != body_len) {
err = ESP_FAIL;
}
}
int got = 0;
int status = 0;
if (err == ESP_OK && esp_http_client_fetch_headers(cl) >= 0) {
status = esp_http_client_get_status_code(cl);
int r;
while (got < 4095 && (r = esp_http_client_read(cl, out + got, 4095 - got)) > 0) {
got += r;
}
} else {
err = ESP_FAIL;
}
esp_http_client_close(cl);
esp_http_client_cleanup(cl);
cJSON_Delete(top);
if (err != ESP_OK) {
result = send_error(req, "502 Bad Gateway", "could not reach that device");
goto done;
}
out[got] = '\0';
cJSON *o = cJSON_CreateObject();
cJSON_AddNumberToObject(o, "status", status);
cJSON_AddStringToObject(o, "body", out);
result = send_json(req, o);
}
done:
free(in);
free(out);
return result;
}
// GET /api/devices: the LED drivers on this network, found by mDNS (they advertise app=led-strip).
// Includes this driver; the page leaves it out, since "This device" is already in the list.
static esp_err_t devices_get(httpd_req_t *req)
{
cJSON *arr = cJSON_CreateArray();
mdns_result_t *res = NULL;
if (mdns_query_ptr("_http", "_tcp", 1500, 30, &res) == ESP_OK && res) {
for (mdns_result_t *r = res; r; r = r->next) {
if (!r->hostname) {
continue;
}
bool is_strip = false;
for (size_t i = 0; i < r->txt_count && r->txt; i++) {
if (r->txt[i].key && r->txt[i].value && strcmp(r->txt[i].key, "app") == 0
&& strcmp(r->txt[i].value, "led-strip") == 0) {
is_strip = true;
}
}
if (!is_strip) {
continue;
}
char ip[16] = "";
for (mdns_ip_addr_t *a = r->addr; a; a = a->next) {
if (a->addr.type == ESP_IPADDR_TYPE_V4) {
snprintf(ip, sizeof(ip), IPSTR, IP2STR(&a->addr.u_addr.ip4));
break;
}
}
if (ip[0] == '\0') {
continue;
}
bool seen = false; // one entry per address (a service can be listed twice)
for (int i = 0; i < cJSON_GetArraySize(arr); i++) {
const cJSON *ip_item = cJSON_GetObjectItem(cJSON_GetArrayItem(arr, i), "ip");
if (cJSON_IsString(ip_item) && strcmp(ip_item->valuestring, ip) == 0) {
seen = true;
}
}
if (seen) {
continue;
}
char host[96];
snprintf(host, sizeof(host), "%s.local", r->hostname);
cJSON *o = cJSON_CreateObject();
cJSON_AddStringToObject(o, "name", r->hostname);
cJSON_AddStringToObject(o, "host", host);
cJSON_AddStringToObject(o, "ip", ip);
cJSON_AddItemToArray(arr, o);
}
}
if (res) {
mdns_query_results_free(res);
}
cJSON *top = cJSON_CreateObject();
cJSON_AddItemToObject(top, "devices", arr);
return send_json(req, top);
}
esp_err_t web_start(void)
{
httpd_config_t cfg = HTTPD_DEFAULT_CONFIG();
cfg.max_uri_handlers = 30;
cfg.stack_size = 8192;
cfg.lru_purge_enable = true;
cfg.max_open_sockets = 7;
cfg.backlog_conn = 10;
esp_err_t err = httpd_start(&s_server, &cfg);
if (err != ESP_OK) {
ESP_LOGE(TAG, "HTTP server start failed: %s", esp_err_to_name(err));
return err;
}
add_uri(s_server, "/", HTTP_GET, index_get);
add_uri(s_server, "/app.js", HTTP_GET, app_js_get);
add_uri(s_server, "/style.css", HTTP_GET, style_css_get);
add_uri(s_server, "/api/status", HTTP_GET, status_get);
add_uri(s_server, "/api/pattern", HTTP_POST, pattern_post);
add_uri(s_server, "/api/wifi", HTTP_GET, wifi_get);
add_uri(s_server, "/api/wifi", HTTP_POST, wifi_post);
add_uri(s_server, "/api/wifi/scan", HTTP_GET, wifi_scan_get);
add_uri(s_server, "/api/network", HTTP_GET, network_get);
add_uri(s_server, "/api/network", HTTP_POST, network_post);
add_uri(s_server, "/api/ddp", HTTP_GET, ddp_get);
add_uri(s_server, "/api/hardware", HTTP_GET, hardware_get);
add_uri(s_server, "/api/hardware", HTTP_POST, hardware_post);
add_uri(s_server, "/api/presets", HTTP_GET, presets_get);
add_uri(s_server, "/api/presets", HTTP_POST, presets_post);
add_uri(s_server, "/api/presets/select", HTTP_POST, select_post);
add_uri(s_server, "/api/presets/delete", HTTP_POST, delete_post);
add_uri(s_server, "/api/presets/startup", HTTP_POST, startup_post);
add_uri(s_server, "/api/presets/defaults", HTTP_POST, presets_defaults_post);
add_uri(s_server, "/api/presets/order", HTTP_POST, presets_order_post);
add_uri(s_server, "/api/brightness", HTTP_POST, brightness_post);
add_uri(s_server, "/api/relay", HTTP_POST, relay_post);
add_uri(s_server, "/api/devices", HTTP_GET, devices_get);
ota_register(s_server);
ESP_LOGI(TAG, "Web UI on port 80");
return ESP_OK;
}