mirror of
https://github.com/IoTManagerProject/IoTManager.git
synced 2026-03-26 22:22:16 +03:00
708 lines
18 KiB
C++
708 lines
18 KiB
C++
#include "StandWebServer.h"
|
||
#ifdef STANDARD_WEB_SERVER
|
||
|
||
File uploadFile;
|
||
String unsupportedFiles = String();
|
||
|
||
static const char TEXT_PLAIN[] PROGMEM = "text/plain";
|
||
static const char FS_INIT_ERROR[] PROGMEM = "FS INIT ERROR";
|
||
static const char FILE_NOT_FOUND[] PROGMEM = "FileNotFound";
|
||
//static bool fsOK;
|
||
//const char* fsName = "LittleFS";
|
||
|
||
void standWebServerInit()
|
||
{
|
||
// Кэшировать файлы для быстрой работы
|
||
HTTP.serveStatic("/bundle.js", FileFS, "/", "max-age=31536000"); // кеширование на 1 год
|
||
HTTP.serveStatic("/bundle.css", FileFS, "/", "max-age=31536000"); // кеширование на 1 год
|
||
HTTP.serveStatic("/bundle.js.gz", FileFS, "/", "max-age=31536000"); // кеширование на 1 год
|
||
HTTP.serveStatic("/bundle.css.gz", FileFS, "/", "max-age=31536000"); // кеширование на 1 год
|
||
HTTP.serveStatic("/favicon.png", FileFS, "/", "max-age=31536000"); // кеширование на 1 год
|
||
|
||
// HTTP.on("/devicelist.json", HTTP_GET, []() {
|
||
// HTTP.send(200, "application/json", devListHeapJson);
|
||
// });
|
||
HTTP.on("/settings.h.json", HTTP_GET, []() {
|
||
HTTP.send(200, "application/json", settingsFlashJson);
|
||
});
|
||
// HTTP.on("/settings.f.json", HTTP_GET, []() {
|
||
// HTTP.send(200, "application/json", readFile(F("settings.json"), 20000));
|
||
// });
|
||
// HTTP.on("/params.json", HTTP_GET, []() {
|
||
// String json = getParamsJson();
|
||
// HTTP.send(200, "application/json", json);
|
||
// });
|
||
// HTTP.on("/errors.json", HTTP_GET, []() {
|
||
// HTTP.send(200, "application/json", errorsHeapJson);
|
||
// });
|
||
// HTTP.on("/config.json", HTTP_GET, []() {
|
||
// HTTP.send(200, "application/json", readFile(F("config.json"), 20000));
|
||
// });
|
||
// HTTP.on("/layout.json", HTTP_GET, []() {
|
||
// HTTP.send(200, "application/json", readFile(F("layout.json"), 20000));
|
||
// });
|
||
// HTTP.on("/restart", HTTP_GET, []() {
|
||
// // ESP.restart();
|
||
// HTTP.send(200, "text/plain", "ok");
|
||
// });
|
||
|
||
|
||
HTTP.on("/set", HTTP_GET, []() {
|
||
if (HTTP.hasArg(F("routerssid")) && WiFi.getMode() == WIFI_AP) {
|
||
jsonWriteStr(settingsFlashJson, F("routerssid"), HTTP.arg(F("routerssid")));
|
||
syncSettingsFlashJson();
|
||
HTTP.send(200, "text/plain", "ok");
|
||
}
|
||
|
||
if (HTTP.hasArg(F("routerpass")) && WiFi.getMode() == WIFI_AP) {
|
||
jsonWriteStr(settingsFlashJson, F("routerpass"), HTTP.arg(F("routerpass")));
|
||
syncSettingsFlashJson();
|
||
HTTP.send(200, "text/plain", "ok");
|
||
}
|
||
|
||
});
|
||
|
||
// Добавляем функцию Update для перезаписи прошивки по WiFi при 1М(256K FileFS) и выше
|
||
// httpUpdater.setup(&HTTP);
|
||
|
||
// Запускаем HTTP сервер
|
||
HTTP.begin();
|
||
|
||
// HTTP страницы для работы с FFS
|
||
|
||
////////////////////////////////
|
||
// WEB SERVER INIT
|
||
|
||
// Filesystem status
|
||
HTTP.on("/status", HTTP_GET, handleStatus);
|
||
|
||
// List directory
|
||
HTTP.on("/list", HTTP_GET, handleFileList);
|
||
|
||
// Load editor
|
||
HTTP.on("/edit", HTTP_GET, handleGetEdit);
|
||
|
||
// Create file
|
||
HTTP.on("/edit", HTTP_PUT, handleFileCreate);
|
||
|
||
// Delete file
|
||
HTTP.on("/edit", HTTP_DELETE, handleFileDelete);
|
||
|
||
// Upload file
|
||
// - first callback is called after the request has ended with all parsed arguments
|
||
// - second callback handles file upload at that location
|
||
HTTP.on("/edit", HTTP_POST, replyOK, handleFileUpload);
|
||
|
||
// Default handler for all URIs not defined above
|
||
// Use it to read files from filesystem
|
||
HTTP.onNotFound(handleNotFound);
|
||
}
|
||
|
||
////////////////////////////////
|
||
// Utils to return HTTP codes, and determine content-type
|
||
|
||
void replyOK()
|
||
{
|
||
HTTP.send(200, FPSTR(TEXT_PLAIN), "");
|
||
}
|
||
|
||
void replyOKWithMsg(String msg)
|
||
{
|
||
HTTP.send(200, FPSTR(TEXT_PLAIN), msg);
|
||
}
|
||
|
||
void replyNotFound(String msg)
|
||
{
|
||
HTTP.send(404, FPSTR(TEXT_PLAIN), msg);
|
||
}
|
||
|
||
void replyBadRequest(String msg)
|
||
{
|
||
// DBG_OUTPUT_PORT.println(msg);
|
||
HTTP.send(400, FPSTR(TEXT_PLAIN), msg + "\r\n");
|
||
}
|
||
|
||
void replyServerError(String msg)
|
||
{
|
||
// DBG_OUTPUT_PORT.println(msg);
|
||
HTTP.send(500, FPSTR(TEXT_PLAIN), msg + "\r\n");
|
||
}
|
||
|
||
/*
|
||
Return the FS type, status and size info
|
||
*/
|
||
void handleStatus()
|
||
{
|
||
// DBG_OUTPUT_PORT.println("handleStatus");
|
||
String json;
|
||
json.reserve(128);
|
||
|
||
json = "{\"type\":\"";
|
||
json += FS_NAME;
|
||
json += "\", \"isOk\":";
|
||
|
||
#ifdef ESP8266
|
||
FSInfo fs_info;
|
||
|
||
FileFS.info(fs_info);
|
||
json += F("\"true\", \"totalBytes\":\"");
|
||
json += fs_info.totalBytes;
|
||
json += F("\", \"usedBytes\":\"");
|
||
json += fs_info.usedBytes;
|
||
json += "\"";
|
||
#endif
|
||
#ifdef ESP32
|
||
json += F("\"true\", \"totalBytes\":\"");
|
||
json += String(FileFS.totalBytes());
|
||
json += F("\", \"usedBytes\":\"");
|
||
json += String(FileFS.usedBytes());
|
||
json += "\"";
|
||
#endif
|
||
|
||
json += F(",\"unsupportedFiles\":\"");
|
||
json += unsupportedFiles;
|
||
json += "\"}";
|
||
|
||
HTTP.send(200, "application/json", json);
|
||
}
|
||
|
||
#ifdef ESP32
|
||
String getContentType(String filename) {
|
||
if (HTTP.hasArg("download")) {
|
||
return "application/octet-stream";
|
||
} else if (filename.endsWith(".htm")) {
|
||
return "text/html";
|
||
} else if (filename.endsWith(".html")) {
|
||
return "text/html";
|
||
} else if (filename.endsWith(".css")) {
|
||
return "text/css";
|
||
} else if (filename.endsWith(".js")) {
|
||
return "application/javascript";
|
||
} else if (filename.endsWith(".png")) {
|
||
return "image/png";
|
||
} else if (filename.endsWith(".gif")) {
|
||
return "image/gif";
|
||
} else if (filename.endsWith(".jpg")) {
|
||
return "image/jpeg";
|
||
} else if (filename.endsWith(".ico")) {
|
||
return "image/x-icon";
|
||
} else if (filename.endsWith(".xml")) {
|
||
return "text/xml";
|
||
} else if (filename.endsWith(".pdf")) {
|
||
return "application/x-pdf";
|
||
} else if (filename.endsWith(".zip")) {
|
||
return "application/x-zip";
|
||
} else if (filename.endsWith(".gz")) {
|
||
return "application/x-gzip";
|
||
}
|
||
return "text/plain";
|
||
}
|
||
#endif
|
||
|
||
/*
|
||
Read the given file from the filesystem and stream it back to the client
|
||
*/
|
||
bool handleFileRead(String path)
|
||
{
|
||
// DBG_OUTPUT_PORT.println(String("handleFileRead: ") + path);
|
||
if (path.endsWith("/"))
|
||
{
|
||
path += "index.html";
|
||
}
|
||
|
||
String contentType;
|
||
if (HTTP.hasArg("download"))
|
||
{
|
||
contentType = F("application/octet-stream");
|
||
}
|
||
else
|
||
{
|
||
#ifdef ESP32
|
||
contentType = getContentType(path);
|
||
#endif
|
||
#ifdef ESP8266
|
||
contentType = mime::getContentType(path);
|
||
#endif
|
||
}
|
||
|
||
if (!FileFS.exists(path))
|
||
{
|
||
// File not found, try gzip version
|
||
path = path + ".gz";
|
||
}
|
||
if (FileFS.exists(path))
|
||
{
|
||
File file = FileFS.open(path, "r");
|
||
if (HTTP.streamFile(file, contentType) != file.size())
|
||
{
|
||
// DBG_OUTPUT_PORT.println("Sent less data than expected!");
|
||
}
|
||
file.close();
|
||
return true;
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
/*
|
||
As some FS (e.g. LittleFS) delete the parent folder when the last child has been removed,
|
||
return the path of the closest parent still existing
|
||
*/
|
||
String lastExistingParent(String path)
|
||
{
|
||
while (!path.isEmpty() && !FileFS.exists(path))
|
||
{
|
||
if (path.lastIndexOf('/') > 0)
|
||
{
|
||
path = path.substring(0, path.lastIndexOf('/'));
|
||
}
|
||
else
|
||
{
|
||
path = String(); // No slash => the top folder does not exist
|
||
}
|
||
}
|
||
// DBG_OUTPUT_PORT.println(String("Last existing parent: ") + path);
|
||
return path;
|
||
}
|
||
|
||
/*
|
||
Handle a file upload request
|
||
*/
|
||
void handleFileUpload()
|
||
{
|
||
if (HTTP.uri() != "/edit")
|
||
{
|
||
return;
|
||
}
|
||
HTTPUpload &upload = HTTP.upload();
|
||
if (upload.status == UPLOAD_FILE_START)
|
||
{
|
||
String filename = upload.filename;
|
||
// Make sure paths always start with "/"
|
||
if (!filename.startsWith("/"))
|
||
{
|
||
filename = "/" + filename;
|
||
}
|
||
// DBG_OUTPUT_PORT.println(String("handleFileUpload Name: ") + filename);
|
||
uploadFile = FileFS.open(filename, "w");
|
||
if (!uploadFile)
|
||
{
|
||
return replyServerError(F("CREATE FAILED"));
|
||
}
|
||
// DBG_OUTPUT_PORT.println(String("Upload: START, filename: ") + filename);
|
||
}
|
||
else if (upload.status == UPLOAD_FILE_WRITE)
|
||
{
|
||
if (uploadFile)
|
||
{
|
||
size_t bytesWritten = uploadFile.write(upload.buf, upload.currentSize);
|
||
if (bytesWritten != upload.currentSize)
|
||
{
|
||
return replyServerError(F("WRITE FAILED"));
|
||
}
|
||
}
|
||
// DBG_OUTPUT_PORT.println(String("Upload: WRITE, Bytes: ") + upload.currentSize);
|
||
}
|
||
else if (upload.status == UPLOAD_FILE_END)
|
||
{
|
||
if (uploadFile)
|
||
{
|
||
uploadFile.close();
|
||
}
|
||
// DBG_OUTPUT_PORT.println(String("Upload: END, Size: ") + upload.totalSize);
|
||
}
|
||
}
|
||
|
||
|
||
#ifdef ESP8266
|
||
void deleteRecursive(String path)
|
||
{
|
||
File file = FileFS.open(path, "r");
|
||
bool isDir = file.isDirectory();
|
||
file.close();
|
||
|
||
// If it's a plain file, delete it
|
||
if (!isDir)
|
||
{
|
||
FileFS.remove(path);
|
||
return;
|
||
}
|
||
Dir dir = FileFS.openDir(path);
|
||
while (dir.next())
|
||
{
|
||
deleteRecursive(path + '/' + dir.fileName());
|
||
}
|
||
|
||
// Then delete the folder itself
|
||
FileFS.rmdir(path);
|
||
}
|
||
#endif
|
||
|
||
#ifdef ESP32
|
||
struct treename{
|
||
uint8_t type;
|
||
char *name;
|
||
};
|
||
|
||
|
||
void deleteRecursive( String path ){
|
||
fs::File dir = FileFS.open( path );
|
||
|
||
if(!dir.isDirectory()){
|
||
Serial.printf("%s is a file\n", path);
|
||
dir.close();
|
||
Serial.printf( "result of removing file %s: %d\n", path, FileFS.remove( path ) );
|
||
return;
|
||
}
|
||
|
||
Serial.printf("%s is a directory\n", path);
|
||
|
||
fs::File entry, nextentry;
|
||
|
||
while ( entry = dir.openNextFile() ){
|
||
|
||
if ( entry.isDirectory() ){
|
||
deleteRecursive( entry.path() );
|
||
} else{
|
||
String tmpname = path+"/"+strdup( entry.name() ); // buffer file name
|
||
entry.close();
|
||
Serial.printf( "result of removing file %s: %d\n", tmpname, FileFS.remove( tmpname ) );
|
||
}
|
||
|
||
}
|
||
|
||
dir.close();
|
||
Serial.printf( "result of removing directory %s: %d\n", path, FileFS.rmdir( path ) );
|
||
|
||
}
|
||
#endif
|
||
/*
|
||
Handle a file deletion request
|
||
Operation | req.responseText
|
||
---------------+--------------------------------------------------------------
|
||
Delete file | parent of deleted file, or remaining ancestor
|
||
Delete folder | parent of deleted folder, or remaining ancestor
|
||
*/
|
||
void handleFileDelete()
|
||
{
|
||
String path = HTTP.arg(0);
|
||
if (path.isEmpty() || path == "/")
|
||
{
|
||
return replyBadRequest("BAD PATH");
|
||
}
|
||
|
||
// DBG_OUTPUT_PORT.println(String("handleFileDelete: ") + path);
|
||
if (!FileFS.exists(path))
|
||
{
|
||
return replyNotFound(FPSTR(FILE_NOT_FOUND));
|
||
}
|
||
deleteRecursive(path);
|
||
|
||
|
||
|
||
replyOKWithMsg(lastExistingParent(path));
|
||
}
|
||
|
||
/*
|
||
Handle the creation/rename of a new file
|
||
Operation | req.responseText
|
||
---------------+--------------------------------------------------------------
|
||
Create file | parent of created file
|
||
Create folder | parent of created folder
|
||
Rename file | parent of source file
|
||
Move file | parent of source file, or remaining ancestor
|
||
Rename folder | parent of source folder
|
||
Move folder | parent of source folder, or remaining ancestor
|
||
*/
|
||
void handleFileCreate()
|
||
{
|
||
String path = HTTP.arg("path");
|
||
if (path.isEmpty())
|
||
{
|
||
return replyBadRequest(F("PATH ARG MISSING"));
|
||
}
|
||
|
||
#ifdef USE_SPIFFS
|
||
if (checkForUnsupportedPath(path).length() > 0)
|
||
{
|
||
return replyServerError(F("INVALID FILENAME"));
|
||
}
|
||
#endif
|
||
|
||
if (path == "/")
|
||
{
|
||
return replyBadRequest("BAD PATH");
|
||
}
|
||
if (FileFS.exists(path))
|
||
{
|
||
return replyBadRequest(F("PATH FILE EXISTS"));
|
||
}
|
||
|
||
String src = HTTP.arg("src");
|
||
if (src.isEmpty())
|
||
{
|
||
// No source specified: creation
|
||
// DBG_OUTPUT_PORT.println(String("handleFileCreate: ") + path);
|
||
if (path.endsWith("/"))
|
||
{
|
||
// Create a folder
|
||
path.remove(path.length() - 1);
|
||
if (!FileFS.mkdir(path))
|
||
{
|
||
return replyServerError(F("MKDIR FAILED"));
|
||
}
|
||
}
|
||
else
|
||
{
|
||
// Create a file
|
||
File file = FileFS.open(path, "w");
|
||
if (file)
|
||
{
|
||
#ifdef ESP8266
|
||
file.write((const char *)0);
|
||
#endif
|
||
#ifdef ESP32
|
||
file.write(0);
|
||
#endif
|
||
file.close();
|
||
}
|
||
else
|
||
{
|
||
return replyServerError(F("CREATE FAILED"));
|
||
}
|
||
}
|
||
if (path.lastIndexOf('/') > -1)
|
||
{
|
||
path = path.substring(0, path.lastIndexOf('/'));
|
||
}
|
||
replyOKWithMsg(path);
|
||
}
|
||
else
|
||
{
|
||
// Source specified: rename
|
||
if (src == "/")
|
||
{
|
||
return replyBadRequest("BAD SRC");
|
||
}
|
||
if (!FileFS.exists(src))
|
||
{
|
||
return replyBadRequest(F("SRC FILE NOT FOUND"));
|
||
}
|
||
|
||
// DBG_OUTPUT_PORT.println(String("handleFileCreate: ") + path + " from " + src);
|
||
|
||
if (path.endsWith("/"))
|
||
{
|
||
path.remove(path.length() - 1);
|
||
}
|
||
if (src.endsWith("/"))
|
||
{
|
||
src.remove(src.length() - 1);
|
||
}
|
||
if (!FileFS.rename(src, path))
|
||
{
|
||
return replyServerError(F("RENAME FAILED"));
|
||
}
|
||
replyOKWithMsg(lastExistingParent(src));
|
||
}
|
||
}
|
||
|
||
/*
|
||
Return the list of files in the directory specified by the "dir" query string parameter.
|
||
Also demonstrates the use of chunked responses.
|
||
*/
|
||
#ifdef ESP8266
|
||
void handleFileList()
|
||
{
|
||
if (!HTTP.hasArg("dir"))
|
||
{
|
||
return replyBadRequest(F("DIR ARG MISSING"));
|
||
}
|
||
|
||
String path = HTTP.arg("dir");
|
||
if (path != "/" && !FileFS.exists(path))
|
||
{
|
||
return replyBadRequest("BAD PATH");
|
||
}
|
||
|
||
// DBG_OUTPUT_PORT.println(String("handleFileList: ") + path);
|
||
Dir dir = FileFS.openDir(path);
|
||
path.clear();
|
||
|
||
// use HTTP/1.1 Chunked response to avoid building a huge temporary string
|
||
if (!HTTP.chunkedResponseModeStart(200, "text/json"))
|
||
{
|
||
HTTP.send(505, F("text/html"), F("HTTP1.1 required"));
|
||
return;
|
||
}
|
||
|
||
// use the same string for every line
|
||
String output;
|
||
output.reserve(64);
|
||
while (dir.next())
|
||
{
|
||
#ifdef USE_SPIFFS
|
||
String error = checkForUnsupportedPath(dir.fileName());
|
||
if (error.length() > 0)
|
||
{
|
||
// DBG_OUTPUT_PORT.println(String("Ignoring ") + error + dir.fileName());
|
||
continue;
|
||
}
|
||
#endif
|
||
if (output.length())
|
||
{
|
||
// send string from previous iteration
|
||
// as an HTTP chunk
|
||
HTTP.sendContent(output);
|
||
output = ',';
|
||
}
|
||
else
|
||
{
|
||
output = '[';
|
||
}
|
||
|
||
output += "{\"type\":\"";
|
||
if (dir.isDirectory())
|
||
{
|
||
output += "dir";
|
||
}
|
||
else
|
||
{
|
||
output += F("file\",\"size\":\"");
|
||
output += dir.fileSize();
|
||
}
|
||
|
||
output += F("\",\"name\":\"");
|
||
// Always return names without leading "/"
|
||
if (dir.fileName()[0] == '/')
|
||
{
|
||
output += &(dir.fileName()[1]);
|
||
}
|
||
else
|
||
{
|
||
output += dir.fileName();
|
||
}
|
||
|
||
output += "\"}";
|
||
}
|
||
|
||
// send last string
|
||
output += "]";
|
||
HTTP.sendContent(output);
|
||
HTTP.chunkedResponseFinalize();
|
||
}
|
||
#endif
|
||
|
||
#ifdef ESP32
|
||
void handleFileList() {
|
||
if (!HTTP.hasArg("dir")) {
|
||
HTTP.send(500, "text/plain", "BAD ARGS");
|
||
return;
|
||
}
|
||
|
||
String path = HTTP.arg("dir");
|
||
// DBG_OUTPUT_PORT.println("handleFileList: " + path);
|
||
|
||
|
||
File root = FileFS.open(path);
|
||
path = String();
|
||
|
||
String output = "[";
|
||
if(root.isDirectory()){
|
||
File file = root.openNextFile();
|
||
while(file){
|
||
if (output != "[") {
|
||
output += ',';
|
||
}
|
||
output += "{\"type\":\"";
|
||
// output += (file.isDirectory()) ? "dir" : "file";
|
||
if (file.isDirectory())
|
||
{
|
||
output += "dir";
|
||
}
|
||
else
|
||
{
|
||
output += F("file\",\"size\":\"");
|
||
output += file.size();
|
||
}
|
||
|
||
output += "\",\"name\":\"";
|
||
output += String(file.name());
|
||
output += "\"}";
|
||
file = root.openNextFile();
|
||
}
|
||
}
|
||
output += "]";
|
||
HTTP.send(200, "text/json", output);
|
||
|
||
}
|
||
#endif
|
||
|
||
|
||
/*
|
||
The "Not Found" handler catches all URI not explicitly declared in code
|
||
First try to find and return the requested file from the filesystem,
|
||
and if it fails, return a 404 page with debug information
|
||
*/
|
||
void handleNotFound()
|
||
{
|
||
#ifdef ESP8266
|
||
String uri = ESP8266WebServer::urlDecode(HTTP.uri()); // required to read paths with blanks
|
||
#endif
|
||
#ifdef ESP32
|
||
String uri = WebServer::urlDecode(HTTP.uri()); // required to read paths with blanks
|
||
#endif
|
||
if (handleFileRead(uri))
|
||
{
|
||
return;
|
||
}
|
||
|
||
// Dump debug data
|
||
String message;
|
||
message.reserve(100);
|
||
message = F("Error: File not found\n\nURI: ");
|
||
message += uri;
|
||
message += F("\nMethod: ");
|
||
message += (HTTP.method() == HTTP_GET) ? "GET" : "POST";
|
||
message += F("\nArguments: ");
|
||
message += HTTP.args();
|
||
message += '\n';
|
||
for (uint8_t i = 0; i < HTTP.args(); i++)
|
||
{
|
||
message += F(" NAME:");
|
||
message += HTTP.argName(i);
|
||
message += F("\n VALUE:");
|
||
message += HTTP.arg(i);
|
||
message += '\n';
|
||
}
|
||
message += "path=";
|
||
message += HTTP.arg("path");
|
||
message += '\n';
|
||
// DBG_OUTPUT_PORT.print(message);
|
||
|
||
return replyNotFound(message);
|
||
}
|
||
|
||
/*
|
||
This specific handler returns the index.htm (or a gzipped version) from the /edit folder.
|
||
If the file is not present but the flag INCLUDE_FALLBACK_INDEX_HTM has been set, falls back to the version
|
||
embedded in the program code.
|
||
Otherwise, fails with a 404 page with debug information
|
||
*/
|
||
void handleGetEdit()
|
||
{
|
||
if (handleFileRead(F("/edit.htm")))
|
||
{
|
||
return;
|
||
}
|
||
|
||
#ifdef INCLUDE_FALLBACK_INDEX_HTM
|
||
server.sendHeader(F("Content-Encoding"), "gzip");
|
||
server.send(200, "text/html", index_htm_gz, index_htm_gz_len);
|
||
#else
|
||
replyNotFound(FPSTR(FILE_NOT_FOUND));
|
||
#endif
|
||
}
|
||
|
||
#endif
|