Something went wrong. Try again.
A fork of https://github.com/crosspoint-reader/crosspoint-reader
Something went wrong. Try again.
50 kB · 1554 lines
C++
at master
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555#include "CrossPointWebServer.h"
#include <ArduinoJson.h>#include <Epub.h>#include <FsHelpers.h>#include <HalStorage.h>#include <Logging.h>#include <WiFi.h>#include <esp_task_wdt.h>
#include <algorithm>
#include "CrossPointSettings.h"#include "OpdsServerStore.h"#include "SettingsList.h"#include "WebDAVHandler.h"#include "html/FilesPageHtml.generated.h"#include "html/HomePageHtml.generated.h"#include "html/SettingsPageHtml.generated.h"#include "html/js/jszip_minJs.generated.h"
namespace {// Folders/files to hide from the web interface file browser// Note: Items starting with "." are automatically hiddenconst char* HIDDEN_ITEMS[] = {"System Volume Information", "XTCache"};constexpr size_t HIDDEN_ITEMS_COUNT = sizeof(HIDDEN_ITEMS) / sizeof(HIDDEN_ITEMS[0]);constexpr uint16_t UDP_PORTS[] = {54982, 48123, 39001, 44044, 59678};constexpr uint16_t LOCAL_UDP_PORT = 8134;
// Static pointer for WebSocket callback (WebSocketsServer requires C-style callback)CrossPointWebServer* wsInstance = nullptr;
// WebSocket upload stateFsFile wsUploadFile;String wsUploadFileName;String wsUploadPath;size_t wsUploadSize = 0;size_t wsUploadReceived = 0;unsigned long wsUploadStartTime = 0;bool wsUploadInProgress = false;uint8_t wsUploadClientNum = 255; // 255 = no active upload clientsize_t wsLastProgressSent = 0;String wsLastCompleteName;size_t wsLastCompleteSize = 0;unsigned long wsLastCompleteAt = 0;
// Helper function to clear epub cache after uploadvoid clearEpubCacheIfNeeded(const String& filePath) { // Only clear cache for .epub files if (FsHelpers::hasEpubExtension(filePath)) { Epub(filePath.c_str(), "/.crosspoint").clearCache(); LOG_DBG("WEB", "Cleared epub cache for: %s", filePath.c_str()); }}
String normalizeWebPath(const String& inputPath) { if (inputPath.isEmpty() || inputPath == "/") { return "/"; } std::string normalized = FsHelpers::normalisePath(inputPath.c_str()); String result = normalized.c_str(); if (result.isEmpty()) { return "/"; } if (!result.startsWith("/")) { result = "/" + result; } if (result.length() > 1 && result.endsWith("/")) { result = result.substring(0, result.length() - 1); } return result;}
bool isProtectedItemName(const String& name) { if (name.startsWith(".")) { return true; } for (size_t i = 0; i < HIDDEN_ITEMS_COUNT; i++) { if (name.equals(HIDDEN_ITEMS[i])) { return true; } } return false;}} // namespace
// File listing page template - now using generated headers:// - HomePageHtml (from html/HomePage.html)// - FilesPageHeaderHtml (from html/FilesPageHeader.html)// - FilesPageFooterHtml (from html/FilesPageFooter.html)CrossPointWebServer::CrossPointWebServer() {}
CrossPointWebServer::~CrossPointWebServer() { stop(); }
void CrossPointWebServer::begin() { if (running) { LOG_DBG("WEB", "Web server already running"); return; }
// Check if we have a valid network connection (either STA connected or AP mode) const wifi_mode_t wifiMode = WiFi.getMode(); const bool isStaConnected = (wifiMode & WIFI_MODE_STA) && (WiFi.status() == WL_CONNECTED); const bool isInApMode = (wifiMode & WIFI_MODE_AP) && (WiFi.softAPgetStationNum() >= 0); // AP is running
if (!isStaConnected && !isInApMode) { LOG_DBG("WEB", "Cannot start webserver - no valid network (mode=%d, status=%d)", wifiMode, WiFi.status()); return; }
// Store AP mode flag for later use (e.g., in handleStatus) apMode = isInApMode;
LOG_DBG("WEB", "[MEM] Free heap before begin: %d bytes", ESP.getFreeHeap()); LOG_DBG("WEB", "Network mode: %s", apMode ? "AP" : "STA");
LOG_DBG("WEB", "Creating web server on port %d...", port); server.reset(new WebServer(port));
// Disable WiFi sleep to improve responsiveness and prevent 'unreachable' errors. // This is critical for reliable web server operation on ESP32. WiFi.setSleep(false);
// Note: WebServer class doesn't have setNoDelay() in the standard ESP32 library. // We rely on disabling WiFi sleep for responsiveness.
LOG_DBG("WEB", "[MEM] Free heap after WebServer allocation: %d bytes", ESP.getFreeHeap());
if (!server) { LOG_ERR("WEB", "Failed to create WebServer!"); return; }
// Setup routes LOG_DBG("WEB", "Setting up routes..."); server->on("/", HTTP_GET, [this] { handleRoot(); }); server->on("/files", HTTP_GET, [this] { handleFileList(); }); server->on("/js/jszip.min.js", HTTP_GET, [this] { handleJszip(); });
server->on("/api/status", HTTP_GET, [this] { handleStatus(); }); server->on("/api/files", HTTP_GET, [this] { handleFileListData(); }); server->on("/download", HTTP_GET, [this] { handleDownload(); });
// Upload endpoint with special handling for multipart form data server->on("/upload", HTTP_POST, [this] { handleUploadPost(upload); }, [this] { handleUpload(upload); });
// Create folder endpoint server->on("/mkdir", HTTP_POST, [this] { handleCreateFolder(); });
// Rename file endpoint server->on("/rename", HTTP_POST, [this] { handleRename(); });
// Move file endpoint server->on("/move", HTTP_POST, [this] { handleMove(); });
// Delete file/folder endpoint server->on("/delete", HTTP_POST, [this] { handleDelete(); });
// Settings endpoints server->on("/settings", HTTP_GET, [this] { handleSettingsPage(); }); server->on("/api/settings", HTTP_GET, [this] { handleGetSettings(); }); server->on("/api/settings", HTTP_POST, [this] { handlePostSettings(); });
// OPDS server endpoints server->on("/api/opds", HTTP_GET, [this] { handleGetOpdsServers(); }); server->on("/api/opds", HTTP_POST, [this] { handlePostOpdsServer(); }); server->on("/api/opds/delete", HTTP_POST, [this] { handleDeleteOpdsServer(); });
server->onNotFound([this] { handleNotFound(); }); LOG_DBG("WEB", "[MEM] Free heap after route setup: %d bytes", ESP.getFreeHeap());
// Collect WebDAV headers and register handler const char* davHeaders[] = {"Depth", "Destination", "Overwrite", "If", "Lock-Token", "Timeout"}; server->collectHeaders(davHeaders, 6); server->addHandler(new WebDAVHandler()); // Note: WebDAVHandler will be deleted by WebServer when server is stopped LOG_DBG("WEB", "WebDAV handler initialized");
server->begin();
// Start WebSocket server for fast binary uploads LOG_DBG("WEB", "Starting WebSocket server on port %d...", wsPort); wsServer.reset(new WebSocketsServer(wsPort)); wsInstance = const_cast<CrossPointWebServer*>(this); wsServer->begin(); wsServer->onEvent(wsEventCallback); LOG_DBG("WEB", "WebSocket server started");
udpActive = udp.begin(LOCAL_UDP_PORT); LOG_DBG("WEB", "Discovery UDP %s on port %d", udpActive ? "enabled" : "failed", LOCAL_UDP_PORT);
running = true;
LOG_DBG("WEB", "Web server started on port %d", port); // Show the correct IP based on network mode const String ipAddr = apMode ? WiFi.softAPIP().toString() : WiFi.localIP().toString(); LOG_DBG("WEB", "Access at http://%s/", ipAddr.c_str()); LOG_DBG("WEB", "WebSocket at ws://%s:%d/", ipAddr.c_str(), wsPort); LOG_DBG("WEB", "[MEM] Free heap after server.begin(): %d bytes", ESP.getFreeHeap());}
void CrossPointWebServer::abortWsUpload(const char* tag) { // Explicit close() required: file-scope global persists beyond function scope wsUploadFile.close(); String filePath = wsUploadPath; if (!filePath.endsWith("/")) filePath += "/"; filePath += wsUploadFileName; if (Storage.remove(filePath.c_str())) { LOG_DBG(tag, "Deleted incomplete upload: %s", filePath.c_str()); } else { LOG_DBG(tag, "Failed to delete incomplete upload: %s", filePath.c_str()); } wsUploadInProgress = false; wsUploadClientNum = 255; wsLastProgressSent = 0;}
void CrossPointWebServer::stop() { if (!running || !server) { LOG_DBG("WEB", "stop() called but already stopped (running=%d, server=%p)", running, server.get()); return; }
LOG_DBG("WEB", "STOP INITIATED - setting running=false first"); running = false; // Set this FIRST to prevent handleClient from using server
LOG_DBG("WEB", "[MEM] Free heap before stop: %d bytes", ESP.getFreeHeap());
// Close any in-progress WebSocket upload and remove partial file if (wsUploadInProgress && wsUploadFile) { abortWsUpload("WEB"); }
// Stop WebSocket server if (wsServer) { LOG_DBG("WEB", "Stopping WebSocket server..."); wsServer->close(); wsServer.reset(); wsInstance = nullptr; LOG_DBG("WEB", "WebSocket server stopped"); }
if (udpActive) { udp.stop(); udpActive = false; }
// Brief delay to allow any in-flight handleClient() calls to complete delay(20);
server->stop(); LOG_DBG("WEB", "[MEM] Free heap after server->stop(): %d bytes", ESP.getFreeHeap());
// Brief delay before deletion delay(10);
server.reset(); LOG_DBG("WEB", "Web server stopped and deleted"); LOG_DBG("WEB", "[MEM] Free heap after delete server: %d bytes", ESP.getFreeHeap());
// Note: Static upload variables (uploadFileName, uploadPath, uploadError) are declared // later in the file and will be cleared when they go out of scope or on next upload LOG_DBG("WEB", "[MEM] Free heap final: %d bytes", ESP.getFreeHeap());}
void CrossPointWebServer::handleClient() { static unsigned long lastDebugPrint = 0;
// Check running flag FIRST before accessing server if (!running) { return; }
// Double-check server pointer is valid if (!server) { LOG_DBG("WEB", "WARNING: handleClient called with null server!"); return; }
// Print debug every 10 seconds to confirm handleClient is being called if (millis() - lastDebugPrint > 10000) { LOG_DBG("WEB", "handleClient active, server running on port %d", port); lastDebugPrint = millis(); }
server->handleClient();
// Handle WebSocket events if (wsServer) { wsServer->loop(); }
// Respond to discovery broadcasts if (udpActive) { int packetSize = udp.parsePacket(); if (packetSize > 0) { char buffer[16]; int len = udp.read(buffer, sizeof(buffer) - 1); if (len > 0) { buffer[len] = '\0'; if (strcmp(buffer, "hello") == 0) { String hostname = WiFi.getHostname(); if (hostname.isEmpty()) { hostname = "crosspoint"; } String message = "crosspoint (on " + hostname + ");" + String(wsPort); udp.beginPacket(udp.remoteIP(), udp.remotePort()); udp.write(reinterpret_cast<const uint8_t*>(message.c_str()), message.length()); udp.endPacket(); } } } }}
CrossPointWebServer::WsUploadStatus CrossPointWebServer::getWsUploadStatus() const { WsUploadStatus status; status.inProgress = wsUploadInProgress; status.received = wsUploadReceived; status.total = wsUploadSize; status.filename = wsUploadFileName.c_str(); status.lastCompleteName = wsLastCompleteName.c_str(); status.lastCompleteSize = wsLastCompleteSize; status.lastCompleteAt = wsLastCompleteAt; return status;}
static void sendHtmlContent(WebServer* server, const char* data, size_t len) { server->sendHeader("Content-Encoding", "gzip"); server->send_P(200, "text/html", data, len);}
void CrossPointWebServer::handleRoot() const { sendHtmlContent(server.get(), HomePageHtml, sizeof(HomePageHtml)); LOG_DBG("WEB", "Served root page");}
void CrossPointWebServer::handleJszip() const { server->sendHeader("Content-Encoding", "gzip"); server->send_P(200, "application/javascript", jszip_minJs, jszip_minJsCompressedSize); LOG_DBG("WEB", "Served jszip.min.js");}
void CrossPointWebServer::handleNotFound() const { String message = "404 Not Found\n\n"; message += "URI: " + server->uri() + "\n"; server->send(404, "text/plain", message);}
void CrossPointWebServer::handleStatus() const { // Get correct IP based on AP vs STA mode const String ipAddr = apMode ? WiFi.softAPIP().toString() : WiFi.localIP().toString();
JsonDocument doc; doc["version"] = CROSSPOINT_VERSION; doc["ip"] = ipAddr; doc["mode"] = apMode ? "AP" : "STA"; doc["rssi"] = apMode ? 0 : WiFi.RSSI(); doc["freeHeap"] = ESP.getFreeHeap(); doc["uptime"] = millis() / 1000;
String json; serializeJson(doc, json); server->send(200, "application/json", json);}
void CrossPointWebServer::scanFiles(const char* path, const std::function<void(FileInfo)>& callback) const { FsFile root = Storage.open(path); if (!root) { LOG_DBG("WEB", "Failed to open directory: %s", path); return; }
if (!root.isDirectory()) { LOG_DBG("WEB", "Not a directory: %s", path); root.close(); return; }
LOG_DBG("WEB", "Scanning files in: %s", path);
FsFile file = root.openNextFile(); char name[500]; while (file) { file.getName(name, sizeof(name)); auto fileName = String(name);
// Skip hidden items (starting with ".") bool shouldHide = !SETTINGS.showHiddenFiles && fileName.startsWith(".");
// Check against explicitly hidden items list if (!shouldHide) { for (size_t i = 0; i < HIDDEN_ITEMS_COUNT; i++) { if (fileName.equals(HIDDEN_ITEMS[i])) { shouldHide = true; break; } } }
if (!shouldHide) { FileInfo info; info.name = fileName; info.isDirectory = file.isDirectory();
if (info.isDirectory) { info.size = 0; info.isEpub = false; } else { info.size = file.size(); info.isEpub = isEpubFile(info.name); }
callback(info); }
file.close(); yield(); // Yield to allow WiFi and other tasks to process during long scans esp_task_wdt_reset(); // Reset watchdog to prevent timeout on large directories file = root.openNextFile(); } root.close();}
bool CrossPointWebServer::isEpubFile(const String& filename) const { return FsHelpers::hasEpubExtension(filename); }
void CrossPointWebServer::handleFileList() const { sendHtmlContent(server.get(), FilesPageHtml, sizeof(FilesPageHtml));}
void CrossPointWebServer::handleFileListData() const { // Get current path from query string (default to root) String currentPath = "/"; if (server->hasArg("path")) { currentPath = server->arg("path"); // Ensure path starts with / if (!currentPath.startsWith("/")) { currentPath = "/" + currentPath; } // Remove trailing slash unless it's root if (currentPath.length() > 1 && currentPath.endsWith("/")) { currentPath = currentPath.substring(0, currentPath.length() - 1); } }
server->setContentLength(CONTENT_LENGTH_UNKNOWN); server->send(200, "application/json", ""); server->sendContent("["); char output[512]; constexpr size_t outputSize = sizeof(output); bool seenFirst = false; JsonDocument doc;
scanFiles(currentPath.c_str(), [this, &output, &doc, seenFirst](const FileInfo& info) mutable { doc.clear(); doc["name"] = info.name; doc["size"] = info.size; doc["isDirectory"] = info.isDirectory; doc["isEpub"] = info.isEpub;
const size_t written = serializeJson(doc, output, outputSize); if (written >= outputSize) { // JSON output truncated; skip this entry to avoid sending malformed JSON LOG_DBG("WEB", "Skipping file entry with oversized JSON for name: %s", info.name.c_str()); return; }
if (seenFirst) { server->sendContent(","); } else { seenFirst = true; } server->sendContent(output); }); server->sendContent("]"); // End of streamed response, empty chunk to signal client server->sendContent(""); LOG_DBG("WEB", "Served file listing page for path: %s", currentPath.c_str());}
void CrossPointWebServer::handleDownload() const { if (!server->hasArg("path")) { server->send(400, "text/plain", "Missing path"); return; }
String itemPath = server->arg("path"); if (itemPath.isEmpty() || itemPath == "/") { server->send(400, "text/plain", "Invalid path"); return; } if (!itemPath.startsWith("/")) { itemPath = "/" + itemPath; }
const String itemName = itemPath.substring(itemPath.lastIndexOf('/') + 1); if (itemName.startsWith(".")) { server->send(403, "text/plain", "Cannot access system files"); return; } for (size_t i = 0; i < HIDDEN_ITEMS_COUNT; i++) { if (itemName.equals(HIDDEN_ITEMS[i])) { server->send(403, "text/plain", "Cannot access protected items"); return; } }
if (!Storage.exists(itemPath.c_str())) { server->send(404, "text/plain", "Item not found"); return; }
FsFile file = Storage.open(itemPath.c_str()); if (!file) { server->send(500, "text/plain", "Failed to open file"); return; } if (file.isDirectory()) { file.close(); server->send(400, "text/plain", "Path is a directory"); return; }
String contentType = "application/octet-stream"; if (isEpubFile(itemPath)) { contentType = "application/epub+zip"; }
char nameBuf[128] = {0}; String filename = "download"; if (file.getName(nameBuf, sizeof(nameBuf))) { filename = nameBuf; }
server->setContentLength(file.size()); server->sendHeader("Content-Disposition", "attachment; filename=\"" + filename + "\""); server->send(200, contentType.c_str(), "");
NetworkClient client = server->client(); const size_t chunkSize = 4096; uint8_t buffer[chunkSize];
bool downloadOk = true; while (downloadOk && file.available()) { int result = file.read(buffer, chunkSize); if (result <= 0) break; size_t bytesRead = static_cast<size_t>(result); size_t totalWritten = 0; while (totalWritten < bytesRead) { esp_task_wdt_reset(); size_t wrote = client.write(buffer + totalWritten, bytesRead - totalWritten); if (wrote == 0) { downloadOk = false; break; } totalWritten += wrote; } } client.clear(); file.close();}
// Diagnostic counters for upload performance analysisstatic unsigned long uploadStartTime = 0;static unsigned long totalWriteTime = 0;static size_t writeCount = 0;
static bool flushUploadBuffer(CrossPointWebServer::UploadState& state) { if (state.bufferPos > 0 && state.file) { esp_task_wdt_reset(); // Reset watchdog before potentially slow SD write const unsigned long writeStart = millis(); const size_t written = state.file.write(state.buffer.data(), state.bufferPos); totalWriteTime += millis() - writeStart; writeCount++; esp_task_wdt_reset(); // Reset watchdog after SD write
if (written != state.bufferPos) { LOG_DBG("WEB", "[UPLOAD] Buffer flush failed: expected %d, wrote %d", state.bufferPos, written); state.bufferPos = 0; return false; } state.bufferPos = 0; } return true;}
void CrossPointWebServer::handleUpload(UploadState& state) const { static size_t lastLoggedSize = 0;
// Reset watchdog at start of every upload callback - HTTP parsing can be slow esp_task_wdt_reset();
// Safety check: ensure server is still valid if (!running || !server) { LOG_DBG("WEB", "[UPLOAD] ERROR: handleUpload called but server not running!"); return; }
const HTTPUpload& upload = server->upload();
if (upload.status == UPLOAD_FILE_START) { // Reset watchdog - this is the critical 1% crash point esp_task_wdt_reset();
state.fileName = upload.filename; state.size = 0; state.success = false; state.error = ""; uploadStartTime = millis(); lastLoggedSize = 0; state.bufferPos = 0; totalWriteTime = 0; writeCount = 0;
// Get upload path from query parameter (defaults to root if not specified) // Note: We use query parameter instead of form data because multipart form // fields aren't available until after file upload completes if (server->hasArg("path")) { state.path = server->arg("path"); // Ensure path starts with / if (!state.path.startsWith("/")) { state.path = "/" + state.path; } // Remove trailing slash unless it's root if (state.path.length() > 1 && state.path.endsWith("/")) { state.path = state.path.substring(0, state.path.length() - 1); } } else { state.path = "/"; }
LOG_DBG("WEB", "[UPLOAD] START: %s to path: %s", state.fileName.c_str(), state.path.c_str()); LOG_DBG("WEB", "[UPLOAD] Free heap: %d bytes", ESP.getFreeHeap());
// Create file path String filePath = state.path; if (!filePath.endsWith("/")) filePath += "/"; filePath += state.fileName;
// Check if file already exists - SD operations can be slow esp_task_wdt_reset(); if (Storage.exists(filePath.c_str())) { LOG_DBG("WEB", "[UPLOAD] Overwriting existing file: %s", filePath.c_str()); esp_task_wdt_reset(); Storage.remove(filePath.c_str()); }
// Open file for writing - this can be slow due to FAT cluster allocation esp_task_wdt_reset(); if (!Storage.openFileForWrite("WEB", filePath, state.file)) { state.error = "Failed to create file on SD card"; LOG_DBG("WEB", "[UPLOAD] FAILED to create file: %s", filePath.c_str()); return; } esp_task_wdt_reset();
LOG_DBG("WEB", "[UPLOAD] File created successfully: %s", filePath.c_str()); } else if (upload.status == UPLOAD_FILE_WRITE) { if (state.file && state.error.isEmpty()) { // Buffer incoming data and flush when buffer is full // This reduces SD card write operations and improves throughput const uint8_t* data = upload.buf; size_t remaining = upload.currentSize;
while (remaining > 0) { const size_t space = UploadState::UPLOAD_BUFFER_SIZE - state.bufferPos; const size_t toCopy = (remaining < space) ? remaining : space;
memcpy(state.buffer.data() + state.bufferPos, data, toCopy); state.bufferPos += toCopy; data += toCopy; remaining -= toCopy;
// Flush buffer when full if (state.bufferPos >= UploadState::UPLOAD_BUFFER_SIZE) { if (!flushUploadBuffer(state)) { state.error = "Failed to write to SD card - disk may be full"; state.file.close(); return; } } }
state.size += upload.currentSize;
// Log progress every 100KB if (state.size - lastLoggedSize >= 102400) { const unsigned long elapsed = millis() - uploadStartTime; const float kbps = (elapsed > 0) ? (state.size / 1024.0) / (elapsed / 1000.0) : 0; LOG_DBG("WEB", "[UPLOAD] %d bytes (%.1f KB), %.1f KB/s, %d writes", state.size, state.size / 1024.0, kbps, writeCount); lastLoggedSize = state.size; } } } else if (upload.status == UPLOAD_FILE_END) { if (state.file) { // Flush any remaining buffered data if (!flushUploadBuffer(state)) { state.error = "Failed to write final data to SD card"; } state.file.close();
if (state.error.isEmpty()) { state.success = true; const unsigned long elapsed = millis() - uploadStartTime; const float avgKbps = (elapsed > 0) ? (state.size / 1024.0) / (elapsed / 1000.0) : 0; const float writePercent = (elapsed > 0) ? (totalWriteTime * 100.0 / elapsed) : 0; LOG_DBG("WEB", "[UPLOAD] Complete: %s (%d bytes in %lu ms, avg %.1f KB/s)", state.fileName.c_str(), state.size, elapsed, avgKbps); LOG_DBG("WEB", "[UPLOAD] Diagnostics: %d writes, total write time: %lu ms (%.1f%%)", writeCount, totalWriteTime, writePercent);
// Clear epub cache to prevent stale metadata issues when overwriting files String filePath = state.path; if (!filePath.endsWith("/")) filePath += "/"; filePath += state.fileName; clearEpubCacheIfNeeded(filePath); } } } else if (upload.status == UPLOAD_FILE_ABORTED) { state.bufferPos = 0; // Discard buffered data if (state.file) { state.file.close(); // Try to delete the incomplete file String filePath = state.path; if (!filePath.endsWith("/")) filePath += "/"; filePath += state.fileName; Storage.remove(filePath.c_str()); } state.error = "Upload aborted"; LOG_DBG("WEB", "Upload aborted"); }}
void CrossPointWebServer::handleUploadPost(UploadState& state) const { if (state.success) { server->send(200, "text/plain", "File uploaded successfully: " + state.fileName); } else { const String error = state.error.isEmpty() ? "Unknown error during upload" : state.error; server->send(400, "text/plain", error); }}
void CrossPointWebServer::handleCreateFolder() const { // Get folder name from form data if (!server->hasArg("name")) { server->send(400, "text/plain", "Missing folder name"); return; }
const String folderName = server->arg("name");
// Validate folder name if (folderName.isEmpty()) { server->send(400, "text/plain", "Folder name cannot be empty"); return; }
// Get parent path String parentPath = "/"; if (server->hasArg("path")) { parentPath = server->arg("path"); if (!parentPath.startsWith("/")) { parentPath = "/" + parentPath; } if (parentPath.length() > 1 && parentPath.endsWith("/")) { parentPath = parentPath.substring(0, parentPath.length() - 1); } }
// Build full folder path String folderPath = parentPath; if (!folderPath.endsWith("/")) folderPath += "/"; folderPath += folderName;
LOG_DBG("WEB", "Creating folder: %s", folderPath.c_str());
// Check if already exists if (Storage.exists(folderPath.c_str())) { server->send(400, "text/plain", "Folder already exists"); return; }
// Create the folder if (Storage.mkdir(folderPath.c_str())) { LOG_DBG("WEB", "Folder created successfully: %s", folderPath.c_str()); server->send(200, "text/plain", "Folder created: " + folderName); } else { LOG_DBG("WEB", "Failed to create folder: %s", folderPath.c_str()); server->send(500, "text/plain", "Failed to create folder"); }}
void CrossPointWebServer::handleRename() const { if (!server->hasArg("path") || !server->hasArg("name")) { server->send(400, "text/plain", "Missing path or new name"); return; }
String itemPath = normalizeWebPath(server->arg("path")); String newName = server->arg("name"); newName.trim();
if (itemPath.isEmpty() || itemPath == "/") { server->send(400, "text/plain", "Invalid path"); return; } if (newName.isEmpty()) { server->send(400, "text/plain", "New name cannot be empty"); return; } if (newName.indexOf('/') >= 0 || newName.indexOf('\\') >= 0) { server->send(400, "text/plain", "Invalid file name"); return; } if (isProtectedItemName(newName)) { server->send(403, "text/plain", "Cannot rename to protected name"); return; }
const String itemName = itemPath.substring(itemPath.lastIndexOf('/') + 1); if (isProtectedItemName(itemName)) { server->send(403, "text/plain", "Cannot rename protected item"); return; } if (newName == itemName) { server->send(200, "text/plain", "Name unchanged"); return; }
if (!Storage.exists(itemPath.c_str())) { server->send(404, "text/plain", "Item not found"); return; }
FsFile file = Storage.open(itemPath.c_str()); if (!file) { server->send(500, "text/plain", "Failed to open file"); return; } if (file.isDirectory()) { file.close(); server->send(400, "text/plain", "Only files can be renamed"); return; }
String parentPath = itemPath.substring(0, itemPath.lastIndexOf('/')); if (parentPath.isEmpty()) { parentPath = "/"; } String newPath = parentPath; if (!newPath.endsWith("/")) { newPath += "/"; } newPath += newName;
if (Storage.exists(newPath.c_str())) { file.close(); server->send(409, "text/plain", "Target already exists"); return; }
clearEpubCacheIfNeeded(itemPath); const bool success = file.rename(newPath.c_str()); file.close();
if (success) { LOG_DBG("WEB", "Renamed file: %s -> %s", itemPath.c_str(), newPath.c_str()); server->send(200, "text/plain", "Renamed successfully"); } else { LOG_ERR("WEB", "Failed to rename file: %s -> %s", itemPath.c_str(), newPath.c_str()); server->send(500, "text/plain", "Failed to rename file"); }}
void CrossPointWebServer::handleMove() const { if (!server->hasArg("path") || !server->hasArg("dest")) { server->send(400, "text/plain", "Missing path or destination"); return; }
String itemPath = normalizeWebPath(server->arg("path")); String destPath = normalizeWebPath(server->arg("dest"));
if (itemPath.isEmpty() || itemPath == "/") { server->send(400, "text/plain", "Invalid path"); return; } if (destPath.isEmpty()) { server->send(400, "text/plain", "Invalid destination"); return; }
const String itemName = itemPath.substring(itemPath.lastIndexOf('/') + 1); if (isProtectedItemName(itemName)) { server->send(403, "text/plain", "Cannot move protected item"); return; } if (destPath != "/") { const String destName = destPath.substring(destPath.lastIndexOf('/') + 1); if (isProtectedItemName(destName)) { server->send(403, "text/plain", "Cannot move into protected folder"); return; } }
if (!Storage.exists(itemPath.c_str())) { server->send(404, "text/plain", "Item not found"); return; }
FsFile file = Storage.open(itemPath.c_str()); if (!file) { server->send(500, "text/plain", "Failed to open file"); return; } if (file.isDirectory()) { file.close(); server->send(400, "text/plain", "Only files can be moved"); return; }
if (!Storage.exists(destPath.c_str())) { file.close(); server->send(404, "text/plain", "Destination not found"); return; } FsFile destDir = Storage.open(destPath.c_str()); if (!destDir || !destDir.isDirectory()) { if (destDir) { destDir.close(); } file.close(); server->send(400, "text/plain", "Destination is not a folder"); return; } destDir.close();
String newPath = destPath; if (!newPath.endsWith("/")) { newPath += "/"; } newPath += itemName;
if (newPath == itemPath) { file.close(); server->send(200, "text/plain", "Already in destination"); return; } if (Storage.exists(newPath.c_str())) { file.close(); server->send(409, "text/plain", "Target already exists"); return; }
clearEpubCacheIfNeeded(itemPath); const bool success = file.rename(newPath.c_str()); file.close();
if (success) { LOG_DBG("WEB", "Moved file: %s -> %s", itemPath.c_str(), newPath.c_str()); server->send(200, "text/plain", "Moved successfully"); } else { LOG_ERR("WEB", "Failed to move file: %s -> %s", itemPath.c_str(), newPath.c_str()); server->send(500, "text/plain", "Failed to move file"); }}
void CrossPointWebServer::handleDelete() const { // To ensure backwards compatibility, plain `path` is mapped // to a single element JSON array. bool hasPathArg = server->hasArg("path"); bool hasPathsArg = server->hasArg("paths"); // Check 'paths' or `path` argument is provided if (!(hasPathArg || hasPathsArg)) { server->send(400, "text/plain", "Missing `path` or `paths` argument"); return; } if (hasPathArg && hasPathsArg) { server->send(400, "text/plain", "Provide either 'path' or 'paths', not both"); return; }
// Parse paths String pathsArg; JsonDocument doc; DeserializationError error = DeserializationError(DeserializationError::Code::Ok); if (hasPathsArg) { pathsArg = server->arg("paths"); error = deserializeJson(doc, pathsArg); } else { pathsArg = server->arg("path"); doc.add(pathsArg); } if (error) { server->send(400, "text/plain", "Invalid paths format"); return; }
auto paths = doc.as<JsonArray>(); if (paths.isNull() || paths.size() == 0) { server->send(400, "text/plain", "No paths provided"); return; }
// Iterate over paths and delete each item bool allSuccess = true; String failedItems;
for (const auto& p : paths) { auto itemPath = p.as<String>();
// Validate path if (itemPath.isEmpty() || itemPath == "/") { failedItems += itemPath + " (cannot delete root); "; allSuccess = false; continue; }
// Ensure path starts with / if (!itemPath.startsWith("/")) { itemPath = "/" + itemPath; }
// Security check: prevent deletion of protected items const String itemName = itemPath.substring(itemPath.lastIndexOf('/') + 1);
// Hidden/system files are protected if (itemName.startsWith(".")) { failedItems += itemPath + " (hidden/system file); "; allSuccess = false; continue; }
// Check against explicitly protected items bool isProtected = false; for (size_t i = 0; i < HIDDEN_ITEMS_COUNT; i++) { if (itemName.equals(HIDDEN_ITEMS[i])) { isProtected = true; break; } } if (isProtected) { failedItems += itemPath + " (protected file); "; allSuccess = false; continue; }
// Check if item exists if (!Storage.exists(itemPath.c_str())) { failedItems += itemPath + " (not found); "; allSuccess = false; continue; }
// Decide whether it's a directory or file by opening it bool success = false; FsFile f = Storage.open(itemPath.c_str()); if (f && f.isDirectory()) { // For folders, ensure empty before removing FsFile entry = f.openNextFile(); if (entry) { entry.close(); f.close(); failedItems += itemPath + " (folder not empty); "; allSuccess = false; continue; } f.close(); success = Storage.rmdir(itemPath.c_str()); } else { // It's a file (or couldn't open as dir) — remove file if (f) f.close(); success = Storage.remove(itemPath.c_str()); clearEpubCacheIfNeeded(itemPath); }
if (!success) { failedItems += itemPath + " (deletion failed); "; allSuccess = false; } }
if (allSuccess) { server->send(200, "text/plain", "All items deleted successfully"); } else { server->send(500, "text/plain", "Failed to delete some items: " + failedItems); }}
void CrossPointWebServer::handleSettingsPage() const { sendHtmlContent(server.get(), SettingsPageHtml, sizeof(SettingsPageHtml)); LOG_DBG("WEB", "Served settings page");}
void CrossPointWebServer::handleGetSettings() const { const auto& settings = getSettingsList();
server->setContentLength(CONTENT_LENGTH_UNKNOWN); server->send(200, "application/json", ""); server->sendContent("[");
char output[512]; constexpr size_t outputSize = sizeof(output); bool seenFirst = false; JsonDocument doc;
for (const auto& s : settings) { if (!s.key) continue; // Skip ACTION-only entries
doc.clear(); doc["key"] = s.key; doc["name"] = I18N.get(s.nameId); doc["category"] = I18N.get(s.category);
switch (s.type) { case SettingType::TOGGLE: { doc["type"] = "toggle"; if (s.valuePtr) { doc["value"] = static_cast<int>(SETTINGS.*(s.valuePtr)); } break; } case SettingType::ENUM: { doc["type"] = "enum"; if (s.valuePtr) { doc["value"] = static_cast<int>(SETTINGS.*(s.valuePtr)); } else if (s.valueGetter) { doc["value"] = static_cast<int>(s.valueGetter()); } JsonArray options = doc["options"].to<JsonArray>(); for (const auto& opt : s.enumValues) { options.add(I18N.get(opt)); } break; } case SettingType::VALUE: { doc["type"] = "value"; if (s.valuePtr) { doc["value"] = static_cast<int>(SETTINGS.*(s.valuePtr)); } doc["min"] = s.valueRange.min; doc["max"] = s.valueRange.max; doc["step"] = s.valueRange.step; break; } case SettingType::STRING: { doc["type"] = "string"; if (s.stringGetter) { doc["value"] = s.stringGetter(); } else if (s.stringMaxLen > 0) { doc["value"] = reinterpret_cast<const char*>(&SETTINGS) + s.stringOffset; } break; } default: continue; }
const size_t written = serializeJson(doc, output, outputSize); if (written >= outputSize) { LOG_DBG("WEB", "Skipping oversized setting JSON for: %s", s.key); continue; }
if (seenFirst) { server->sendContent(","); } else { seenFirst = true; } server->sendContent(output); }
server->sendContent("]"); server->sendContent(""); LOG_DBG("WEB", "Served settings API");}
void CrossPointWebServer::handlePostSettings() { if (!server->hasArg("plain")) { server->send(400, "text/plain", "Missing JSON body"); return; }
const String body = server->arg("plain"); JsonDocument doc; const DeserializationError err = deserializeJson(doc, body); if (err) { server->send(400, "text/plain", String("Invalid JSON: ") + err.c_str()); return; }
const auto& settings = getSettingsList(); int applied = 0;
for (const auto& s : settings) { if (!s.key) continue; if (!doc[s.key].is<JsonVariant>()) continue;
switch (s.type) { case SettingType::TOGGLE: { const int val = doc[s.key].as<int>() ? 1 : 0; if (s.valuePtr) { SETTINGS.*(s.valuePtr) = val; } applied++; break; } case SettingType::ENUM: { const int val = doc[s.key].as<int>(); if (val >= 0 && val < static_cast<int>(s.enumValues.size())) { if (s.valuePtr) { SETTINGS.*(s.valuePtr) = static_cast<uint8_t>(val); } else if (s.valueSetter) { s.valueSetter(static_cast<uint8_t>(val)); } applied++; } break; } case SettingType::VALUE: { const int val = doc[s.key].as<int>(); if (val >= s.valueRange.min && val <= s.valueRange.max) { if (s.valuePtr) { SETTINGS.*(s.valuePtr) = static_cast<uint8_t>(val); } applied++; } break; } case SettingType::STRING: { const std::string val = doc[s.key].as<std::string>(); if (s.stringSetter) { s.stringSetter(val); } else if (s.stringMaxLen > 0) { char* ptr = reinterpret_cast<char*>(&SETTINGS) + s.stringOffset; strncpy(ptr, val.c_str(), s.stringMaxLen - 1); ptr[s.stringMaxLen - 1] = '\0'; } applied++; break; } default: break; } }
SETTINGS.saveToFile();
LOG_DBG("WEB", "Applied %d setting(s)", applied); server->send(200, "text/plain", String("Applied ") + String(applied) + " setting(s)");}
// ---- OPDS Server API ----
void CrossPointWebServer::handleGetOpdsServers() const { const auto& servers = OPDS_STORE.getServers();
// Stream JSON array incrementally to avoid allocating the full response in memory server->setContentLength(CONTENT_LENGTH_UNKNOWN); server->send(200, "application/json", ""); server->sendContent("[");
char output[512]; constexpr size_t outputSize = sizeof(output); JsonDocument doc;
for (size_t i = 0; i < servers.size(); i++) { doc.clear(); doc["index"] = i; doc["name"] = servers[i].name; doc["url"] = servers[i].url; doc["username"] = servers[i].username; // Never expose passwords over the API — only indicate whether one is set doc["hasPassword"] = !servers[i].password.empty();
const size_t written = serializeJson(doc, output, outputSize); if (written >= outputSize) continue;
if (i > 0) server->sendContent(","); server->sendContent(output); }
server->sendContent("]"); server->sendContent(""); LOG_DBG("WEB", "Served OPDS servers API (%zu servers)", servers.size());}
void CrossPointWebServer::handlePostOpdsServer() { if (!server->hasArg("plain")) { server->send(400, "text/plain", "Missing JSON body"); return; }
const String body = server->arg("plain"); JsonDocument doc; const DeserializationError err = deserializeJson(doc, body); if (err) { server->send(400, "text/plain", String("Invalid JSON: ") + err.c_str()); return; }
OpdsServer opdsServer; opdsServer.name = doc["name"] | std::string(""); opdsServer.url = doc["url"] | std::string(""); opdsServer.username = doc["username"] | std::string("");
// The password field is optional in the JSON payload. When absent (vs. present but empty), // we preserve the existing password — the web UI omits it when the user hasn't changed it. bool hasPasswordField = doc["password"].is<const char*>() || doc["password"].is<std::string>(); std::string password = doc["password"] | std::string("");
if (doc["index"].is<int>()) { int idx = doc["index"].as<int>(); if (idx < 0 || idx >= static_cast<int>(OPDS_STORE.getCount())) { server->send(400, "text/plain", "Invalid server index"); return; } // Preserve existing password if not explicitly provided if (!hasPasswordField) { const auto* existing = OPDS_STORE.getServer(static_cast<size_t>(idx)); if (existing) password = existing->password; } opdsServer.password = password; OPDS_STORE.updateServer(static_cast<size_t>(idx), opdsServer); LOG_DBG("WEB", "Updated OPDS server at index %d", idx); } else { opdsServer.password = password; if (!OPDS_STORE.addServer(opdsServer)) { server->send(400, "text/plain", "Cannot add server (limit reached)"); return; } LOG_DBG("WEB", "Added new OPDS server: %s", opdsServer.name.c_str()); }
server->send(200, "text/plain", "OK");}
// Uses POST (not HTTP DELETE) because ESP32 WebServer doesn't support DELETE with body.void CrossPointWebServer::handleDeleteOpdsServer() { if (!server->hasArg("plain")) { server->send(400, "text/plain", "Missing JSON body"); return; }
const String body = server->arg("plain"); JsonDocument doc; const DeserializationError err = deserializeJson(doc, body); if (err) { server->send(400, "text/plain", String("Invalid JSON: ") + err.c_str()); return; }
if (!doc["index"].is<int>()) { server->send(400, "text/plain", "Missing index"); return; }
int idx = doc["index"].as<int>(); if (idx < 0 || idx >= static_cast<int>(OPDS_STORE.getCount())) { server->send(400, "text/plain", "Invalid server index"); return; }
OPDS_STORE.removeServer(static_cast<size_t>(idx)); LOG_DBG("WEB", "Deleted OPDS server at index %d", idx); server->send(200, "text/plain", "OK");}
// WebSocket callback trampolinevoid CrossPointWebServer::wsEventCallback(uint8_t num, WStype_t type, uint8_t* payload, size_t length) { if (wsInstance) { wsInstance->onWebSocketEvent(num, type, payload, length); }}
// WebSocket event handler for fast binary uploads// Protocol:// 1. Client sends TEXT message: "START:<filename>:<size>:<path>"// 2. Client sends BINARY messages with file data chunks// 3. Server sends TEXT "PROGRESS:<received>:<total>" after each chunk// 4. Server sends TEXT "DONE" or "ERROR:<message>" when completevoid CrossPointWebServer::onWebSocketEvent(uint8_t num, WStype_t type, uint8_t* payload, size_t length) { switch (type) { case WStype_DISCONNECTED: LOG_DBG("WS", "Client %u disconnected", num); // Only clean up if this is the client that owns the active upload. // A new client may have already started a fresh upload before this // DISCONNECTED event fires (race condition on quick cancel + retry). if (num == wsUploadClientNum && wsUploadInProgress && wsUploadFile) { abortWsUpload("WS"); } break;
case WStype_CONNECTED: { LOG_DBG("WS", "Client %u connected", num); break; }
case WStype_TEXT: { // Parse control messages String msg = String((char*)payload); LOG_DBG("WS", "Text from client %u: %s", num, msg.c_str());
if (msg.startsWith("START:")) { // Reject any START while an upload is already active to prevent // leaking the open wsUploadFile handle (owning client re-START included) if (wsUploadInProgress) { wsServer->sendTXT(num, "ERROR:Upload already in progress"); break; }
// Parse: START:<filename>:<size>:<path> int firstColon = msg.indexOf(':', 6); int secondColon = msg.indexOf(':', firstColon + 1);
if (firstColon > 0 && secondColon > 0) { wsUploadFileName = msg.substring(6, firstColon); String sizeToken = msg.substring(firstColon + 1, secondColon); bool sizeValid = sizeToken.length() > 0; int digitStart = (sizeValid && sizeToken[0] == '+') ? 1 : 0; if (digitStart > 0 && sizeToken.length() < 2) sizeValid = false; for (int i = digitStart; i < (int)sizeToken.length() && sizeValid; i++) { if (!isdigit((unsigned char)sizeToken[i])) sizeValid = false; } if (!sizeValid) { LOG_DBG("WS", "START rejected: invalid size token '%s'", sizeToken.c_str()); wsServer->sendTXT(num, "ERROR:Invalid START format"); return; } wsUploadSize = sizeToken.toInt(); wsUploadPath = msg.substring(secondColon + 1); wsUploadReceived = 0; wsLastProgressSent = 0; wsUploadStartTime = millis();
// Ensure path is valid if (!wsUploadPath.startsWith("/")) wsUploadPath = "/" + wsUploadPath; if (wsUploadPath.length() > 1 && wsUploadPath.endsWith("/")) { wsUploadPath = wsUploadPath.substring(0, wsUploadPath.length() - 1); }
// Build file path String filePath = wsUploadPath; if (!filePath.endsWith("/")) filePath += "/"; filePath += wsUploadFileName;
LOG_DBG("WS", "Starting upload: %s (%d bytes) to %s", wsUploadFileName.c_str(), wsUploadSize, filePath.c_str());
// Check if file exists and remove it esp_task_wdt_reset(); if (Storage.exists(filePath.c_str())) { Storage.remove(filePath.c_str()); }
// Open file for writing esp_task_wdt_reset(); if (!Storage.openFileForWrite("WS", filePath, wsUploadFile)) { wsServer->sendTXT(num, "ERROR:Failed to create file"); wsUploadInProgress = false; wsUploadClientNum = 255; return; } esp_task_wdt_reset();
// Zero-byte upload: complete immediately without waiting for BIN frames if (wsUploadSize == 0) { // Explicit close() required: file-scope global persists beyond function scope wsUploadFile.close(); wsLastCompleteName = wsUploadFileName; wsLastCompleteSize = 0; wsLastCompleteAt = millis(); LOG_DBG("WS", "Zero-byte upload complete: %s", filePath.c_str()); clearEpubCacheIfNeeded(filePath); wsServer->sendTXT(num, "DONE"); wsLastProgressSent = 0; break; }
wsUploadClientNum = num; wsUploadInProgress = true; wsServer->sendTXT(num, "READY"); } else { wsServer->sendTXT(num, "ERROR:Invalid START format"); } } break; }
case WStype_BIN: { if (!wsUploadInProgress || !wsUploadFile || num != wsUploadClientNum) { wsServer->sendTXT(num, "ERROR:No upload in progress"); return; }
// Write binary data directly to file size_t remaining = wsUploadSize - wsUploadReceived; if (length > remaining) { abortWsUpload("WS"); wsServer->sendTXT(num, "ERROR:Upload overflow"); return; } esp_task_wdt_reset(); size_t written = wsUploadFile.write(payload, length); esp_task_wdt_reset();
if (written != length) { abortWsUpload("WS"); wsServer->sendTXT(num, "ERROR:Write failed - disk full?"); return; }
wsUploadReceived += written;
// Send progress update (every 64KB or at end) if (wsUploadReceived - wsLastProgressSent >= 65536 || wsUploadReceived >= wsUploadSize) { String progress = "PROGRESS:" + String(wsUploadReceived) + ":" + String(wsUploadSize); wsServer->sendTXT(num, progress); wsLastProgressSent = wsUploadReceived; }
// Check if upload complete if (wsUploadReceived >= wsUploadSize) { // Explicit close() required: file-scope global persists beyond function scope wsUploadFile.close(); wsUploadInProgress = false; wsUploadClientNum = 255;
wsLastCompleteName = wsUploadFileName; wsLastCompleteSize = wsUploadSize; wsLastCompleteAt = millis();
unsigned long elapsed = millis() - wsUploadStartTime; float kbps = (elapsed > 0) ? (wsUploadSize / 1024.0) / (elapsed / 1000.0) : 0;
LOG_DBG("WS", "Upload complete: %s (%d bytes in %lu ms, %.1f KB/s)", wsUploadFileName.c_str(), wsUploadSize, elapsed, kbps);
// Clear epub cache to prevent stale metadata issues when overwriting files String filePath = wsUploadPath; if (!filePath.endsWith("/")) filePath += "/"; filePath += wsUploadFileName; clearEpubCacheIfNeeded(filePath);
wsServer->sendTXT(num, "DONE"); wsLastProgressSent = 0; } break; }
default: break; }}