mirror of
https://git.mirrors.martin98.com/https://github.com/luc-github/ESP3D.git
synced 2025-06-06 02:36:49 +08:00
1383 lines
58 KiB
C++
1383 lines
58 KiB
C++
/*
|
|
syncwebserver.cpp - ESP3D sync functions class
|
|
|
|
Copyright (c) 2014 Luc Lebosse. All rights reserved.
|
|
|
|
This library is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU Lesser General Public
|
|
License as published by the Free Software Foundation; either
|
|
version 2.1 of the License, or (at your option) any later version.
|
|
|
|
This library is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public
|
|
License along with this library; if not, write to the Free Software
|
|
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
*/
|
|
|
|
#include <pgmspace.h>
|
|
#include "config.h"
|
|
#if !defined(ASYNCWEBSERVER)
|
|
|
|
#include "webinterface.h"
|
|
#include "wificonf.h"
|
|
#include <WiFiClient.h>
|
|
#include <WiFiServer.h>
|
|
#include <WiFiUdp.h>
|
|
#include <StreamString.h>
|
|
#ifndef FS_NO_GLOBALS
|
|
#define FS_NO_GLOBALS
|
|
#endif
|
|
#include <FS.h>
|
|
#if defined ( ARDUINO_ARCH_ESP8266)
|
|
#include "ESP8266WiFi.h"
|
|
#include <ESP8266WebServer.h>
|
|
#endif
|
|
#if defined ( ARDUINO_ARCH_ESP32)
|
|
#include <WiFi.h>
|
|
#include <WebServer.h>
|
|
#include "SPIFFS.h"
|
|
#include "Update.h"
|
|
#include <esp_ota_ops.h>
|
|
#endif
|
|
|
|
#include "GenLinkedList.h"
|
|
#include "command.h"
|
|
#include "espcom.h"
|
|
|
|
#ifdef SSDP_FEATURE
|
|
#ifdef ARDUINO_ARCH_ESP32
|
|
#include <ESP32SSDP.h>
|
|
#else
|
|
#include <ESP8266SSDP.h>
|
|
#endif
|
|
#endif
|
|
|
|
//embedded response file if no files on SPIFFS
|
|
#include "nofile.h"
|
|
#include "syncwebserver.h"
|
|
WebSocketsServer * socket_server;
|
|
|
|
|
|
#define ESP_ERROR_AUTHENTICATION 1
|
|
#define ESP_ERROR_FILE_CREATION 2
|
|
#define ESP_ERROR_FILE_WRITE 3
|
|
#define ESP_ERROR_UPLOAD 4
|
|
#define ESP_ERROR_NOT_ENOUGH_SPACE 5
|
|
#define ESP_ERROR_UPLOAD_CANCELLED 6
|
|
#define ESP_ERROR_FILE_CLOSE 7
|
|
#define ESP_ERROR_NO_SD 8
|
|
#define ESP_ERROR_MOUNT_SD 9
|
|
#define ESP_ERROR_RESET_NUMBERING 10
|
|
#define ESP_ERROR_BUFFER_OVERFLOW 11
|
|
#define ESP_ERROR_START_UPLOAD 12
|
|
|
|
|
|
void pushError(int code, const char * st, uint16_t web_error = 500, uint16_t timeout = 1000){
|
|
if (socket_server && st) {
|
|
String s = "ERROR:" + String(code) + ":";
|
|
s+=st;
|
|
socket_server->sendTXT(ESPCOM::current_socket_id, s);
|
|
if (web_error != 0) {
|
|
if (web_interface) {
|
|
if (web_interface->web_server.client().available() > 0) {
|
|
web_interface->web_server.send (web_error, "text/xml", st);
|
|
}
|
|
}
|
|
}
|
|
uint32_t t = millis();
|
|
while (millis() - t < timeout) {
|
|
socket_server->loop();
|
|
delay(10);
|
|
}
|
|
}
|
|
}
|
|
|
|
//abort reception of packages
|
|
void cancelUpload(){
|
|
if (web_interface) {
|
|
if (web_interface->web_server.client().available() > 0) {
|
|
HTTPUpload& upload = (web_interface->web_server).upload();
|
|
upload.status = UPLOAD_FILE_ABORTED;
|
|
#if defined (ARDUINO_ARCH_ESP8266)
|
|
web_interface->web_server.client().stopAll();
|
|
#endif
|
|
#if defined (ARDUINO_ARCH_ESP32)
|
|
errno = ECONNABORTED;
|
|
web_interface->web_server.client().stop();
|
|
#endif
|
|
delay(100);
|
|
}
|
|
}
|
|
}
|
|
|
|
void webSocketEvent(uint8_t num, WStype_t type, uint8_t * payload, size_t length)
|
|
{
|
|
|
|
switch(type) {
|
|
case WStype_DISCONNECTED:
|
|
//USE_SERIAL.printf("[%u] Disconnected!\n", num);
|
|
break;
|
|
case WStype_CONNECTED: {
|
|
//IPAddress ip = socket_server->remoteIP(num);
|
|
//USE_SERIAL.printf("[%u] Connected from %d.%d.%d.%d url: %s\n", num, ip[0], ip[1], ip[2], ip[3], payload);
|
|
String s = "CURRENT_ID:" + String(num);
|
|
// send message to client
|
|
ESPCOM::current_socket_id = num;
|
|
socket_server->sendTXT(ESPCOM::current_socket_id, s);
|
|
s = "ACTIVE_ID:" + String(ESPCOM::current_socket_id);
|
|
socket_server->broadcastTXT(s);
|
|
}
|
|
break;
|
|
case WStype_TEXT:
|
|
//USE_SERIAL.printf("[%u] get Text: %s\n", num, payload);
|
|
|
|
// send message to client
|
|
// webSocket.sendTXT(num, "message here");
|
|
|
|
// send data to all connected clients
|
|
// webSocket.broadcastTXT("message here");
|
|
break;
|
|
case WStype_BIN:
|
|
//USE_SERIAL.printf("[%u] get binary length: %u\n", num, length);
|
|
//hexdump(payload, length);
|
|
|
|
// send message to client
|
|
// webSocket.sendBIN(num, payload, length);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
extern bool deleteRecursive(String path);
|
|
extern void CloseSerialUpload (bool iserror, String & filename, int32_t linenb);
|
|
extern bool sendLine2Serial (String & line, int32_t linenb, int32_t* newlinenb);
|
|
extern bool purge_serial();
|
|
|
|
const uint8_t PAGE_404 [] PROGMEM = "<HTML>\n<HEAD>\n<title>Redirecting...</title> \n</HEAD>\n<BODY>\n<CENTER>Unknown page : $QUERY$- you will be redirected...\n<BR><BR>\nif not redirected, <a href='http://$WEB_ADDRESS$'>click here</a>\n<BR><BR>\n<PROGRESS name='prg' id='prg'></PROGRESS>\n\n<script>\nvar i = 0; \nvar x = document.getElementById(\"prg\"); \nx.max=5; \nvar interval=setInterval(function(){\ni=i+1; \nvar x = document.getElementById(\"prg\"); \nx.value=i; \nif (i>5) \n{\nclearInterval(interval);\nwindow.location.href='/';\n}\n},1000);\n</script>\n</CENTER>\n</BODY>\n</HTML>\n\n";
|
|
const uint8_t PAGE_CAPTIVE [] PROGMEM = "<HTML>\n<HEAD>\n<title>Captive Portal</title> \n</HEAD>\n<BODY>\n<CENTER>Captive Portal page : $QUERY$- you will be redirected...\n<BR><BR>\nif not redirected, <a href='http://$WEB_ADDRESS$'>click here</a>\n<BR><BR>\n<PROGRESS name='prg' id='prg'></PROGRESS>\n\n<script>\nvar i = 0; \nvar x = document.getElementById(\"prg\"); \nx.max=5; \nvar interval=setInterval(function(){\ni=i+1; \nvar x = document.getElementById(\"prg\"); \nx.value=i; \nif (i>5) \n{\nclearInterval(interval);\nwindow.location.href='/';\n}\n},1000);\n</script>\n</CENTER>\n</BODY>\n</HTML>\n\n";
|
|
#define CONTENT_TYPE_HTML "text/html"
|
|
|
|
//Root of Webserver/////////////////////////////////////////////////////
|
|
|
|
void handle_web_interface_root()
|
|
{
|
|
String path = "/index.html";
|
|
String contentType = web_interface->getContentType(path);
|
|
String pathWithGz = path + ".gz";
|
|
//if have a index.html or gzip version this is default root page
|
|
if((SPIFFS.exists(pathWithGz) || SPIFFS.exists(path)) && !web_interface->web_server.hasArg("forcefallback") && web_interface->web_server.arg("forcefallback")!="yes") {
|
|
if(SPIFFS.exists(pathWithGz)) {
|
|
path = pathWithGz;
|
|
}
|
|
FS_FILE file = SPIFFS.open(path, SPIFFS_FILE_READ);
|
|
web_interface->web_server.streamFile(file, contentType);
|
|
file.close();
|
|
return;
|
|
}
|
|
//if no lets launch the default content
|
|
web_interface->web_server.sendHeader("Content-Encoding", "gzip");
|
|
web_interface->web_server.send_P(200,CONTENT_TYPE_HTML,PAGE_NOFILES,PAGE_NOFILES_SIZE);
|
|
}
|
|
|
|
//Login check///////////////////////////////////////////////////////////
|
|
void handle_login()
|
|
{
|
|
#ifdef AUTHENTICATION_FEATURE
|
|
String smsg;
|
|
String sUser,sPassword;
|
|
String auths;
|
|
int code = 200;
|
|
bool msg_alert_error=false;
|
|
//disconnect can be done anytime no need to check credential
|
|
if (web_interface->web_server.hasArg("DISCONNECT")) {
|
|
String cookie = web_interface->web_server.header("Cookie");
|
|
int pos = cookie.indexOf("ESPSESSIONID=");
|
|
String sessionID;
|
|
if (pos!= -1) {
|
|
int pos2 = cookie.indexOf(";",pos);
|
|
sessionID = cookie.substring(pos+strlen("ESPSESSIONID="),pos2);
|
|
}
|
|
web_interface->ClearAuthIP(web_interface->web_server.client().remoteIP(), sessionID.c_str());
|
|
web_interface->web_server.sendHeader("Set-Cookie","ESPSESSIONID=0");
|
|
web_interface->web_server.sendHeader("Cache-Control","no-cache");
|
|
String buffer2send = "{\"status\":\"Ok\",\"authentication_lvl\":\"guest\"}";
|
|
web_interface->web_server.send(code, "application/json", buffer2send);
|
|
return;
|
|
}
|
|
|
|
level_authenticate_type auth_level= web_interface->is_authenticated();
|
|
if (auth_level == LEVEL_GUEST) {
|
|
auths = F("guest");
|
|
} else if (auth_level == LEVEL_USER) {
|
|
auths = F("user");
|
|
} else if (auth_level == LEVEL_ADMIN) {
|
|
auths = F("admin");
|
|
} else {
|
|
auths = F("???");
|
|
}
|
|
|
|
//check is it is a submission or a query
|
|
if (web_interface->web_server.hasArg("SUBMIT")) {
|
|
//is there a correct list of query?
|
|
if ( web_interface->web_server.hasArg("PASSWORD")&& web_interface->web_server.hasArg("USER")) {
|
|
//USER
|
|
sUser = web_interface->web_server.arg("USER");
|
|
if ( !((sUser==FPSTR(DEFAULT_ADMIN_LOGIN)) || (sUser==FPSTR(DEFAULT_USER_LOGIN)))) {
|
|
msg_alert_error=true;
|
|
smsg=F("Error : Incorrect User");
|
|
code=401;
|
|
}
|
|
if (msg_alert_error == false) {
|
|
//Password
|
|
sPassword = web_interface->web_server.arg("PASSWORD");
|
|
String sadminPassword;
|
|
|
|
if (!CONFIG::read_string(EP_ADMIN_PWD, sadminPassword, MAX_LOCAL_PASSWORD_LENGTH)) {
|
|
sadminPassword=FPSTR(DEFAULT_ADMIN_PWD);
|
|
}
|
|
|
|
String suserPassword;
|
|
|
|
if (!CONFIG::read_string(EP_USER_PWD, suserPassword, MAX_LOCAL_PASSWORD_LENGTH)) {
|
|
suserPassword=FPSTR(DEFAULT_USER_PWD);
|
|
}
|
|
|
|
if(!(((sUser==FPSTR(DEFAULT_ADMIN_LOGIN)) && (strcmp(sPassword.c_str(),sadminPassword.c_str())==0)) ||
|
|
((sUser==FPSTR(DEFAULT_USER_LOGIN)) && (strcmp(sPassword.c_str(),suserPassword.c_str()) == 0)))) {
|
|
msg_alert_error=true;
|
|
smsg=F("Error: Incorrect password");
|
|
Serial.println(sPassword.c_str());
|
|
Serial.println(sadminPassword.c_str());
|
|
code = 401;
|
|
}
|
|
}
|
|
} else {
|
|
msg_alert_error=true;
|
|
smsg = F("Error: Missing data");
|
|
code = 500;
|
|
}
|
|
//change password
|
|
if ( web_interface->web_server.hasArg("PASSWORD")&& web_interface->web_server.hasArg("USER") && web_interface->web_server.hasArg("NEWPASSWORD") && (msg_alert_error==false) ) {
|
|
String newpassword = web_interface->web_server.arg("NEWPASSWORD");
|
|
if (CONFIG::isLocalPasswordValid(newpassword.c_str())) {
|
|
int pos=0;
|
|
if(sUser==FPSTR(DEFAULT_ADMIN_LOGIN)) {
|
|
pos = EP_ADMIN_PWD;
|
|
} else {
|
|
pos = EP_USER_PWD;
|
|
}
|
|
if (!CONFIG::write_string(pos,newpassword.c_str())) {
|
|
msg_alert_error=true;
|
|
smsg = F("Error: Cannot apply changes");
|
|
code = 500;
|
|
}
|
|
} else {
|
|
msg_alert_error=true;
|
|
smsg = F("Error: Incorrect password");
|
|
code = 500;
|
|
}
|
|
}
|
|
if ((code == 200) || (code == 500)) {
|
|
level_authenticate_type current_auth_level;
|
|
if(sUser == FPSTR(DEFAULT_ADMIN_LOGIN)) {
|
|
current_auth_level = LEVEL_ADMIN;
|
|
} else if(sUser == FPSTR(DEFAULT_USER_LOGIN)) {
|
|
current_auth_level = LEVEL_USER;
|
|
} else {
|
|
current_auth_level = LEVEL_GUEST;
|
|
}
|
|
//create Session
|
|
if ((current_auth_level != auth_level) || (auth_level== LEVEL_GUEST)) {
|
|
auth_ip * current_auth = new auth_ip;
|
|
current_auth->level = current_auth_level;
|
|
current_auth->ip=web_interface->web_server.client().remoteIP();
|
|
strcpy(current_auth->sessionID,web_interface->create_session_ID());
|
|
strcpy(current_auth->userID,sUser.c_str());
|
|
current_auth->last_time=millis();
|
|
if (web_interface->AddAuthIP(current_auth)) {
|
|
String tmps ="ESPSESSIONID=";
|
|
tmps+=current_auth->sessionID;
|
|
web_interface->web_server.sendHeader("Set-Cookie",tmps);
|
|
web_interface->web_server.sendHeader("Cache-Control","no-cache");
|
|
switch(current_auth->level) {
|
|
case LEVEL_ADMIN:
|
|
auths = "admin";
|
|
break;
|
|
case LEVEL_USER:
|
|
auths = "user";
|
|
break;
|
|
default:
|
|
auths = "guest";
|
|
break;
|
|
}
|
|
} else {
|
|
delete current_auth;
|
|
msg_alert_error=true;
|
|
code = 500;
|
|
smsg = F("Error: Too many connections");
|
|
}
|
|
}
|
|
}
|
|
if (code == 200) {
|
|
smsg = F("Ok");
|
|
}
|
|
|
|
//build JSON
|
|
String buffer2send = "{\"status\":\"" + smsg + "\",\"authentication_lvl\":\"";
|
|
buffer2send += auths;
|
|
buffer2send += "\"}";
|
|
web_interface->web_server.send(code, "application/json", buffer2send);
|
|
} else {
|
|
if (auth_level != LEVEL_GUEST) {
|
|
String cookie = web_interface->web_server.header("Cookie");
|
|
int pos = cookie.indexOf("ESPSESSIONID=");
|
|
String sessionID;
|
|
if (pos!= -1) {
|
|
int pos2 = cookie.indexOf(";",pos);
|
|
sessionID = cookie.substring(pos+strlen("ESPSESSIONID="),pos2);
|
|
auth_ip * current_auth_info = web_interface->GetAuth(web_interface->web_server.client().remoteIP(), sessionID.c_str());
|
|
if (current_auth_info != NULL) {
|
|
sUser = current_auth_info->userID;
|
|
}
|
|
}
|
|
}
|
|
String buffer2send = "{\"status\":\"200\",\"authentication_lvl\":\"";
|
|
buffer2send += auths;
|
|
buffer2send += "\",\"user\":\"";
|
|
buffer2send += sUser;
|
|
buffer2send +="\"}";
|
|
web_interface->web_server.send(code, "application/json", buffer2send);
|
|
}
|
|
#else
|
|
web_interface->web_server.sendHeader("Cache-Control","no-cache");
|
|
web_interface->web_server.send(200, "application/json", "{\"status\":\"Ok\",\"authentication_lvl\":\"admin\"}");
|
|
#endif
|
|
}
|
|
|
|
//SSDP interface////////////////////////////////////////
|
|
#ifdef SSDP_FEATURE
|
|
void handle_SSDP()
|
|
{
|
|
SSDP.schema(web_interface->web_server.client());
|
|
}
|
|
#endif
|
|
|
|
//SPIFFS files list and file commands///////////////////////////////////
|
|
void handleFileList()
|
|
{
|
|
level_authenticate_type auth_level = web_interface->is_authenticated();
|
|
if (auth_level == LEVEL_GUEST) {
|
|
web_interface->_upload_status=UPLOAD_STATUS_NONE;
|
|
web_interface->web_server.send(401,"text/plain","Authentication failed!\n");
|
|
return;
|
|
}
|
|
String path ;
|
|
String status = "Ok";
|
|
if ((web_interface->_upload_status == UPLOAD_STATUS_FAILED) || (web_interface->_upload_status == UPLOAD_STATUS_FAILED)) {
|
|
status = "Upload failed";
|
|
web_interface->_upload_status=UPLOAD_STATUS_NONE;
|
|
}
|
|
//be sure root is correct according authentication
|
|
if (auth_level == LEVEL_ADMIN) {
|
|
path = "/";
|
|
} else {
|
|
path = "/user";
|
|
}
|
|
//get current path
|
|
if(web_interface->web_server.hasArg("path")) {
|
|
path += web_interface->web_server.arg("path") ;
|
|
}
|
|
//to have a clean path
|
|
path.trim();
|
|
path.replace("//","/");
|
|
if (path[path.length()-1] !='/') {
|
|
path +="/";
|
|
}
|
|
//check if query need some action
|
|
if(web_interface->web_server.hasArg("action")) {
|
|
//delete a file
|
|
if(web_interface->web_server.arg ("action") == "delete" && web_interface->web_server.hasArg ("filename")) {
|
|
String filename;
|
|
String shortname = web_interface->web_server.arg ("filename");
|
|
shortname.replace ("/","");
|
|
filename = path + web_interface->web_server.arg ("filename");
|
|
filename.replace ("//","/");
|
|
if (!SPIFFS.exists (filename)) {
|
|
status = shortname + F(" does not exists!");
|
|
} else {
|
|
if (SPIFFS.remove(filename)) {
|
|
status = shortname + F(" deleted");
|
|
//what happen if no "/." and no other subfiles ?
|
|
#if defined(ARDUINO_ARCH_ESP8266)
|
|
FS_DIR dir = SPIFFS.openDir(path);
|
|
if (!dir.next()) {
|
|
#else
|
|
String ptmp = path;
|
|
if ( (path != "/") && (path[path.length() - 1] = '/') ) {
|
|
ptmp = path.substring (0, path.length() - 1);
|
|
}
|
|
FS_FILE dir = SPIFFS.open (ptmp);
|
|
FS_FILE dircontent = dir.openNextFile();
|
|
if (!dircontent) {
|
|
#endif
|
|
//keep directory alive even empty
|
|
FS_FILE r = SPIFFS.open (path+"/.", SPIFFS_FILE_WRITE);
|
|
if (r) {
|
|
r.close();
|
|
}
|
|
}
|
|
} else {
|
|
status = F("Cannot deleted ") ;
|
|
status += shortname ;
|
|
}
|
|
}
|
|
}
|
|
//delete a directory
|
|
if(web_interface->web_server.arg("action") == "deletedir" && web_interface->web_server.hasArg("filename")) {
|
|
String filename;
|
|
String shortname = web_interface->web_server.arg("filename");
|
|
shortname.replace("/","");
|
|
filename = path + web_interface->web_server.arg("filename");
|
|
filename += "/";
|
|
filename.replace("//","/");
|
|
if (filename != "/") {
|
|
bool delete_error = false;
|
|
#if defined ( ARDUINO_ARCH_ESP8266)
|
|
FS_DIR dir = SPIFFS.openDir(path + shortname);
|
|
{
|
|
while (dir.next()) {
|
|
#else
|
|
FS_FILE dir = SPIFFS.open(path + shortname);
|
|
{
|
|
FS_FILE file2deleted = dir.openNextFile();
|
|
while (file2deleted) {
|
|
#endif
|
|
#if defined ( ARDUINO_ARCH_ESP8266)
|
|
String fullpath = dir.fileName();
|
|
#else
|
|
String fullpath = file2deleted.name();
|
|
#endif
|
|
if (!SPIFFS.remove(fullpath)) {
|
|
delete_error = true;
|
|
status = F("Cannot deleted ") ;
|
|
status+=fullpath;
|
|
}
|
|
#if defined(ARDUINO_ARCH_ESP32)
|
|
file2deleted = dir.openNextFile();
|
|
#endif
|
|
}
|
|
}
|
|
if (!delete_error) {
|
|
status = shortname ;
|
|
status+=" deleted";
|
|
}
|
|
}
|
|
}
|
|
//create a directory
|
|
if(web_interface->web_server.arg("action")=="createdir" && web_interface->web_server.hasArg("filename")) {
|
|
String filename;
|
|
filename = path + web_interface->web_server.arg("filename") +"/.";
|
|
String shortname = web_interface->web_server.arg("filename");
|
|
shortname.replace("/","");
|
|
filename.replace("//","/");
|
|
if(SPIFFS.exists(filename)) {
|
|
status = shortname + F(" already exists!");
|
|
} else {
|
|
FS_FILE r = SPIFFS.open(filename,SPIFFS_FILE_WRITE);
|
|
if (!r) {
|
|
status = F("Cannot create ");
|
|
status += shortname ;
|
|
} else {
|
|
r.close();
|
|
status = shortname + F(" created");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
String jsonfile = "{";
|
|
#if defined ( ARDUINO_ARCH_ESP8266 )
|
|
FS_DIR dir = SPIFFS.openDir(path);
|
|
#else
|
|
String ptmp = path;
|
|
if ( (path != "/") && (path[path.length() - 1] = '/') ) {
|
|
ptmp = path.substring (0, path.length() - 1);
|
|
}
|
|
FS_FILE dir = SPIFFS.open(ptmp);
|
|
#endif
|
|
jsonfile+="\"files\":[";
|
|
bool firstentry=true;
|
|
String subdirlist="";
|
|
#if defined ( ARDUINO_ARCH_ESP8266 )
|
|
while (dir.next()) {
|
|
String filename = dir.fileName();
|
|
#else
|
|
File fileparsed = dir.openNextFile();
|
|
while (fileparsed) {
|
|
String filename = fileparsed.name();
|
|
#endif
|
|
String size ="";
|
|
bool addtolist=true;
|
|
//remove path from name
|
|
filename = filename.substring(path.length(),filename.length());
|
|
//check if file or subfile
|
|
if (filename.indexOf("/")>-1) {
|
|
//Do not rely on "/." to define directory as SPIFFS upload won't create it but directly files
|
|
//and no need to overload SPIFFS if not necessary to create "/." if no need
|
|
//it will reduce SPIFFS available space so limit it to creation
|
|
filename = filename.substring(0,filename.indexOf("/"));
|
|
String tag="*";
|
|
tag += filename + "*";
|
|
if (subdirlist.indexOf(tag)>-1 || filename.length()==0) { //already in list
|
|
addtolist = false; //no need to add
|
|
} else {
|
|
size = -1; //it is subfile so display only directory, size will be -1 to describe it is directory
|
|
if (subdirlist.length()==0) {
|
|
subdirlist+="*";
|
|
}
|
|
subdirlist += filename + "*"; //add to list
|
|
}
|
|
} else {
|
|
//do not add "." file
|
|
if (!((filename==".") || (filename==""))) {
|
|
#if defined ( ARDUINO_ARCH_ESP8266)
|
|
size = CONFIG::formatBytes(dir.fileSize());
|
|
#else
|
|
size = CONFIG::formatBytes(fileparsed.size());
|
|
#endif
|
|
|
|
} else {
|
|
addtolist = false;
|
|
}
|
|
}
|
|
if(addtolist) {
|
|
if (!firstentry) {
|
|
jsonfile+=",";
|
|
} else {
|
|
firstentry=false;
|
|
}
|
|
jsonfile+="{";
|
|
jsonfile+="\"name\":\"";
|
|
jsonfile+=filename;
|
|
jsonfile+="\",\"size\":\"";
|
|
jsonfile+=size;
|
|
jsonfile+="\"";
|
|
jsonfile+="}";
|
|
}
|
|
#ifdef ARDUINO_ARCH_ESP32
|
|
fileparsed = dir.openNextFile();
|
|
#endif
|
|
}
|
|
jsonfile+="],";
|
|
jsonfile+="\"path\":\"" + path + "\",";
|
|
jsonfile+="\"status\":\"" + status + "\",";
|
|
size_t totalBytes;
|
|
size_t usedBytes;
|
|
#if defined ( ARDUINO_ARCH_ESP8266)
|
|
fs::FSInfo info;
|
|
SPIFFS.info(info);
|
|
totalBytes = info.totalBytes;
|
|
usedBytes = info.usedBytes;
|
|
#else
|
|
totalBytes = SPIFFS.totalBytes();
|
|
usedBytes = SPIFFS.usedBytes();
|
|
#endif
|
|
jsonfile+="\"total\":\"" + CONFIG::formatBytes(totalBytes) + "\",";
|
|
jsonfile+="\"used\":\"" + CONFIG::formatBytes(usedBytes) + "\",";
|
|
jsonfile.concat(F("\"occupation\":\""));
|
|
jsonfile+= CONFIG::intTostr(100*usedBytes/totalBytes);
|
|
jsonfile+="\"";
|
|
jsonfile+="}";
|
|
path = "";
|
|
web_interface->web_server.sendHeader("Cache-Control", "no-cache");
|
|
web_interface->web_server.send(200, "application/json", jsonfile);
|
|
web_interface->_upload_status=UPLOAD_STATUS_NONE;
|
|
}
|
|
|
|
//SPIFFS files uploader handle
|
|
void SPIFFSFileupload()
|
|
{
|
|
static FS_FILE fsUploadFile = (FS_FILE)0;
|
|
static String filename;
|
|
//get authentication status
|
|
level_authenticate_type auth_level= web_interface->is_authenticated();
|
|
//Guest cannot upload
|
|
if (auth_level == LEVEL_GUEST) {
|
|
web_interface->_upload_status=UPLOAD_STATUS_FAILED;
|
|
ESPCOM::println (F ("Upload rejected"), PRINTER_PIPE);
|
|
pushError(ESP_ERROR_AUTHENTICATION, "Upload rejected", 401);
|
|
} else {
|
|
//get current file ID
|
|
HTTPUpload& upload = (web_interface->web_server).upload();
|
|
if ((web_interface->_upload_status != UPLOAD_STATUS_FAILED) || (upload.status == UPLOAD_FILE_START)) {
|
|
//Upload start
|
|
//**************
|
|
if(upload.status == UPLOAD_FILE_START) {
|
|
web_interface->_upload_status= UPLOAD_STATUS_ONGOING;
|
|
String upload_filename = upload.filename;
|
|
String sizeargname = upload_filename + "S";
|
|
if (upload_filename[0] != '/') filename = "/" + upload_filename;
|
|
else filename = upload.filename;
|
|
//according User or Admin the root is different as user is isolate to /user when admin has full access
|
|
if(auth_level != LEVEL_ADMIN) {
|
|
upload_filename = filename;
|
|
filename = "/user" + upload_filename;
|
|
}
|
|
|
|
if (SPIFFS.exists (filename) ) {
|
|
SPIFFS.remove (filename);
|
|
}
|
|
if (fsUploadFile ) {
|
|
fsUploadFile.close();
|
|
}
|
|
if ((web_interface->web_server).hasArg (sizeargname.c_str()) ) {
|
|
uint32_t filesize = (web_interface->web_server).arg (sizeargname.c_str()).toInt();
|
|
#if defined ( ARDUINO_ARCH_ESP8266)
|
|
fs::FSInfo info;
|
|
SPIFFS.info(info);
|
|
uint32_t freespace = info.totalBytes- info.usedBytes;
|
|
#endif
|
|
#if defined ( ARDUINO_ARCH_ESP32)
|
|
uint32_t freespace = SPIFFS.totalBytes() - SPIFFS.usedBytes();
|
|
#endif
|
|
|
|
if (filesize > freespace) {
|
|
web_interface->_upload_status=UPLOAD_STATUS_FAILED;
|
|
pushError(ESP_ERROR_NOT_ENOUGH_SPACE, "Upload rejected, not enough space");
|
|
}
|
|
}
|
|
if (web_interface->_upload_status != UPLOAD_STATUS_FAILED) {
|
|
//create file
|
|
fsUploadFile = SPIFFS.open(filename, SPIFFS_FILE_WRITE);
|
|
//check If creation succeed
|
|
if (fsUploadFile) {
|
|
//if yes upload is started
|
|
web_interface->_upload_status= UPLOAD_STATUS_ONGOING;
|
|
} else {
|
|
//if no set cancel flag
|
|
web_interface->_upload_status=UPLOAD_STATUS_FAILED;
|
|
ESPCOM::println (F ("Error ESP create"), PRINTER_PIPE);
|
|
pushError(ESP_ERROR_FILE_CREATION, "File creation failed");
|
|
}
|
|
}
|
|
//Upload write
|
|
//**************
|
|
} else if(upload.status == UPLOAD_FILE_WRITE) {
|
|
//check if file is available and no error
|
|
if(fsUploadFile && web_interface->_upload_status == UPLOAD_STATUS_ONGOING) {
|
|
//no error so write post date
|
|
if (upload.currentSize != fsUploadFile.write(upload.buf, upload.currentSize)){
|
|
web_interface->_upload_status=UPLOAD_STATUS_FAILED;
|
|
ESPCOM::println (F ("Error ESP write"), PRINTER_PIPE);
|
|
pushError(ESP_ERROR_FILE_WRITE, "File write failed");
|
|
}
|
|
} else {
|
|
//we have a problem set flag UPLOAD_STATUS_FAILED
|
|
web_interface->_upload_status=UPLOAD_STATUS_FAILED;
|
|
ESPCOM::println (F ("Error ESP write"), PRINTER_PIPE);
|
|
}
|
|
//Upload end
|
|
//**************
|
|
} else if(upload.status == UPLOAD_FILE_END) {
|
|
//check if file is still open
|
|
if(fsUploadFile) {
|
|
//close it
|
|
fsUploadFile.close();
|
|
if (web_interface->_upload_status == UPLOAD_STATUS_ONGOING) {
|
|
web_interface->_upload_status = UPLOAD_STATUS_SUCCESSFUL;
|
|
}
|
|
} else {
|
|
//we have a problem set flag UPLOAD_STATUS_FAILED
|
|
web_interface->_upload_status=UPLOAD_STATUS_FAILED;
|
|
ESPCOM::println (F ("Error ESP close"), PRINTER_PIPE);
|
|
pushError(ESP_ERROR_FILE_CLOSE, "File close failed");
|
|
}
|
|
//Upload cancelled
|
|
//**************
|
|
} else {
|
|
web_interface->_upload_status = UPLOAD_STATUS_FAILED;
|
|
return;
|
|
//ESPCOM::println (F ("Error ESP upload"), PRINTER_PIPE);
|
|
//pushError(ESP_ERROR_UPLOAD, "File upload failed");
|
|
}
|
|
}
|
|
}
|
|
if (web_interface->_upload_status == UPLOAD_STATUS_FAILED) {
|
|
cancelUpload();
|
|
if (SPIFFS.exists (filename) ) {
|
|
SPIFFS.remove (filename);
|
|
}
|
|
}
|
|
CONFIG::wait(0);
|
|
}
|
|
|
|
//FW update using Web interface/////////////////////////////////////////
|
|
#ifdef WEB_UPDATE_FEATURE
|
|
void WebUpdateUpload()
|
|
{
|
|
static size_t last_upload_update;
|
|
static uint32_t maxSketchSpace ;
|
|
//only admin can update FW
|
|
if(web_interface->is_authenticated() != LEVEL_ADMIN) {
|
|
web_interface->_upload_status=UPLOAD_STATUS_FAILED;
|
|
ESPCOM::println (F ("Update failed"), PRINTER_PIPE);
|
|
log_esp3d("Web Update failed");
|
|
pushError(ESP_ERROR_AUTHENTICATION, "Upload rejected",401);
|
|
} else {
|
|
//get current file ID
|
|
HTTPUpload& upload = (web_interface->web_server).upload();
|
|
if ((web_interface->_upload_status != UPLOAD_STATUS_FAILED) || (upload.status == UPLOAD_FILE_START)) {
|
|
//Upload start
|
|
//**************
|
|
if(upload.status == UPLOAD_FILE_START) {
|
|
ESPCOM::println (F ("Update Firmware"), PRINTER_PIPE);
|
|
web_interface->_upload_status= UPLOAD_STATUS_ONGOING;
|
|
String sizeargname = upload.filename + "S";
|
|
|
|
#if defined ( ARDUINO_ARCH_ESP8266)
|
|
WiFiUDP::stopAll();
|
|
#endif
|
|
size_t flashsize = 0;
|
|
#if defined ( ARDUINO_ARCH_ESP8266)
|
|
maxSketchSpace = (ESP.getFreeSketchSpace() - 0x1000) & 0xFFFFF000;
|
|
#else
|
|
if (esp_ota_get_running_partition()) {
|
|
const esp_partition_t* partition = esp_ota_get_next_update_partition(NULL);
|
|
if (partition) {
|
|
maxSketchSpace = partition->size;
|
|
}
|
|
}
|
|
#endif
|
|
if ((web_interface->web_server).hasArg (sizeargname.c_str()) ) {
|
|
flashsize = (web_interface->web_server).arg (sizeargname).toInt();
|
|
} else {
|
|
flashsize = maxSketchSpace;
|
|
}
|
|
if ((flashsize > maxSketchSpace) || (flashsize == 0)) {
|
|
web_interface->_upload_status=UPLOAD_STATUS_FAILED;
|
|
pushError(ESP_ERROR_NOT_ENOUGH_SPACE, "Upload rejected");
|
|
}
|
|
if (web_interface->_upload_status != UPLOAD_STATUS_FAILED) {
|
|
last_upload_update = 0;
|
|
if(!Update.begin(maxSketchSpace)) { //start with max available size
|
|
web_interface->_upload_status=UPLOAD_STATUS_FAILED;
|
|
pushError(ESP_ERROR_NOT_ENOUGH_SPACE, "Upload rejected");
|
|
} else {
|
|
if (( CONFIG::GetFirmwareTarget() == REPETIER4DV) || (CONFIG::GetFirmwareTarget() == REPETIER)) ESPCOM::println (F ("Update 0%%"), PRINTER_PIPE);
|
|
else ESPCOM::println (F ("Update 0%"), PRINTER_PIPE);
|
|
}
|
|
}
|
|
//Upload write
|
|
//**************
|
|
} else if(upload.status == UPLOAD_FILE_WRITE) {
|
|
//check if no error
|
|
if (web_interface->_upload_status == UPLOAD_STATUS_ONGOING) {
|
|
//we do not know the total file size yet but we know the available space so let's use it
|
|
if ( ((100 * upload.totalSize) / maxSketchSpace) !=last_upload_update) {
|
|
last_upload_update = (100 * upload.totalSize) / maxSketchSpace;
|
|
String s = "Update ";
|
|
s+= String(last_upload_update);
|
|
s+= "%";
|
|
if (( CONFIG::GetFirmwareTarget() == REPETIER4DV) || (CONFIG::GetFirmwareTarget() == REPETIER)) s+= "%";
|
|
ESPCOM::println (s.c_str(), PRINTER_PIPE);
|
|
}
|
|
if(Update.write(upload.buf, upload.currentSize) != upload.currentSize) {
|
|
web_interface->_upload_status=UPLOAD_STATUS_FAILED;
|
|
pushError(ESP_ERROR_FILE_WRITE, "File write failed");
|
|
}
|
|
}
|
|
//Upload end
|
|
//**************
|
|
} else if(upload.status == UPLOAD_FILE_END) {
|
|
if(Update.end(true)) { //true to set the size to the current progress
|
|
//Now Reboot
|
|
if (( CONFIG::GetFirmwareTarget() == REPETIER4DV) || (CONFIG::GetFirmwareTarget() == REPETIER)) ESPCOM::println (F("Update 100%%"), PRINTER_PIPE);
|
|
else ESPCOM::println (F("Update 100%"), PRINTER_PIPE);
|
|
web_interface->_upload_status=UPLOAD_STATUS_SUCCESSFUL;
|
|
}
|
|
} else if(upload.status == UPLOAD_FILE_ABORTED) {
|
|
ESPCOM::println (F("Update Failed"), PRINTER_PIPE);
|
|
web_interface->_upload_status=UPLOAD_STATUS_FAILED;
|
|
//pushError(ESP_ERROR_UPLOAD_CANCELLED, "Upload cancelled");
|
|
}
|
|
}
|
|
}
|
|
|
|
if (web_interface->_upload_status==UPLOAD_STATUS_FAILED) {
|
|
cancelUpload();
|
|
Update.end();
|
|
}
|
|
|
|
CONFIG::wait(0);
|
|
}
|
|
|
|
void handleUpdate()
|
|
{
|
|
level_authenticate_type auth_level = web_interface->is_authenticated();
|
|
if (auth_level != LEVEL_ADMIN) {
|
|
web_interface->_upload_status=UPLOAD_STATUS_NONE;
|
|
web_interface->web_server.send(403,"text/plain","Not allowed, log in first!\n");
|
|
return;
|
|
}
|
|
String jsonfile = "{\"status\":\"" ;
|
|
jsonfile+=CONFIG::intTostr(web_interface->_upload_status);
|
|
jsonfile+="\"}";
|
|
//send status
|
|
web_interface->web_server.sendHeader("Cache-Control", "no-cache");
|
|
web_interface->web_server.send(200, "application/json", jsonfile);
|
|
//if success restart
|
|
if (web_interface->_upload_status==UPLOAD_STATUS_SUCCESSFUL) {
|
|
CONFIG::wait(2000);
|
|
web_interface->restartmodule=true;
|
|
} else {
|
|
web_interface->_upload_status=UPLOAD_STATUS_NONE;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
//Handle not registred path on SPIFFS neither SD ///////////////////////
|
|
void handle_not_found()
|
|
{
|
|
static const char NOT_AUTH_NF [] PROGMEM = "HTTP/1.1 301 OK\r\nLocation: /\r\nCache-Control: no-cache\r\n\r\n";
|
|
|
|
if (web_interface->is_authenticated() == LEVEL_GUEST) {
|
|
web_interface->web_server.sendContent_P(NOT_AUTH_NF);
|
|
return;
|
|
}
|
|
bool page_not_found = false;
|
|
String path = web_interface->web_server.urlDecode(web_interface->web_server.uri());
|
|
String contentType = web_interface->getContentType(path);
|
|
String pathWithGz = path + ".gz";
|
|
log_esp3d("Not found %s, type %s", path.c_str(), contentType.c_str());
|
|
if(SPIFFS.exists(pathWithGz) || SPIFFS.exists(path)) {
|
|
if(SPIFFS.exists(pathWithGz)) {
|
|
path = pathWithGz;
|
|
}
|
|
FS_FILE file = SPIFFS.open(path, SPIFFS_FILE_READ);
|
|
web_interface->web_server.streamFile(file, contentType);
|
|
file.close();
|
|
return;
|
|
} else {
|
|
page_not_found = true;
|
|
}
|
|
|
|
if (page_not_found ) {
|
|
#ifdef CAPTIVE_PORTAL_FEATURE
|
|
if (WiFi.getMode()!=WIFI_STA ) {
|
|
String contentType=FPSTR(PAGE_CAPTIVE);
|
|
String stmp = WiFi.softAPIP().toString();
|
|
//Web address = ip + port
|
|
String KEY_IP = F("$WEB_ADDRESS$");
|
|
String KEY_QUERY = F("$QUERY$");
|
|
if (wifi_config.iweb_port!=80) {
|
|
stmp+=":";
|
|
stmp+=CONFIG::intTostr(wifi_config.iweb_port);
|
|
}
|
|
contentType.replace(KEY_IP,stmp);
|
|
contentType.replace(KEY_IP,stmp);
|
|
contentType.replace(KEY_QUERY,web_interface->web_server.uri());
|
|
web_interface->web_server.send(200,"text/html",contentType);
|
|
//web_interface->web_server.sendContent_P(NOT_AUTH_NF);
|
|
return;
|
|
}
|
|
#endif
|
|
log_esp3d("Page not found");
|
|
path = F("/404.htm");
|
|
contentType = web_interface->getContentType(path);
|
|
pathWithGz = path + F(".gz");
|
|
if(SPIFFS.exists(pathWithGz) || SPIFFS.exists(path)) {
|
|
if(SPIFFS.exists(pathWithGz)) {
|
|
path = pathWithGz;
|
|
}
|
|
FS_FILE file = SPIFFS.open(path, SPIFFS_FILE_READ);
|
|
web_interface->web_server.streamFile(file, contentType);
|
|
file.close();
|
|
|
|
} else {
|
|
//if not template use default page
|
|
contentType=FPSTR(PAGE_404);
|
|
String stmp;
|
|
if (WiFi.getMode()==WIFI_STA ) {
|
|
stmp=WiFi.localIP().toString();
|
|
} else {
|
|
stmp=WiFi.softAPIP().toString();
|
|
}
|
|
//Web address = ip + port
|
|
String KEY_IP = F("$WEB_ADDRESS$");
|
|
String KEY_QUERY = F("$QUERY$");
|
|
if (wifi_config.iweb_port!=80) {
|
|
stmp+=":";
|
|
stmp+=CONFIG::intTostr(wifi_config.iweb_port);
|
|
}
|
|
contentType.replace(KEY_IP,stmp);
|
|
contentType.replace(KEY_QUERY,web_interface->web_server.uri());
|
|
web_interface->web_server.send(200,"text/html",contentType);
|
|
}
|
|
}
|
|
}
|
|
|
|
//Handle web command query and send answer /////////////////////////////
|
|
void handle_web_command()
|
|
{
|
|
level_authenticate_type auth_level= web_interface->is_authenticated();
|
|
/* if (auth_level == LEVEL_GUEST) {
|
|
web_interface->web_server.send(403,"text/plain","Not allowed, log in first!\n");
|
|
return;
|
|
}*/
|
|
String buffer2send = "";
|
|
ESPResponseStream espresponse;
|
|
String cmd = "";
|
|
if (web_interface->web_server.hasArg("plain") || web_interface->web_server.hasArg("commandText")) {
|
|
if (web_interface->web_server.hasArg("plain")) {
|
|
cmd = web_interface->web_server.arg("plain");
|
|
} else {
|
|
cmd = web_interface->web_server.arg("commandText");
|
|
}
|
|
log_esp3d("WebCommand %s",cmd.c_str());
|
|
} else {
|
|
log_esp3d("Invalid arg");
|
|
web_interface->web_server.send(200,"text/plain","Invalid command");
|
|
return;
|
|
}
|
|
//if it is for ESP module [ESPXXX]<parameter>
|
|
cmd.trim();
|
|
int ESPpos = cmd.indexOf("[ESP");
|
|
if (ESPpos==0) {
|
|
//is there the second part?
|
|
int ESPpos2 = cmd.indexOf("]",ESPpos);
|
|
if (ESPpos2>-1) {
|
|
//Split in command and parameters
|
|
String cmd_part1=cmd.substring(ESPpos+4,ESPpos2);
|
|
String cmd_part2="";
|
|
//only [ESP800] is allowed login free if authentication is enabled
|
|
if ((auth_level == LEVEL_GUEST) && (cmd_part1.toInt()!=800)) {
|
|
web_interface->web_server.send(401,"text/plain","Authentication failed!\n");
|
|
return;
|
|
}
|
|
//is there space for parameters?
|
|
if ((uint)ESPpos2<cmd.length()) {
|
|
cmd_part2=cmd.substring(ESPpos2+1);
|
|
}
|
|
//if command is a valid number then execute command
|
|
if(cmd_part1.toInt()!=0) {
|
|
COMMAND::execute_command(cmd_part1.toInt(), cmd_part2, WEB_PIPE, auth_level, &espresponse);
|
|
ESPCOM::flush(WEB_PIPE, &espresponse);
|
|
}
|
|
//if not is not a valid [ESPXXX] command
|
|
}
|
|
} else {
|
|
if (auth_level == LEVEL_GUEST) {
|
|
web_interface->web_server.send(401,"text/plain","Authentication failed!\n");
|
|
return;
|
|
}
|
|
//send command to serial as no need to transfer ESP command
|
|
//to avoid any pollution if Uploading file to SDCard
|
|
if ((web_interface->blockserial) == false) {
|
|
//block every query
|
|
web_interface->blockserial = true;
|
|
log_esp3d("Block Serial");
|
|
//empty the serial buffer and incoming data
|
|
log_esp3d("Start PurgeSerial");
|
|
if(ESPCOM::available(DEFAULT_PRINTER_PIPE)) {
|
|
ESPCOM::bridge();
|
|
CONFIG::wait(1);
|
|
}
|
|
log_esp3d("End PurgeSerial");
|
|
web_interface->web_server.setContentLength(CONTENT_LENGTH_UNKNOWN);
|
|
web_interface->web_server.sendHeader("Content-Type","text/plain",true);
|
|
web_interface->web_server.sendHeader("Cache-Control","no-cache");
|
|
web_interface->web_server.send(200);
|
|
//send command
|
|
log_esp3d("Start PurgeSerial");
|
|
if(ESPCOM::available(DEFAULT_PRINTER_PIPE)) {
|
|
ESPCOM::bridge();
|
|
CONFIG::wait(1);
|
|
}
|
|
log_esp3d("End PurgeSerial");
|
|
ESPCOM::println (cmd, DEFAULT_PRINTER_PIPE);
|
|
bool done = false;
|
|
String current_buffer;
|
|
String current_line;
|
|
//int pos;
|
|
int temp_counter = 0;
|
|
String tmp;
|
|
bool datasent = false;
|
|
uint32_t timeout = millis();
|
|
//pickup the list
|
|
while ((millis() - timeout < 2000) && !done) {
|
|
//give some time between each buffer
|
|
if (ESPCOM::available(DEFAULT_PRINTER_PIPE)) {
|
|
log_esp3d("Got data");
|
|
timeout = millis();
|
|
size_t len = ESPCOM::available(DEFAULT_PRINTER_PIPE);
|
|
uint8_t sbuf[len+1];
|
|
//read buffer
|
|
ESPCOM::readBytes (DEFAULT_PRINTER_PIPE, sbuf, len);
|
|
//change buffer as string
|
|
sbuf[len]='\0';
|
|
//add buffer to current one if any
|
|
current_buffer += (char * ) sbuf;
|
|
while (current_buffer.indexOf("\n") !=-1) {
|
|
log_esp3d("Remove new line");
|
|
//remove the possible "\r"
|
|
current_buffer.replace("\r","");
|
|
//get line
|
|
current_line = current_buffer.substring(0,current_buffer.indexOf("\n"));
|
|
//if line is command ack - just exit so save the time out period
|
|
if ((current_line == "ok") || (current_line == "wait") || (current_line.startsWith("ok") && !((CONFIG::GetFirmwareTarget() == REPETIER) || (CONFIG::GetFirmwareTarget() == REPETIER4DV)))) {
|
|
done = true;
|
|
buffer2send +=current_line;
|
|
log_esp3d("Found ok/wait add New buffer %s", buffer2send.c_str());
|
|
buffer2send +="\n";
|
|
break;
|
|
}
|
|
//get the line and transmit it
|
|
//check command
|
|
if ((CONFIG::GetFirmwareTarget() == REPETIER) || (CONFIG::GetFirmwareTarget() == REPETIER4DV)) {
|
|
//save time no need to continue
|
|
if (current_line.indexOf("busy:") > -1) {
|
|
temp_counter++;
|
|
} else if (COMMAND::check_command(current_line, NO_PIPE, false)) {
|
|
temp_counter ++ ;
|
|
}
|
|
} else {
|
|
if (COMMAND::check_command(current_line, NO_PIPE, false)) {
|
|
temp_counter ++ ;
|
|
}
|
|
}
|
|
if (temp_counter > 5) {
|
|
log_esp3d("Timeout X5");
|
|
done = true;
|
|
break;
|
|
}
|
|
if ((CONFIG::GetFirmwareTarget() == REPETIER) || (CONFIG::GetFirmwareTarget() == REPETIER4DV)) {
|
|
if (!current_line.startsWith( "ok ")) {
|
|
buffer2send +=current_line;
|
|
buffer2send +="\n";
|
|
}
|
|
} else {
|
|
buffer2send +=current_line;
|
|
log_esp3d("New buffer %s", buffer2send.c_str());
|
|
buffer2send +="\n";
|
|
}
|
|
if (buffer2send.length() > 1200) {
|
|
web_interface->web_server.sendContent(buffer2send);
|
|
log_esp3d("Sending %s", buffer2send.c_str());
|
|
buffer2send = "";
|
|
datasent = true;
|
|
}
|
|
//current remove line from buffer
|
|
tmp = current_buffer.substring(current_buffer.indexOf("\n")+1,current_buffer.length());
|
|
current_buffer = tmp;
|
|
CONFIG::wait (0);
|
|
}
|
|
CONFIG::wait (0);
|
|
} else {
|
|
CONFIG::wait(1);
|
|
}
|
|
//it is sending too many temp status should be heating so let's exit the loop
|
|
if (temp_counter > 5) {
|
|
done = true;
|
|
}
|
|
}
|
|
log_esp3d("Finished");
|
|
//to be sure connection close
|
|
if (buffer2send.length() > 0) {
|
|
web_interface->web_server.sendContent(buffer2send);
|
|
log_esp3d("Sending %s", buffer2send.c_str());
|
|
datasent = true;
|
|
}
|
|
if (!datasent) {
|
|
web_interface->web_server.sendContent(" \r\n");
|
|
}
|
|
web_interface->web_server.sendContent("");
|
|
log_esp3d("Start PurgeSerial");
|
|
if(ESPCOM::available(DEFAULT_PRINTER_PIPE)) {
|
|
ESPCOM::bridge();
|
|
CONFIG::wait(1);
|
|
}
|
|
log_esp3d("End PurgeSerial");
|
|
web_interface->blockserial = false;
|
|
log_esp3d("Release PurgeSerial");
|
|
} else {
|
|
web_interface->web_server.send(200,"text/plain","Serial is busy, retry later!");
|
|
}
|
|
}
|
|
}
|
|
|
|
//Handle web command query and sent ack or fail instead of answer //////
|
|
void handle_web_command_silent()
|
|
{
|
|
level_authenticate_type auth_level= web_interface->is_authenticated();
|
|
if (auth_level == LEVEL_GUEST) {
|
|
web_interface->web_server.send(401,"text/plain","Authentication failed!\n");
|
|
return;
|
|
}
|
|
String buffer2send = "";
|
|
String cmd = "";
|
|
//int count ;
|
|
if (web_interface->web_server.hasArg("plain") || web_interface->web_server.hasArg("commandText")) {
|
|
if (web_interface->web_server.hasArg("plain")) {
|
|
cmd = web_interface->web_server.arg("plain");
|
|
} else {
|
|
cmd = web_interface->web_server.arg("commandText");
|
|
}
|
|
log_esp3d("Web Command:%s", cmd.c_str());
|
|
} else {
|
|
log_esp3d("Invalid argument");
|
|
web_interface->web_server.send(200,"text/plain","Invalid command");
|
|
return;
|
|
}
|
|
//if it is for ESP module [ESPXXX]<parameter>
|
|
cmd.trim();
|
|
int ESPpos = cmd.indexOf("[ESP");
|
|
if (ESPpos==0) {
|
|
//is there the second part?
|
|
int ESPpos2 = cmd.indexOf("]",ESPpos);
|
|
if (ESPpos2>-1) {
|
|
//Split in command and parameters
|
|
String cmd_part1=cmd.substring(ESPpos+4,ESPpos2);
|
|
String cmd_part2="";
|
|
//is there space for parameters?
|
|
if ((uint)ESPpos2<cmd.length()) {
|
|
cmd_part2=cmd.substring(ESPpos2+1);
|
|
}
|
|
//if command is a valid number then execute command
|
|
if(cmd_part1.toInt()!=0) {
|
|
if (COMMAND::execute_command(cmd_part1.toInt(),cmd_part2,NO_PIPE, auth_level)) {
|
|
web_interface->web_server.send(200,"text/plain","ok");
|
|
} else {
|
|
web_interface->web_server.send(500,"text/plain","error");
|
|
}
|
|
|
|
}
|
|
//if not is not a valid [ESPXXX] command
|
|
}
|
|
} else {
|
|
//send command to serial as no need to transfer ESP command
|
|
//to avoid any pollution if Uploading file to SDCard
|
|
if ((web_interface->blockserial) == false) {
|
|
//send command
|
|
ESPCOM::println (cmd, DEFAULT_PRINTER_PIPE);
|
|
web_interface->web_server.send(200,"text/plain","ok");
|
|
} else {
|
|
web_interface->web_server.send(200,"text/plain","Serial is busy, retry later!");
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
//Serial SD files list//////////////////////////////////////////////////
|
|
void handle_serial_SDFileList()
|
|
{
|
|
#ifndef USE_AS_UPDATER_ONLY
|
|
//this is only for admin an user
|
|
if (web_interface->is_authenticated() == LEVEL_GUEST) {
|
|
web_interface->_upload_status=UPLOAD_STATUS_NONE;
|
|
web_interface->web_server.sendHeader("Cache-Control", "no-cache");
|
|
web_interface->web_server.send(401, "application/json", "{\"status\":\"Authentication failed!\"}");
|
|
return;
|
|
}
|
|
|
|
log_esp3d("Serial SD upload done");
|
|
String sstatus="Ok";
|
|
if ((web_interface->_upload_status == UPLOAD_STATUS_FAILED) || (web_interface->_upload_status == UPLOAD_STATUS_FAILED)) {
|
|
sstatus = "Upload failed";
|
|
web_interface->_upload_status = UPLOAD_STATUS_NONE;
|
|
}
|
|
String jsonfile = "{\"status\":\"" + sstatus + "\"}";
|
|
web_interface->web_server.sendHeader("Cache-Control", "no-cache");
|
|
web_interface->web_server.send(200, "application/json", jsonfile);
|
|
web_interface->blockserial = false;
|
|
web_interface->_upload_status=UPLOAD_STATUS_NONE;
|
|
#endif //USE_AS_UPDATER_ONLY
|
|
}
|
|
|
|
#define NB_RETRY 5
|
|
#define MAX_RESEND_BUFFER 228
|
|
#define SERIAL_CHECK_TIMEOUT 2000
|
|
//SD file upload by serial
|
|
void SDFile_serial_upload()
|
|
{
|
|
#ifndef USE_AS_UPDATER_ONLY
|
|
static int32_t lineNb =-1;
|
|
static String current_line;
|
|
static bool is_comment = false;
|
|
static String current_filename;
|
|
String response;
|
|
//Guest cannot upload - only admin and user
|
|
if(web_interface->is_authenticated() == LEVEL_GUEST) {
|
|
web_interface->_upload_status=UPLOAD_STATUS_FAILED;
|
|
ESPCOM::println (F ("SD upload rejected"), PRINTER_PIPE);
|
|
pushError(ESP_ERROR_AUTHENTICATION, "Upload rejected", 401);
|
|
log_esp3d("SD upload rejected");
|
|
} else {
|
|
//retrieve current file id
|
|
HTTPUpload& upload = (web_interface->web_server).upload();
|
|
if((web_interface->_upload_status != UPLOAD_STATUS_FAILED) || (upload.status == UPLOAD_FILE_START)) {
|
|
//Upload start
|
|
//**************
|
|
if(upload.status == UPLOAD_FILE_START) {
|
|
web_interface->_upload_status= UPLOAD_STATUS_ONGOING;
|
|
log_esp3d("Upload start");
|
|
String command = "M29";
|
|
String resetcmd = "M110 N0";
|
|
if (CONFIG::GetFirmwareTarget() == SMOOTHIEWARE)resetcmd = "N0 M110";
|
|
lineNb=1;
|
|
//close any ongoing upload and get current line number
|
|
if(!sendLine2Serial (command,-1, &lineNb)){
|
|
//it can failed for repetier
|
|
if ( ( CONFIG::GetFirmwareTarget() == REPETIER4DV) || (CONFIG::GetFirmwareTarget() == REPETIER) ) {
|
|
if(!sendLine2Serial (command,1, NULL)){
|
|
log_esp3d("Upload start failed");
|
|
web_interface->_upload_status= UPLOAD_STATUS_FAILED;
|
|
pushError(ESP_ERROR_START_UPLOAD, "Upload rejected");
|
|
}
|
|
} else {
|
|
log_esp3d("Upload start failed");
|
|
web_interface->_upload_status= UPLOAD_STATUS_FAILED;
|
|
pushError(ESP_ERROR_START_UPLOAD, "Upload rejected");
|
|
}
|
|
} else {
|
|
//Mount SD card
|
|
command = "M21";
|
|
if(!sendLine2Serial (command,-1, NULL)){
|
|
log_esp3d("Mounting SD failed");
|
|
web_interface->_upload_status= UPLOAD_STATUS_FAILED;
|
|
pushError(ESP_ERROR_MOUNT_SD, "Mounting SD failed");
|
|
}
|
|
if (web_interface->_upload_status != UPLOAD_STATUS_FAILED) {
|
|
//Reset line numbering
|
|
if(!sendLine2Serial (resetcmd,-1, NULL)){
|
|
log_esp3d("Reset Numbering failed");
|
|
web_interface->_upload_status= UPLOAD_STATUS_FAILED;
|
|
pushError(ESP_ERROR_RESET_NUMBERING, "Reset Numbering failed");
|
|
}
|
|
}
|
|
if (web_interface->_upload_status != UPLOAD_STATUS_FAILED) {
|
|
lineNb=1;
|
|
//need to lock serial out to avoid garbage in file
|
|
(web_interface->blockserial) = true;
|
|
current_line ="";
|
|
current_filename = upload.filename;
|
|
is_comment = false;
|
|
String response;
|
|
ESPCOM::println (F ("Uploading..."), PRINTER_PIPE);
|
|
//Clear all serial
|
|
ESPCOM::flush (DEFAULT_PRINTER_PIPE);
|
|
purge_serial();
|
|
//besure nothing left again
|
|
purge_serial();
|
|
command = "M28 " + upload.filename;
|
|
//send start upload
|
|
//no correction allowed because it means reset numbering was failed
|
|
if (sendLine2Serial(command, lineNb, NULL)){
|
|
CONFIG::wait(1200);
|
|
//additional purge, in case it is slow to answer
|
|
purge_serial();
|
|
web_interface->_upload_status= UPLOAD_STATUS_ONGOING;
|
|
log_esp3d("Creation Ok");
|
|
|
|
} else {
|
|
web_interface->_upload_status= UPLOAD_STATUS_FAILED;
|
|
log_esp3d("Creation failed");
|
|
pushError(ESP_ERROR_FILE_CREATION, "File creation failed");
|
|
}
|
|
}
|
|
}
|
|
//Upload write
|
|
//**************
|
|
//upload is on going with data coming by 2K blocks
|
|
} else if(upload.status == UPLOAD_FILE_WRITE) { //if com error no need to send more data to serial
|
|
for (uint pos = 0;( pos < upload.currentSize) && (web_interface->_upload_status == UPLOAD_STATUS_ONGOING); pos++) { //parse full post data
|
|
//feed watchdog
|
|
CONFIG::wait(0);
|
|
//it is a comment
|
|
if (upload.buf[pos] == ';') {
|
|
log_esp3d("Comment found");
|
|
is_comment = true;
|
|
}
|
|
//it is an end line
|
|
else if ( (upload.buf[pos] == 13) || (upload.buf[pos] == 10) ) {
|
|
//if comment line then reset
|
|
is_comment = false;
|
|
//does line fit the buffer ?
|
|
if (current_line.length() < MAX_RESEND_BUFFER) {
|
|
//do we have something in buffer ?
|
|
if (current_line.length() > 0 ) {
|
|
lineNb++;
|
|
if (!sendLine2Serial (current_line, lineNb, NULL) ) {
|
|
log_esp3d("Error sending line");
|
|
CloseSerialUpload (true, current_filename,lineNb);
|
|
web_interface->_upload_status= UPLOAD_STATUS_FAILED;
|
|
pushError(ESP_ERROR_FILE_WRITE, "File write failed");
|
|
}
|
|
//reset line
|
|
current_line = "";
|
|
|
|
} else {
|
|
log_esp3d ("Empy line");
|
|
}
|
|
} else {
|
|
//error buffer overload
|
|
log_esp3d ("Error over buffer(1)");
|
|
lineNb++;
|
|
web_interface->_upload_status= UPLOAD_STATUS_FAILED;
|
|
pushError(ESP_ERROR_BUFFER_OVERFLOW, "Error buffer overflow");
|
|
}
|
|
} else if (!is_comment) {
|
|
if (current_line.length() < MAX_RESEND_BUFFER) {
|
|
current_line += char (upload.buf[pos]); //copy current char to buffer to send/resend
|
|
} else {
|
|
log_esp3d ("Error over buffer(2)");
|
|
lineNb++;
|
|
web_interface->_upload_status= UPLOAD_STATUS_FAILED;
|
|
pushError(ESP_ERROR_BUFFER_OVERFLOW, "Error buffer overflow");
|
|
}
|
|
}
|
|
}
|
|
//Upload end
|
|
//**************
|
|
} else if(upload.status == UPLOAD_FILE_END && web_interface->_upload_status == UPLOAD_STATUS_ONGOING) {
|
|
//if last part does not have '\n'
|
|
if (current_line.length() > 0) {
|
|
lineNb++;
|
|
if (!sendLine2Serial (current_line, lineNb, NULL) ) {
|
|
log_esp3d ("Error sending buffer");
|
|
lineNb++;
|
|
CloseSerialUpload (true, current_filename, lineNb);
|
|
web_interface->_upload_status= UPLOAD_STATUS_FAILED;
|
|
pushError(ESP_ERROR_FILE_WRITE, "File write failed");
|
|
}
|
|
}
|
|
log_esp3d ("Upload finished");
|
|
lineNb++;
|
|
CloseSerialUpload (false, current_filename, lineNb);
|
|
//Upload cancelled
|
|
//**************
|
|
} else { //UPLOAD_FILE_ABORTED
|
|
log_esp3d("Error, Something happened");
|
|
web_interface->_upload_status= UPLOAD_STATUS_FAILED;
|
|
//pushError(ESP_ERROR_UPLOAD_CANCELLED, "Upload cancelled");
|
|
}
|
|
}
|
|
}
|
|
|
|
if (web_interface->_upload_status == UPLOAD_STATUS_FAILED) {
|
|
ESPCOM::println (F ("Upload failed"), PRINTER_PIPE);
|
|
lineNb++;
|
|
CloseSerialUpload (true, current_filename, lineNb);
|
|
cancelUpload();
|
|
}
|
|
#endif //USE_AS_UPDATER_ONLY
|
|
}
|
|
|
|
#endif
|