feat: DDP frame sync over UDP broadcast, DDP acks, DDP enable setting

- Driver acks each completed DDP frame; the test waits for the acks before broadcasting the sync.
- Sync listener on UDP 4049: a frame is held until the next sync, then shown.
- DDP pixels are shown at full brightness, ignoring the device brightness settings.
- "DDP and sync receive on" setting (NVS, network API, web UI); off ignores DDP and sync packets.
- ddp_test.py: finds devices on the subnet, drives them in lockstep at a fixed rate, runs animations.
- /api/ddp reports sync counters for diagnosis.
- Includes in-progress WebSocket, multi-driver web UI and Wi-Fi work from the same tree.

Co-Authored-By: Claude Haiku 5.5 <noreply@anthropic.com>
This commit is contained in:
jimmyandClaude Haiku 5.5 committed 2026-11-11 14:10:55 +13:00
1 parent 47f4eba0d6
commit 4cd3bc7973
294 files changed
+48954 -301

No files matched your search

+539 -129
View File
@@ -11,6 +11,9 @@
#include "esp_http_server.h"
#include "esp_log.h"
#include "esp_netif.h"
#include "esp_timer.h"
#include <netinet/tcp.h>
#include <sys/socket.h>
#include "esp_wifi.h"
#include "net.h"
#include "ota.h"
@@ -20,6 +23,7 @@
#include "presets.h"
#include "settings.h"
#include "web.h"
#include "ws_client.h"
static const char *TAG = "web";
@@ -122,38 +126,74 @@ void web_allow_lan_origin(httpd_req_t *req)
httpd_resp_set_hdr(req, "Vary", "Origin");
}
static esp_err_t send_json(httpd_req_t *req, cJSON *obj)
// One API call, from an HTTP request or from a WebSocket message. Handlers use only the helpers
// below, so the same handler serves both.
typedef struct {
httpd_req_t *http; // the HTTP request, or NULL for a WebSocket call
const char *body; // WebSocket call: the request body text
const char *query; // WebSocket call: the query string after '?', or ""
char *out; // WebSocket call: the reply text is written here
size_t out_cap;
int status; // WebSocket call: the reply's status code
} api_req_t;
typedef esp_err_t (*api_fn_t)(api_req_t *req);
// Send a JSON reply. status is a status line such as "200 OK".
static esp_err_t send_text(api_req_t *req, const char *status, const char *text)
{
if (req->http) {
web_allow_lan_origin(req->http);
httpd_resp_set_status(req->http, status);
httpd_resp_set_type(req->http, "application/json");
return httpd_resp_sendstr(req->http, text);
}
req->status = atoi(status);
snprintf(req->out, req->out_cap, "%s", text);
return ESP_OK;
}
static esp_err_t send_json(api_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);
return send_text(req, "500 Internal Server Error", "{\"error\":\"out of memory\"}");
}
httpd_resp_set_type(req, "application/json");
esp_err_t err = httpd_resp_sendstr(req, s);
esp_err_t err = send_text(req, "200 OK", s);
cJSON_free(s);
return err;
}
static esp_err_t send_error(httpd_req_t *req, const char *status, const char *msg)
static esp_err_t send_error(api_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);
char *s = cJSON_PrintUnformatted(o);
cJSON_Delete(o);
esp_err_t err = send_text(req, status, s ? s : "{}");
cJSON_free(s);
return err;
}
// 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)
static bool read_body(api_req_t *req, char *buf, size_t cap)
{
int len = req->content_len;
if (!req->http) {
size_t n = req->body ? strlen(req->body) : 0;
if (n == 0 || n >= cap) {
return false;
}
memcpy(buf, req->body, n + 1);
return true;
}
int len = req->http->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);
int r = httpd_req_recv(req->http, buf + got, len - got);
if (r <= 0) {
return false;
}
@@ -164,7 +204,7 @@ static bool read_body(httpd_req_t *req, char *buf, size_t cap)
}
// 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)
static cJSON *read_json(api_req_t *req)
{
char body[MAX_BODY];
if (!read_body(req, body, sizeof(body))) {
@@ -190,7 +230,7 @@ static esp_err_t style_css_get(httpd_req_t *req)
}
// 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)
static esp_err_t status_get(api_req_t *req)
{
preset_t p;
patterns_get(&p);
@@ -207,6 +247,7 @@ static esp_err_t status_get(httpd_req_t *req)
cJSON_AddStringToObject(o, "sta_ip", ip);
cJSON_AddStringToObject(o, "selected", presets_selected());
cJSON_AddNumberToObject(o, "global_brightness", patterns_get_global());
cJSON_AddNumberToObject(o, "master_brightness", patterns_get_master());
cJSON *modes = cJSON_AddArrayToObject(o, "patterns");
for (int i = 0; i < patterns_count(); i++) {
cJSON_AddItemToArray(modes, cJSON_CreateString(patterns_name(i)));
@@ -215,7 +256,7 @@ static esp_err_t status_get(httpd_req_t *req)
}
// 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)
static esp_err_t pattern_post(api_req_t *req)
{
cJSON *in = read_json(req);
if (!in) {
@@ -233,7 +274,7 @@ static esp_err_t pattern_post(httpd_req_t *req)
}
// GET /api/wifi : saved client SSID and connection state
static esp_err_t wifi_get(httpd_req_t *req)
static esp_err_t wifi_get(api_req_t *req)
{
wifi_creds_t c = {};
settings_load_wifi(&c);
@@ -247,7 +288,7 @@ static esp_err_t wifi_get(httpd_req_t *req)
}
// POST /api/wifi {"ssid","password"} : save and connect
static esp_err_t wifi_post(httpd_req_t *req)
static esp_err_t wifi_post(api_req_t *req)
{
char body[MAX_BODY];
if (!read_body(req, body, sizeof(body))) {
@@ -285,7 +326,7 @@ static esp_err_t wifi_post(httpd_req_t *req)
}
// GET /api/wifi/scan : visible networks
static esp_err_t wifi_scan_get(httpd_req_t *req)
static esp_err_t wifi_scan_get(api_req_t *req)
{
static wifi_ap_record_t recs[MAX_SCAN];
uint16_t count = MAX_SCAN;
@@ -330,7 +371,7 @@ static bool valid_ipv4(const char *s)
}
// GET /api/network : mDNS name and client address settings, with the current address
static esp_err_t network_get(httpd_req_t *req)
static esp_err_t network_get(api_req_t *req)
{
net_cfg_t n;
settings_load_net(&n);
@@ -345,12 +386,14 @@ static esp_err_t network_get(httpd_req_t *req)
cJSON_AddStringToObject(o, "dns", n.dns);
cJSON_AddBoolToObject(o, "connected", up);
cJSON_AddStringToObject(o, "current_ip", ip);
cJSON_AddBoolToObject(o, "ap_enabled", n.ap_enabled);
cJSON_AddBoolToObject(o, "ddp_enabled", n.ddp_enabled);
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)
static esp_err_t network_post(api_req_t *req)
{
cJSON *in = read_json(req);
if (!in) {
@@ -399,6 +442,15 @@ static esp_err_t network_post(httpd_req_t *req)
f.dst[f.len - 1] = '\0';
}
}
cJSON *ap = cJSON_GetObjectItem(in, "ap_enabled");
if (cJSON_IsBool(ap)) {
n.ap_enabled = cJSON_IsTrue(ap);
}
cJSON *ddp = cJSON_GetObjectItem(in, "ddp_enabled");
if (cJSON_IsBool(ddp)) {
n.ddp_enabled = cJSON_IsTrue(ddp);
ddp_set_enabled(n.ddp_enabled);
}
cJSON_Delete(in);
if (n.use_static) {
@@ -411,6 +463,9 @@ static esp_err_t network_post(httpd_req_t *req)
}
esp_err_t err = net_save_network(&n);
if (err == ESP_ERR_INVALID_STATE) {
return send_error(req, "400 Bad Request", "connect to a Wi-Fi network before turning the access point off");
}
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));
@@ -451,7 +506,7 @@ static bool valid_pin(int pin)
}
// GET /api/hardware : LED strip settings
static esp_err_t hardware_get(httpd_req_t *req)
static esp_err_t hardware_get(api_req_t *req)
{
hw_cfg_t hw;
settings_load_hw(&hw);
@@ -464,7 +519,7 @@ static esp_err_t hardware_get(httpd_req_t *req)
}
// 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)
static esp_err_t hardware_post(api_req_t *req)
{
cJSON *in = read_json(req);
if (!in) {
@@ -523,18 +578,21 @@ static esp_err_t hardware_post(httpd_req_t *req)
}
// 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)
static esp_err_t ddp_get(api_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);
}
char q[32] = "";
if (req->http) {
httpd_req_get_url_query_str(req->http, q, sizeof(q));
} else {
snprintf(q, sizeof(q), "%s", req->query);
}
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);
@@ -542,6 +600,16 @@ static esp_err_t ddp_get(httpd_req_t *req)
cJSON_AddBoolToObject(o, "active", active);
cJSON_AddNumberToObject(o, "packets", packets);
cJSON_AddNumberToObject(o, "port", DDP_PORT);
patterns_ddp_debug_t dbg;
patterns_ddp_debug(&dbg);
cJSON *sy = cJSON_AddObjectToObject(o, "sync");
cJSON_AddNumberToObject(sy, "port", DDP_SYNC_PORT);
cJSON_AddNumberToObject(sy, "syncs", dbg.syncs);
cJSON_AddNumberToObject(sy, "seq", dbg.sync_seq);
cJSON_AddNumberToObject(sy, "age_ms", dbg.sync_age_ms == UINT32_MAX ? -1 : (double)dbg.sync_age_ms);
cJSON_AddNumberToObject(sy, "frames", dbg.frames);
cJSON_AddNumberToObject(sy, "shown", dbg.shown);
cJSON_AddBoolToObject(sy, "held", dbg.held);
cJSON_AddNumberToObject(o, "led", led);
cJSON *px_arr = cJSON_AddArrayToObject(o, "rgb");
for (int i = 0; i < 3; i++) {
@@ -551,7 +619,7 @@ static esp_err_t ddp_get(httpd_req_t *req)
}
// POST /api/presets/order {"names":[...]} : the presets' order on the front page
static esp_err_t presets_order_post(httpd_req_t *req)
static esp_err_t presets_order_post(api_req_t *req)
{
cJSON *in = read_json(req);
if (!in) {
@@ -578,7 +646,7 @@ static esp_err_t presets_order_post(httpd_req_t *req)
}
// POST /api/presets/defaults : add the default presets that are missing
static esp_err_t presets_defaults_post(httpd_req_t *req)
static esp_err_t presets_defaults_post(api_req_t *req)
{
cJSON *o = cJSON_CreateObject();
cJSON_AddNumberToObject(o, "added", presets_add_defaults());
@@ -586,7 +654,7 @@ static esp_err_t presets_defaults_post(httpd_req_t *req)
}
// GET /api/presets
static esp_err_t presets_get(httpd_req_t *req)
static esp_err_t presets_get(api_req_t *req)
{
cJSON *o = cJSON_CreateObject();
cJSON *arr = cJSON_AddArrayToObject(o, "presets");
@@ -599,32 +667,52 @@ static esp_err_t presets_get(httpd_req_t *req)
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)
// POST /api/brightness {"brightness":0-255} sets this device's level; {"master":0-255} sets its
// master scale (sent to every device by "All devices"). Either or both, saved.
// Returns NULL when applied, or the error message.
static const char *brightness_apply(const cJSON *in)
{
const cJSON *v = cJSON_GetObjectItem(in, "brightness");
const cJSON *m = cJSON_GetObjectItem(in, "master");
if (!v && !m) {
return "send brightness and/or master";
}
if ((v && (!cJSON_IsNumber(v) || v->valueint < 0 || v->valueint > 255)) ||
(m && (!cJSON_IsNumber(m) || m->valueint < 0 || m->valueint > 255))) {
return "brightness and master must be 0-255";
}
hw_cfg_t hw;
settings_load_hw(&hw);
if (v) {
hw.global_brightness = (uint8_t)v->valueint;
patterns_set_global(hw.global_brightness);
}
if (m) {
hw.master_brightness = (uint8_t)m->valueint;
patterns_set_master(hw.master_brightness);
}
settings_save_hw(&hw);
return NULL;
}
static esp_err_t brightness_post(api_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;
const char *err = brightness_apply(in);
cJSON_Delete(in);
patterns_set_global(level);
hw_cfg_t hw;
settings_load_hw(&hw);
hw.global_brightness = level;
settings_save_hw(&hw);
if (err) {
return send_error(req, "400 Bad Request", err);
}
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)
static esp_err_t presets_post(api_req_t *req)
{
cJSON *in = read_json(req);
if (!in) {
@@ -656,7 +744,7 @@ static esp_err_t presets_post(httpd_req_t *req)
}
// 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)
static esp_err_t preset_name_action(api_req_t *req, esp_err_t (*action)(const char *), const char *ok_msg)
{
cJSON *in = read_json(req);
if (!in) {
@@ -684,24 +772,25 @@ static esp_err_t preset_name_action(httpd_req_t *req, esp_err_t (*action)(const
return send_json(req, o);
}
static esp_err_t select_post(httpd_req_t *req)
static esp_err_t select_post(api_req_t *req)
{
return preset_name_action(req, presets_select, "selected");
}
static esp_err_t delete_post(httpd_req_t *req)
static esp_err_t delete_post(api_req_t *req)
{
return preset_name_action(req, presets_delete, "deleted");
}
static esp_err_t startup_post(httpd_req_t *req)
static esp_err_t startup_post(api_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_uri_t u = { .uri = uri, .method = method, .handler = handler, .user_ctx = NULL,
.is_websocket = false, .handle_ws_control_frames = false, .supported_subprotocol = NULL };
httpd_register_uri_handler(srv, &u);
}
@@ -734,90 +823,240 @@ static bool relay_path_ok(const char *p)
return strstr(p, "..") == NULL && strchr(p, ' ') == NULL && strchr(p, '\r') == NULL && strchr(p, '\n') == NULL;
}
// Relay connections are kept open per peer, so a relayed request does not pay for a new TCP connection.
// The HTTP server runs one task, so relay calls never overlap and the slots need no lock.
#define RELAY_SLOTS 4
#define RELAY_TIMEOUT_MS 4000
struct relay_slot_t {
char host[80];
esp_http_client_handle_t cl;
};
static relay_slot_t s_relay[RELAY_SLOTS];
// The kept-open client for this host, pointed at url. A new slot evicts the oldest one.
static esp_http_client_handle_t relay_client(const char *host, const char *url)
{
int slot = -1;
for (int i = 0; i < RELAY_SLOTS; i++) {
if (s_relay[i].cl && strcmp(s_relay[i].host, host) == 0) {
slot = i;
break;
}
}
if (slot < 0) {
slot = 0;
for (int i = 0; i < RELAY_SLOTS; i++) {
if (!s_relay[i].cl) {
slot = i;
break;
}
}
if (s_relay[slot].cl) {
esp_http_client_cleanup(s_relay[slot].cl);
}
esp_http_client_config_t cfg = {};
cfg.url = url;
cfg.timeout_ms = RELAY_TIMEOUT_MS;
cfg.keep_alive_enable = true;
s_relay[slot].cl = esp_http_client_init(&cfg);
snprintf(s_relay[slot].host, sizeof(s_relay[slot].host), "%s", host);
return s_relay[slot].cl;
}
esp_http_client_set_url(s_relay[slot].cl, url);
return s_relay[slot].cl;
}
// One request to a peer over its kept-open connection. A dead connection is dropped and retried once.
static esp_err_t relay_do(const char *host, const char *url, bool is_post, const char *body, int body_len,
int *status, char *out, int cap, int *got)
{
for (int attempt = 0; attempt < 2; attempt++) {
const int64_t t0 = esp_timer_get_time();
esp_http_client_handle_t cl = relay_client(host, url);
const int64_t t_client = esp_timer_get_time();
if (!cl) {
return ESP_ERR_NO_MEM;
}
esp_http_client_set_method(cl, is_post ? HTTP_METHOD_POST : HTTP_METHOD_GET);
esp_http_client_set_header(cl, "Content-Type", "text/plain");
esp_err_t err = esp_http_client_open(cl, is_post ? body_len : 0);
const int64_t t_open = esp_timer_get_time();
if (err == ESP_OK && is_post && body_len > 0 && esp_http_client_write(cl, body, body_len) != body_len) {
err = ESP_FAIL;
}
const int64_t t_write = esp_timer_get_time();
*got = 0;
bool full = false;
int fetch_rc = -1;
if (err == ESP_OK) {
fetch_rc = esp_http_client_fetch_headers(cl);
}
const int64_t t_headers = esp_timer_get_time();
ESP_LOGI(TAG, "relay %s attempt %d: client %lld us, open %lld us, write %lld us, headers %lld us (rc %d, err %d)",
host, attempt, (long long)(t_client - t0), (long long)(t_open - t_client),
(long long)(t_write - t_open), (long long)(t_headers - t_write), fetch_rc, (int)err);
if (err == ESP_OK && fetch_rc >= 0) {
*status = esp_http_client_get_status_code(cl);
int r;
while (*got < cap && (r = esp_http_client_read(cl, out + *got, cap - *got)) > 0) {
*got += r;
}
ESP_LOGI(TAG, "relay %s body %d bytes read in %lld us", host, *got,
(long long)(esp_timer_get_time() - t_headers));
full = *got >= cap; // more body than fits: keep what fits, and drop the connection
if (!full) {
return ESP_OK;
}
esp_http_client_close(cl);
return ESP_OK;
}
// Failed before the answer: drop this connection and try once more
esp_http_client_close(cl);
}
return ESP_FAIL;
}
// Calls to a peer go over a kept-open WebSocket (its /ws), not a new HTTP request each time.
#define WS_SLOTS 4
struct ws_slot_t {
char host[80]; // empty when the slot is free
int fd;
};
static ws_slot_t s_ws[WS_SLOTS];
static void ws_slot_drop(ws_slot_t *slot)
{
ws_client_close(slot->fd);
slot->fd = -1;
slot->host[0] = '\0';
}
// Send msg to host's /ws and read the reply into reply. Reconnects once if the connection is dead.
static bool ws_fast_call(const char *host, const char *msg, char *reply, size_t cap)
{
for (int attempt = 0; attempt < 2; attempt++) {
ws_slot_t *slot = NULL;
for (int i = 0; i < WS_SLOTS; i++) {
if (s_ws[i].host[0] && strcmp(s_ws[i].host, host) == 0) {
slot = &s_ws[i];
break;
}
}
if (!slot) {
for (int i = 0; i < WS_SLOTS && !slot; i++) {
if (!s_ws[i].host[0]) {
slot = &s_ws[i];
}
}
if (!slot) {
slot = &s_ws[0];
ws_slot_drop(slot);
}
slot->fd = ws_client_connect(host, "/ws");
if (slot->fd < 0) {
slot->host[0] = '\0';
return false;
}
snprintf(slot->host, sizeof(slot->host), "%s", host);
}
if (ws_client_send_text(slot->fd, msg, strlen(msg)) == ESP_OK && ws_client_recv_text(slot->fd, reply, cap) >= 0) {
return true;
}
ws_slot_drop(slot);
}
return false;
}
// The reply to a relayed or WebSocket call: {"status": n, "body": "..."}
static void envelope(char *out, size_t cap, int status, const char *body_text)
{
cJSON *env = cJSON_CreateObject();
cJSON_AddNumberToObject(env, "status", status);
cJSON_AddStringToObject(env, "body", body_text);
char *s = cJSON_PrintUnformatted(env);
snprintf(out, cap, "%s", s ? s : "{}");
cJSON_free(s);
cJSON_Delete(env);
}
// Call another driver's API. The peer's WebSocket is tried first (kept open, so it is fast); the HTTP
// call is the fallback. out gets the envelope {"status": n, "body": "..."}.
static void relay_forward(const char *host, const char *method, const char *path, const char *body,
char *out, size_t cap)
{
if (!relay_host_ok(host) || !relay_path_ok(path) || (strcmp(method, "GET") != 0 && strcmp(method, "POST") != 0)) {
envelope(out, cap, 400, "{\"error\":\"need host, method GET or POST, and a path under /api/\"}");
return;
}
const bool is_post = strcmp(method, "POST") == 0;
const char *b = is_post ? body : "";
cJSON *m = cJSON_CreateObject();
cJSON_AddStringToObject(m, "method", method);
cJSON_AddStringToObject(m, "path", path);
cJSON_AddStringToObject(m, "body", b);
char *msg = cJSON_PrintUnformatted(m);
cJSON_Delete(m);
bool ok = msg && ws_fast_call(host, msg, out, cap); // the peer's reply is already an envelope
cJSON_free(msg);
if (ok) {
return;
}
char *buf = (char *)malloc(4096);
if (!buf) {
envelope(out, cap, 503, "{\"error\":\"out of memory\"}");
return;
}
char url[200];
snprintf(url, sizeof(url), "http://%s%s", host, path);
int got = 0;
int status = 0;
if (relay_do(host, url, is_post, b, (int)strlen(b), &status, buf, 4095, &got) != ESP_OK) {
envelope(out, cap, 502, "{\"error\":\"could not reach that device\"}");
} else {
buf[got] = '\0';
envelope(out, cap, status, buf);
}
free(buf);
}
// 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)
// Kept for HTTP callers; the page itself sends relayed calls over the WebSocket.
static esp_err_t relay_post(api_req_t *req)
{
// Heap buffers: the HTTP server task has an 8 KB stack
char *in = (char *)malloc(2048);
char *out = (char *)malloc(4096);
char *out = (char *)malloc(8192);
if (!in || !out) {
free(in);
free(out);
return send_error(req, "503 Service Unavailable", "out of memory");
}
esp_err_t result = ESP_FAIL;
esp_err_t result;
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)) {
if (!cJSON_IsString(jh) || !cJSON_IsString(jm) || !cJSON_IsString(jp)) {
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;
}
result = send_error(req, "400 Bad Request", "need host, method and path");
} else {
err = ESP_FAIL;
relay_forward(jh->valuestring, jm->valuestring, jp->valuestring,
cJSON_IsString(jb) ? jb->valuestring : "", out, 8192);
cJSON_Delete(top);
result = send_text(req, "200 OK", out);
}
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)
static esp_err_t devices_get(api_req_t *req)
{
cJSON *arr = cJSON_CreateArray();
mdns_result_t *res = NULL;
@@ -873,6 +1112,184 @@ static esp_err_t devices_get(httpd_req_t *req)
return send_json(req, top);
}
// The server sends each response header as its own small write. With Nagle on, every write after the
// first waits for the client's delayed ACK (hundreds of ms), so turn Nagle off on each new connection.
static esp_err_t open_nodelay(httpd_handle_t hd, int sockfd)
{
(void)hd;
int one = 1;
setsockopt(sockfd, IPPROTO_TCP, TCP_NODELAY, &one, sizeof(one));
return ESP_OK;
}
// The JSON API. Each route answers an HTTP request and a WebSocket message alike.
typedef struct {
const char *path;
httpd_method_t method;
api_fn_t fn;
} api_route_t;
static const api_route_t s_api[] = {
{"/api/status", HTTP_GET, status_get},
{"/api/pattern", HTTP_POST, pattern_post},
{"/api/wifi", HTTP_GET, wifi_get},
{"/api/wifi", HTTP_POST, wifi_post},
{"/api/wifi/scan", HTTP_GET, wifi_scan_get},
{"/api/network", HTTP_GET, network_get},
{"/api/network", HTTP_POST, network_post},
{"/api/ddp", HTTP_GET, ddp_get},
{"/api/hardware", HTTP_GET, hardware_get},
{"/api/hardware", HTTP_POST, hardware_post},
{"/api/presets", HTTP_GET, presets_get},
{"/api/presets", HTTP_POST, presets_post},
{"/api/presets/select", HTTP_POST, select_post},
{"/api/presets/delete", HTTP_POST, delete_post},
{"/api/presets/startup", HTTP_POST, startup_post},
{"/api/presets/defaults", HTTP_POST, presets_defaults_post},
{"/api/presets/order", HTTP_POST, presets_order_post},
{"/api/brightness", HTTP_POST, brightness_post},
{"/api/devices", HTTP_GET, devices_get},
{"/api/relay", HTTP_POST, relay_post},
};
// An HTTP request for a route: the route's function is kept in the URI's user_ctx.
static esp_err_t api_http_entry(httpd_req_t *req)
{
api_req_t a = {};
a.http = req;
return reinterpret_cast<api_fn_t>(req->user_ctx)(&a);
}
#define WS_MSG_MAX 2048 // a request message
#define WS_REPLY_MAX 8192 // a reply envelope
// Run an API route on this driver: target is the path, optionally with a query string.
static void ws_local(const char *method, const char *target, const char *body, char *out, size_t cap)
{
char path[64];
const char *q = strchr(target, '?');
size_t n = q ? (size_t)(q - target) : strlen(target);
if (n >= sizeof(path)) {
envelope(out, cap, 404, "{\"error\":\"no such API path\"}");
return;
}
memcpy(path, target, n);
path[n] = '\0';
for (size_t i = 0; i < sizeof(s_api) / sizeof(s_api[0]); i++) {
const bool is_get = s_api[i].method == HTTP_GET;
if (strcmp(s_api[i].path, path) == 0 && strcmp(method, is_get ? "GET" : "POST") == 0) {
char *reply = (char *)malloc(WS_REPLY_MAX);
if (!reply) {
envelope(out, cap, 503, "{\"error\":\"out of memory\"}");
return;
}
reply[0] = '\0';
api_req_t a = {};
a.body = body;
a.query = q ? q + 1 : "";
a.out = reply;
a.out_cap = WS_REPLY_MAX;
a.status = 200;
s_api[i].fn(&a);
if (reply[0] == '\0') {
snprintf(reply, WS_REPLY_MAX, "{}");
}
envelope(out, cap, a.status, reply);
free(reply);
return;
}
}
envelope(out, cap, 404, "{\"error\":\"no such API path\"}");
}
// A WebSocket request: {"method": "GET" or "POST", "path": "/api/...", "body": "<JSON text>"}, plus
// "host" to have this driver relay it to that driver. The reply is the envelope {"status": n, "body": "..."}.
static void ws_dispatch(const char *msg, char *out, size_t cap)
{
cJSON *top = cJSON_Parse(msg);
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;
const cJSON *jh = top ? cJSON_GetObjectItem(top, "host") : NULL;
if (!cJSON_IsString(jp)) {
envelope(out, cap, 400, "{\"error\":\"need a path\"}");
cJSON_Delete(top);
return;
}
const char *method = cJSON_IsString(jm) ? jm->valuestring : "GET";
char *owned = NULL; // body printed from a JSON object (a string is used as it is)
const char *body = "";
if (cJSON_IsString(jb)) {
body = jb->valuestring;
} else if (jb) {
owned = cJSON_PrintUnformatted(jb);
body = owned ? owned : "";
}
if (cJSON_IsString(jh) && jh->valuestring[0] != '\0') {
relay_forward(jh->valuestring, method, jp->valuestring, body, out, cap);
} else {
ws_local(method, jp->valuestring, body, out, cap);
}
cJSON_free(owned);
cJSON_Delete(top);
}
// WebSocket handler: one text frame in, one text frame out
// Another site's page must not drive this driver. A browser sends its Origin with the WebSocket
// handshake, and only a page from the LAN (or this device) may open the socket. ESP-IDF has no hook
// before the handshake reply, so the check runs right after it: a refused socket is closed before any
// frame is read, so its messages are never dispatched.
static esp_err_t ws_origin_check(httpd_req_t *req)
{
size_t origin_len = httpd_req_get_hdr_value_len(req, "Origin");
if (origin_len == 0) {
return ESP_OK; // not a browser (no Origin): the device's own client, or a tool
}
char origin[128];
if (origin_len >= sizeof(origin) || httpd_req_get_hdr_value_str(req, "Origin", origin, sizeof(origin)) != ESP_OK
|| !origin_is_lan(origin)) {
return ESP_FAIL;
}
return ESP_OK;
}
static esp_err_t ws_handler(httpd_req_t *req)
{
if (req->method == HTTP_GET) {
return ws_origin_check(req); // the handshake is done
}
httpd_ws_frame_t frame = {};
frame.type = HTTPD_WS_TYPE_TEXT;
esp_err_t err = httpd_ws_recv_frame(req, &frame, 0);
if (err != ESP_OK) {
return err;
}
if (frame.len == 0 || frame.len > WS_MSG_MAX) {
return ESP_FAIL;
}
uint8_t *buf = (uint8_t *)malloc(frame.len + 1);
char *reply = (char *)malloc(WS_REPLY_MAX);
if (!buf || !reply) {
free(buf);
free(reply);
return ESP_ERR_NO_MEM;
}
frame.payload = buf;
err = httpd_ws_recv_frame(req, &frame, frame.len);
if (err == ESP_OK) {
buf[frame.len] = '\0';
ws_dispatch((const char *)buf, reply, WS_REPLY_MAX);
httpd_ws_frame_t out = {};
out.type = HTTPD_WS_TYPE_TEXT;
out.payload = (uint8_t *)reply;
out.len = strlen(reply);
err = httpd_ws_send_frame(req, &out);
}
free(buf);
free(reply);
return err;
}
esp_err_t web_start(void)
{
httpd_config_t cfg = HTTPD_DEFAULT_CONFIG();
@@ -881,6 +1298,7 @@ esp_err_t web_start(void)
cfg.lru_purge_enable = true;
cfg.max_open_sockets = 7;
cfg.backlog_conn = 10;
cfg.open_fn = open_nodelay;
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));
@@ -889,26 +1307,18 @@ esp_err_t web_start(void)
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);
for (size_t i = 0; i < sizeof(s_api) / sizeof(s_api[0]); i++) {
httpd_uri_t u = {};
u.uri = s_api[i].path;
u.method = s_api[i].method;
u.handler = api_http_entry;
u.user_ctx = reinterpret_cast<void *>(s_api[i].fn);
httpd_register_uri_handler(s_server, &u);
}
static const httpd_uri_t ws_uri = { .uri = "/ws", .method = HTTP_GET, .handler = ws_handler,
.user_ctx = NULL, .is_websocket = true, .handle_ws_control_frames = false,
.supported_subprotocol = NULL };
httpd_register_uri_handler(s_server, &ws_uri);
ota_register(s_server);
ESP_LOGI(TAG, "Web UI on port 80");
return ESP_OK;