Refactor OTA update process and clean up code

code/components/jomjol_fileserver_ota/server_file.cpp

@@ -15,17 +15,13 @@
 #include <sys/unistd.h>
 #include <sys/stat.h>
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-#include <dirent.h>
-#ifdef __cplusplus
-}
-#endif
-
 #include "esp_err.h"
 #include "esp_log.h"
 
+#include <iostream>
+#include <sys/types.h>
+#include <dirent.h>
+
 #include "esp_vfs.h"
 #include <esp_spiffs.h>
 #include "esp_http_server.h"
@@ -38,17 +34,17 @@ extern "C" {
 #include "server_help.h"
 #include "md5.h"
 #ifdef ENABLE_MQTT
-    #include "interface_mqtt.h"
-#endif //ENABLE_MQTT
+#include "interface_mqtt.h"
+#endif // ENABLE_MQTT
 #include "server_GPIO.h"
 
 #include "Helper.h"
-#include "miniz.h"
 #include "basic_auth.h"
 
 static const char *TAG = "OTA FILE";
 
-struct file_server_data {
+struct file_server_data
+{
     /* Base path of file storage */
     char base_path[ESP_VFS_PATH_MAX + 1];
 
@@ -56,14 +52,6 @@ struct file_server_data {
     char scratch[SERVER_FILER_SCRATCH_BUFSIZE];
 };
 
-#include <iostream>
-#include <sys/types.h>
-#include <dirent.h>
-
-using namespace std;
-
-string SUFFIX_ZW = "_tmp";
-
 static esp_err_t send_logfile(httpd_req_t *req, bool send_full_file);
 static esp_err_t send_datafile(httpd_req_t *req, bool send_full_file);
 
@@ -71,7 +59,7 @@ esp_err_t get_numbers_file_handler(httpd_req_t *req)
 {
     std::string ret = flowctrl.getNumbersName();
 
-//    ESP_LOGI(TAG, "Result get_numbers_file_handler: %s", ret.c_str());
+    //    ESP_LOGI(TAG, "Result get_numbers_file_handler: %s", ret.c_str());
 
     httpd_resp_set_hdr(req, "Access-Control-Allow-Origin", "*");
     httpd_resp_set_type(req, "text/plain");
@@ -88,7 +76,7 @@ esp_err_t get_data_file_handler(httpd_req_t *req)
 
     std::string _filename, _fileext;
     size_t pos = 0;
-    
+
     const char verz_name[] = "/sdcard/log/data";
     ESP_LOGD(TAG, "Suche data files in /sdcard/log/data");
 
@@ -96,13 +84,14 @@ esp_err_t get_data_file_handler(httpd_req_t *req)
     httpd_resp_set_type(req, "text/plain");
 
     DIR *dir = opendir(verz_name);
-    while ((entry = readdir(dir)) != NULL) 
+    while ((entry = readdir(dir)) != NULL)
     {
         _filename = std::string(entry->d_name);
         ESP_LOGD(TAG, "File: %s", _filename.c_str());
 
         // ignore all files with starting dot (hidden files)
-        if (_filename.rfind(".", 0) == 0) {
+        if (_filename.rfind(".", 0) == 0)
+        {
             continue;
         }
 
@@ -131,7 +120,7 @@ esp_err_t get_tflite_file_handler(httpd_req_t *req)
 
     std::string _filename, _fileext;
     size_t pos = 0;
-    
+
     const char verz_name[] = "/sdcard/config";
     ESP_LOGD(TAG, "Suche TFLITE in /sdcard/config/");
 
@@ -139,13 +128,14 @@ esp_err_t get_tflite_file_handler(httpd_req_t *req)
     httpd_resp_set_type(req, "text/plain");
 
     DIR *dir = opendir(verz_name);
-    while ((entry = readdir(dir)) != NULL) 
+    while ((entry = readdir(dir)) != NULL)
     {
         _filename = std::string(entry->d_name);
         ESP_LOGD(TAG, "File: %s", _filename.c_str());
 
         // ignore all files with starting dot (hidden files)
-        if (_filename.rfind(".", 0) == 0) {
+        if (_filename.rfind(".", 0) == 0)
+        {
             continue;
         }
 
@@ -186,7 +176,8 @@ static esp_err_t http_resp_dir_html(httpd_req_t *req, const char *dirpath, const
 
     file_server_data *server_data = (file_server_data *)req->user_ctx;
 
-    if ((strlen(dirpath_corrected) - 1) > strlen(server_data->base_path)) {
+    if ((strlen(dirpath_corrected) - 1) > strlen(server_data->base_path))
+    {
         // if dirpath is not mountpoint, the last "\" needs to be removed
         dirpath_corrected[strlen(dirpath_corrected) - 1] = '\0';
     }
@@ -200,7 +191,8 @@ static esp_err_t http_resp_dir_html(httpd_req_t *req, const char *dirpath, const
     strlcpy(entrypath, dirpath, sizeof(entrypath));
     ESP_LOGD(TAG, "entrypath: <%s>", entrypath);
 
-    if (!pdir) {
+    if (!pdir)
+    {
         LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Failed to stat dir: " + std::string(dirpath) + "!");
         // Respond with 404 Not Found
         httpd_resp_send_err(req, HTTPD_404_NOT_FOUND, get404());
@@ -244,7 +236,8 @@ static esp_err_t http_resp_dir_html(httpd_req_t *req, const char *dirpath, const
                                   "<col width=\"800px\"><col width=\"300px\"><col width=\"300px\"><col width=\"100px\">"
                                   "<thead><tr><th>Name</th><th>Type</th><th>Size</th>");
 
-    if (!readonly) {
+    if (!readonly)
+    {
         httpd_resp_sendstr_chunk(req, "<th><form method=\"post\" action=\"");
         httpd_resp_sendstr_chunk(req, _zw.c_str());
         httpd_resp_sendstr_chunk(req, "\"><button type=\"submit\">DELETE ALL!</button></form></th></tr>");
@@ -253,27 +246,34 @@ static esp_err_t http_resp_dir_html(httpd_req_t *req, const char *dirpath, const
     httpd_resp_sendstr_chunk(req, "</thead><tbody>\n");
 
     // Iterate over all files / folders and fetch their names and sizes
-    while ((entry = readdir(pdir)) != NULL) {
+    while ((entry = readdir(pdir)) != NULL)
+    {
         // wlan.ini soll nicht angezeigt werden!
-        if (strcmp("wlan.ini", entry->d_name) != 0) {
+        if (strcmp("wlan.ini", entry->d_name) != 0)
+        {
             entrytype = (entry->d_type == DT_DIR ? "directory" : "file");
 
             strlcpy(entrypath + dirpath_len, entry->d_name, sizeof(entrypath) - dirpath_len);
             ESP_LOGD(TAG, "Entrypath: %s", entrypath);
 
-            if (stat(entrypath, &entry_stat) == -1) {
+            if (stat(entrypath, &entry_stat) == -1)
+            {
                 LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Failed to stat " + std::string(entrytype) + ": " + std::string(entry->d_name));
                 continue;
             }
 
-            if (entry->d_type == DT_DIR) {
+            if (entry->d_type == DT_DIR)
+            {
                 strcpy(entrysize, "-\0");
             }
-            else {
-                if (entry_stat.st_size >= 1024) {
+            else
+            {
+                if (entry_stat.st_size >= 1024)
+                {
                     sprintf(entrysize, "%ld KiB", entry_stat.st_size / 1024); // kBytes
                 }
-                else {
+                else
+                {
                     sprintf(entrysize, "%ld B", entry_stat.st_size); // Bytes
                 }
             }
@@ -286,7 +286,8 @@ static esp_err_t http_resp_dir_html(httpd_req_t *req, const char *dirpath, const
             httpd_resp_sendstr_chunk(req, uripath);
             httpd_resp_sendstr_chunk(req, entry->d_name);
 
-            if (entry->d_type == DT_DIR) {
+            if (entry->d_type == DT_DIR)
+            {
                 httpd_resp_sendstr_chunk(req, "/");
             }
 
@@ -297,7 +298,8 @@ static esp_err_t http_resp_dir_html(httpd_req_t *req, const char *dirpath, const
             httpd_resp_sendstr_chunk(req, "</td><td>");
             httpd_resp_sendstr_chunk(req, entrysize);
 
-            if (!readonly) {
+            if (!readonly)
+            {
                 httpd_resp_sendstr_chunk(req, "</td><td>");
                 httpd_resp_sendstr_chunk(req, "<form method=\"post\" action=\"/delete");
                 httpd_resp_sendstr_chunk(req, uripath);
@@ -322,19 +324,23 @@ static esp_err_t http_resp_dir_html(httpd_req_t *req, const char *dirpath, const
     return ESP_OK;
 }
 
-static esp_err_t logfileact_get_full_handler(httpd_req_t *req) {
+static esp_err_t logfileact_get_full_handler(httpd_req_t *req)
+{
     return send_logfile(req, true);
 }
 
-static esp_err_t logfileact_get_last_part_handler(httpd_req_t *req) {
+static esp_err_t logfileact_get_last_part_handler(httpd_req_t *req)
+{
     return send_logfile(req, false);
 }
 
-static esp_err_t datafileact_get_full_handler(httpd_req_t *req) {
+static esp_err_t datafileact_get_full_handler(httpd_req_t *req)
+{
     return send_datafile(req, true);
 }
 
-static esp_err_t datafileact_get_last_part_handler(httpd_req_t *req) {
+static esp_err_t datafileact_get_last_part_handler(httpd_req_t *req)
+{
     return send_datafile(req, false);
 }
 
@@ -342,7 +348,7 @@ static esp_err_t send_datafile(httpd_req_t *req, bool send_full_file)
 {
     LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "data_get_last_part_handler");
     FILE *fd = NULL;
-    //struct stat file_stat;
+    // struct stat file_stat;
     ESP_LOGD(TAG, "uri: %s", req->uri);
 
     std::string currentfilename = LogFile.GetCurrentFileNameData();
@@ -350,7 +356,8 @@ static esp_err_t send_datafile(httpd_req_t *req, bool send_full_file)
     ESP_LOGD(TAG, "uri: %s, filename: %s, filepath: %s", req->uri, currentfilename.c_str(), currentfilename.c_str());
 
     fd = fopen(currentfilename.c_str(), "r");
-    if (!fd) {
+    if (!fd)
+    {
         LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Failed to read file: " + currentfilename + "!");
         /* Respond with 404 Error */
         httpd_resp_send_err(req, HTTPD_404_NOT_FOUND, get404());
@@ -359,30 +366,36 @@ static esp_err_t send_datafile(httpd_req_t *req, bool send_full_file)
 
     httpd_resp_set_hdr(req, "Access-Control-Allow-Origin", "*");
 
-//    ESP_LOGI(TAG, "Sending file: %s (%ld bytes)...", &filename, file_stat.st_size);
+    //    ESP_LOGI(TAG, "Sending file: %s (%ld bytes)...", &filename, file_stat.st_size);
     set_content_type_from_file(req, currentfilename.c_str());
 
-    if (!send_full_file) { // Send only last part of file
+    if (!send_full_file)
+    { // Send only last part of file
         ESP_LOGD(TAG, "Sending last %d bytes of the actual datafile!", LOGFILE_LAST_PART_BYTES);
 
         /* Adapted from https://www.geeksforgeeks.org/implement-your-own-tail-read-last-n-lines-of-a-huge-file/ */
-        if (fseek(fd, 0, SEEK_END)) {
+        if (fseek(fd, 0, SEEK_END))
+        {
             LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Failed to get to end of file!");
             return ESP_FAIL;
         }
-        else {
+        else
+        {
             long pos = ftell(fd); // Number of bytes in the file
             ESP_LOGI(TAG, "File contains %ld bytes", pos);
 
-            if (fseek(fd, pos - std::min((long)LOGFILE_LAST_PART_BYTES, pos), SEEK_SET)) { // Go LOGFILE_LAST_PART_BYTES bytes back from EOF
+            if (fseek(fd, pos - std::min((long)LOGFILE_LAST_PART_BYTES, pos), SEEK_SET))
+            { // Go LOGFILE_LAST_PART_BYTES bytes back from EOF
                 LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Failed to go back " + to_string(std::min((long)LOGFILE_LAST_PART_BYTES, pos)) + " bytes within the file!");
                 return ESP_FAIL;
             }
         }
 
         /* Find end of line */
-        while (1) {
-            if (fgetc(fd) == '\n') {
+        while (1)
+        {
+            if (fgetc(fd) == '\n')
+            {
                 break;
             }
         }
@@ -391,12 +404,14 @@ static esp_err_t send_datafile(httpd_req_t *req, bool send_full_file)
     /* Retrieve the pointer to scratch buffer for temporary storage */
     char *chunk = ((struct file_server_data *)req->user_ctx)->scratch;
     size_t chunksize;
-    do {
+    do
+    {
         /* Read file in chunks into the scratch buffer */
         chunksize = fread(chunk, 1, SERVER_FILER_SCRATCH_BUFSIZE, fd);
 
         /* Send the buffer contents as HTTP response chunk */
-        if (httpd_resp_send_chunk(req, chunk, chunksize) != ESP_OK) {
+        if (httpd_resp_send_chunk(req, chunk, chunksize) != ESP_OK)
+        {
             fclose(fd);
             LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "File sending failed!");
             /* Abort sending file */
@@ -422,10 +437,10 @@ static esp_err_t send_logfile(httpd_req_t *req, bool send_full_file)
 {
     LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "log_get_last_part_handler");
     FILE *fd = NULL;
-    //struct stat file_stat;
+    // struct stat file_stat;
     ESP_LOGI(TAG, "uri: %s", req->uri);
 
-    const char* filename = ""; 
+    const char *filename = "";
 
     std::string currentfilename = LogFile.GetCurrentFileName();
 
@@ -435,7 +450,8 @@ static esp_err_t send_logfile(httpd_req_t *req, bool send_full_file)
     LogFile.CloseLogFileAppendHandle();
 
     fd = fopen(currentfilename.c_str(), "r");
-    if (!fd) {
+    if (!fd)
+    {
         LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Failed to read file: " + currentfilename + "!");
         /* Respond with 404 Error */
         httpd_resp_send_err(req, HTTPD_404_NOT_FOUND, get404());
@@ -444,30 +460,36 @@ static esp_err_t send_logfile(httpd_req_t *req, bool send_full_file)
 
     httpd_resp_set_hdr(req, "Access-Control-Allow-Origin", "*");
 
-//    ESP_LOGI(TAG, "Sending file: %s (%ld bytes)...", &filename, file_stat.st_size);
+    //    ESP_LOGI(TAG, "Sending file: %s (%ld bytes)...", &filename, file_stat.st_size);
     set_content_type_from_file(req, filename);
 
-    if (!send_full_file) { // Send only last part of file
+    if (!send_full_file)
+    { // Send only last part of file
         ESP_LOGD(TAG, "Sending last %d bytes of the actual logfile!", LOGFILE_LAST_PART_BYTES);
 
         /* Adapted from https://www.geeksforgeeks.org/implement-your-own-tail-read-last-n-lines-of-a-huge-file/ */
-        if (fseek(fd, 0, SEEK_END)) {
+        if (fseek(fd, 0, SEEK_END))
+        {
             LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Failed to get to end of file!");
             return ESP_FAIL;
         }
-        else {
+        else
+        {
             long pos = ftell(fd); // Number of bytes in the file
             ESP_LOGI(TAG, "File contains %ld bytes", pos);
 
-            if (fseek(fd, pos - std::min((long)LOGFILE_LAST_PART_BYTES, pos), SEEK_SET)) { // Go LOGFILE_LAST_PART_BYTES bytes back from EOF
+            if (fseek(fd, pos - std::min((long)LOGFILE_LAST_PART_BYTES, pos), SEEK_SET))
+            { // Go LOGFILE_LAST_PART_BYTES bytes back from EOF
                 LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Failed to go back " + to_string(std::min((long)LOGFILE_LAST_PART_BYTES, pos)) + " bytes within the file!");
                 return ESP_FAIL;
             }
         }
 
         /* Find end of line */
-        while (1) {
-            if (fgetc(fd) == '\n') {
+        while (1)
+        {
+            if (fgetc(fd) == '\n')
+            {
                 break;
             }
         }
@@ -476,12 +498,14 @@ static esp_err_t send_logfile(httpd_req_t *req, bool send_full_file)
     /* Retrieve the pointer to scratch buffer for temporary storage */
     char *chunk = ((struct file_server_data *)req->user_ctx)->scratch;
     size_t chunksize;
-    do {
+    do
+    {
         /* Read file in chunks into the scratch buffer */
         chunksize = fread(chunk, 1, SERVER_FILER_SCRATCH_BUFSIZE, fd);
 
         /* Send the buffer contents as HTTP response chunk */
-        if (httpd_resp_send_chunk(req, chunk, chunksize) != ESP_OK) {
+        if (httpd_resp_send_chunk(req, chunk, chunksize) != ESP_OK)
+        {
             fclose(fd);
             LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "File sending failed!");
             /* Abort sending file */
@@ -513,14 +537,15 @@ static esp_err_t download_get_handler(httpd_req_t *req)
     ESP_LOGD(TAG, "uri: %s", req->uri);
 
     const char *filename = get_path_from_uri(filepath, ((struct file_server_data *)req->user_ctx)->base_path,
-                                             req->uri  + sizeof("/fileserver") - 1, sizeof(filepath));    
+                                             req->uri + sizeof("/fileserver") - 1, sizeof(filepath));
 
     ESP_LOGD(TAG, "uri: %s, filename: %s, filepath: %s", req->uri, filename, filepath);
 
-//    filename = get_path_from_uri(filepath, ((struct file_server_data *)req->user_ctx)->base_path,
-//                                             req->uri, sizeof(filepath));
+    //    filename = get_path_from_uri(filepath, ((struct file_server_data *)req->user_ctx)->base_path,
+    //                                             req->uri, sizeof(filepath));
 
-    if (!filename) {
+    if (!filename)
+    {
         LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Filename is too long");
         /* Respond with 414 Error */
         httpd_resp_send_err(req, HTTPD_414_URI_TOO_LONG, "Filename too long");
@@ -528,18 +553,22 @@ static esp_err_t download_get_handler(httpd_req_t *req)
     }
 
     /* If name has trailing '/', respond with directory contents */
-    if (filename[strlen(filename) - 1] == '/') {
+    if (filename[strlen(filename) - 1] == '/')
+    {
         bool readonly = false;
         size_t buf_len = httpd_req_get_url_query_len(req) + 1;
-        if (buf_len > 1) {
+        if (buf_len > 1)
+        {
             char buf[buf_len];
-            if (httpd_req_get_url_query_str(req, buf, buf_len) == ESP_OK) {
+            if (httpd_req_get_url_query_str(req, buf, buf_len) == ESP_OK)
+            {
                 ESP_LOGI(TAG, "Found URL query => %s", buf);
                 char param[32];
                 /* Get value of expected key from query string */
-                if (httpd_query_key_value(buf, "readonly", param, sizeof(param)) == ESP_OK) {
+                if (httpd_query_key_value(buf, "readonly", param, sizeof(param)) == ESP_OK)
+                {
                     ESP_LOGI(TAG, "Found URL query parameter => readonly=%s", param);
-                    readonly = (strcmp(param,"true") == 0);
+                    readonly = (strcmp(param, "true") == 0);
                 }
             }
         }
@@ -550,7 +579,8 @@ static esp_err_t download_get_handler(httpd_req_t *req)
 
     std::string testwlan = toUpper(std::string(filename));
 
-    if ((stat(filepath, &file_stat) == -1) || (testwlan.compare("/WLAN.INI") == 0 )) {  // wlan.ini soll nicht angezeigt werden!
+    if ((stat(filepath, &file_stat) == -1) || (testwlan.compare("/WLAN.INI") == 0))
+    { // wlan.ini soll nicht angezeigt werden!
 
         /* If file not present on SPIFFS check if URI
          * corresponds to one of the hardcoded paths */
@@ -561,7 +591,8 @@ static esp_err_t download_get_handler(httpd_req_t *req)
     }
 
     fd = fopen(filepath, "r");
-    if (!fd) {
+    if (!fd)
+    {
         LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Failed to read file: " + std::string(filepath) + "!");
         /* Respond with 404 Error */
         httpd_resp_send_err(req, HTTPD_404_NOT_FOUND, get404());
@@ -576,14 +607,16 @@ static esp_err_t download_get_handler(httpd_req_t *req)
     /* Retrieve the pointer to scratch buffer for temporary storage */
     char *chunk = ((struct file_server_data *)req->user_ctx)->scratch;
     size_t chunksize;
-    do {
+    do
+    {
         /* Read file in chunks into the scratch buffer */
         chunksize = fread(chunk, 1, SERVER_FILER_SCRATCH_BUFSIZE, fd);
 
         /* Send buffer contents as HTTP chunk. If empty this functions as a
          * last-chunk message, signaling end-of-response, to the HTTP client.
          * See RFC 2616, section 3.6.1 for details on Chunked Transfer Encoding. */
-        if (httpd_resp_send_chunk(req, chunk, chunksize) != ESP_OK) {
+        if (httpd_resp_send_chunk(req, chunk, chunksize) != ESP_OK)
+        {
             fclose(fd);
             LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "File sending failed!");
             /* Abort sending file */
@@ -619,21 +652,24 @@ static esp_err_t upload_post_handler(httpd_req_t *req)
     /* Note sizeof() counts NULL termination hence the -1 */
     const char *filename = get_path_from_uri(filepath, ((struct file_server_data *)req->user_ctx)->base_path,
                                              req->uri + sizeof("/upload") - 1, sizeof(filepath));
-    if (!filename) {
+    if (!filename)
+    {
         /* Respond with 413 Error */
         httpd_resp_send_err(req, HTTPD_414_URI_TOO_LONG, "Filename too long");
         return ESP_FAIL;
     }
 
     /* Filename cannot have a trailing '/' */
-    if (filename[strlen(filename) - 1] == '/') {
+    if (filename[strlen(filename) - 1] == '/')
+    {
         LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Invalid filename: " + string(filename));
         /* Respond with 400 Bad Request */
         httpd_resp_send_err(req, HTTPD_400_BAD_REQUEST, "Invalid filename");
         return ESP_FAIL;
     }
 
-    if (stat(filepath, &file_stat) == 0) {
+    if (stat(filepath, &file_stat) == 0)
+    {
         LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "File already exists: " + string(filepath));
         /* Respond with 400 Bad Request */
         httpd_resp_send_err(req, HTTPD_400_BAD_REQUEST, "File already exists");
@@ -641,19 +677,20 @@ static esp_err_t upload_post_handler(httpd_req_t *req)
     }
 
     /* File cannot be larger than a limit */
-    if (req->content_len > MAX_FILE_SIZE) {
+    if (req->content_len > MAX_FILE_SIZE)
+    {
         LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "File too large: " + to_string(req->content_len) + " bytes");
         /* Respond with 400 Bad Request */
         httpd_resp_send_err(req, HTTPD_400_BAD_REQUEST,
-                            "File size must be less than "
-                            MAX_FILE_SIZE_STR "!");
+                            "File size must be less than " MAX_FILE_SIZE_STR "!");
         /* Return failure to close underlying connection else the
          * incoming file content will keep the socket busy */
         return ESP_FAIL;
     }
 
     fd = fopen(filepath, "w");
-    if (!fd) {
+    if (!fd)
+    {
         LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Failed to create file: " + string(filepath));
         /* Respond with 500 Internal Server Error */
         httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "Failed to create file");
@@ -670,12 +707,15 @@ static esp_err_t upload_post_handler(httpd_req_t *req)
      * the size of the file being uploaded */
     int remaining = req->content_len;
 
-    while (remaining > 0) {
+    while (remaining > 0)
+    {
 
         ESP_LOGI(TAG, "Remaining size: %d", remaining);
         /* Receive the file part by part into a buffer */
-        if ((received = httpd_req_recv(req, buf, MIN(remaining, SERVER_FILER_SCRATCH_BUFSIZE))) <= 0) {
-            if (received == HTTPD_SOCK_ERR_TIMEOUT) {
+        if ((received = httpd_req_recv(req, buf, MIN(remaining, SERVER_FILER_SCRATCH_BUFSIZE))) <= 0)
+        {
+            if (received == HTTPD_SOCK_ERR_TIMEOUT)
+            {
                 /* Retry if timeout occurred */
                 continue;
             }
@@ -692,7 +732,8 @@ static esp_err_t upload_post_handler(httpd_req_t *req)
         }
 
         /* Write buffer content to file on storage */
-        if (received && (received != fwrite(buf, 1, received, fd))) {
+        if (received && (received != fwrite(buf, 1, received, fd)))
+        {
             /* Couldn't write everything to file!
              * Storage may be full? */
             fclose(fd);
@@ -715,11 +756,13 @@ static esp_err_t upload_post_handler(httpd_req_t *req)
     ESP_LOGI(TAG, "File reception completed");
 
     string s = req->uri;
-    if (isInString(s, "?md5")) {
+    if (isInString(s, "?md5"))
+    {
         LogFile.WriteToFile(ESP_LOG_INFO, TAG, "Calculate and return MD5 sum...");
-        
+
         fd = fopen(filepath, "r");
-        if (!fd) {
+        if (!fd)
+        {
             LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Failed to open file for reading: " + string(filepath));
             /* Respond with 500 Internal Server Error */
             httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "Failed to open file for reading");
@@ -734,7 +777,8 @@ static esp_err_t upload_post_handler(httpd_req_t *req)
         md5File(fd, result);
         fclose(fd);
 
-        for (int i = 0; i < sizeof(result); i++) {
+        for (int i = 0; i < sizeof(result); i++)
+        {
             snprintf(hex, sizeof(hex), "%02x", result[i]);
             md5hex.append(hex);
         }
@@ -745,13 +789,14 @@ static esp_err_t upload_post_handler(httpd_req_t *req)
 
         httpd_resp_sendstr(req, response.c_str());
     }
-    else {  // Return file server page
+    else
+    { // Return file server page
         std::string directory = std::string(filepath);
         size_t zw = directory.find("/");
         size_t found = zw;
         while (zw != std::string::npos)
         {
-            zw = directory.find("/", found+1);  
+            zw = directory.find("/", found + 1);
             if (zw != std::string::npos)
                 found = zw;
         }
@@ -760,7 +805,7 @@ static esp_err_t upload_post_handler(httpd_req_t *req)
         ESP_LOGD(TAG, "Directory: %s, start_fn: %d, found: %d", directory.c_str(), start_fn, found);
         directory = directory.substr(start_fn, found - start_fn + 1);
         directory = "/fileserver" + directory;
-    //    ESP_LOGD(TAG, "Directory danach 2: %s", directory.c_str());
+        //    ESP_LOGD(TAG, "Directory danach 2: %s", directory.c_str());
 
         /* Redirect onto root to see the updated file list */
         if (strcmp(filename, "/config/config.ini") == 0 ||
@@ -773,11 +818,12 @@ static esp_err_t upload_post_handler(httpd_req_t *req)
             strcmp(filename, "/img_tmp/ref0_org.jpg") == 0 ||
             strcmp(filename, "/img_tmp/ref1.jpg") == 0 ||
             strcmp(filename, "/img_tmp/ref1_org.jpg") == 0 ||
-            strcmp(filename, "/img_tmp/reference.jpg") == 0 ) 
-        { 
+            strcmp(filename, "/img_tmp/reference.jpg") == 0)
+        {
             httpd_resp_set_status(req, HTTPD_200); // Avoid reloading of folder content
         }
-        else {
+        else
+        {
             httpd_resp_set_status(req, "303 See Other"); // Reload folder content after upload
         }
 
@@ -795,20 +841,20 @@ static esp_err_t delete_post_handler(httpd_req_t *req)
     char filepath[FILE_PATH_MAX];
     struct stat file_stat;
 
-//////////////////////////////////////////////////////////////
+    //////////////////////////////////////////////////////////////
     char _query[200];
-    char _valuechar[30];    
+    char _valuechar[30];
     std::string fn = "/sdcard/firmware/";
     std::string _task;
     std::string directory;
-    std::string zw; 
+    std::string zw;
 
     httpd_resp_set_hdr(req, "Access-Control-Allow-Origin", "*");
 
     if (httpd_req_get_url_query_str(req, _query, 200) == ESP_OK)
     {
         ESP_LOGD(TAG, "Query: %s", _query);
-        
+
         if (httpd_query_key_value(_query, "task", _valuechar, 30) == ESP_OK)
         {
             LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "task is found: " + string(_valuechar));
@@ -821,55 +867,60 @@ static esp_err_t delete_post_handler(httpd_req_t *req)
         /* Skip leading "/delete" from URI to get filename */
         /* Note sizeof() counts NULL termination hence the -1 */
         const char *filename = get_path_from_uri(filepath, ((struct file_server_data *)req->user_ctx)->base_path,
-                                                req->uri  + sizeof("/delete") - 1, sizeof(filepath));
-        if (!filename) {
+                                                 req->uri + sizeof("/delete") - 1, sizeof(filepath));
+        if (!filename)
+        {
             /* Respond with 414 Error */
             httpd_resp_send_err(req, HTTPD_414_URI_TOO_LONG, "Filename too long");
             return ESP_FAIL;
         }
         zw = std::string(filename);
-        zw = zw.substr(0, zw.length()-1);
+        zw = zw.substr(0, zw.length() - 1);
         directory = "/fileserver" + zw + "/";
         zw = "/sdcard" + zw;
         ESP_LOGD(TAG, "Directory to delete: %s", zw.c_str());
 
         delete_all_in_directory(zw);
-//        directory = std::string(filepath);
-//        directory = "/fileserver" + directory;
+        //        directory = std::string(filepath);
+        //        directory = "/fileserver" + directory;
         ESP_LOGD(TAG, "Location after delete directory content: %s", directory.c_str());
         /* Redirect onto root to see the updated file list */
-//        httpd_resp_set_status(req, "303 See Other");
-//        httpd_resp_set_hdr(req, "Location", directory.c_str());
-//        httpd_resp_sendstr(req, "File deleted successfully");
-//        return ESP_OK;        
+        //        httpd_resp_set_status(req, "303 See Other");
+        //        httpd_resp_set_hdr(req, "Location", directory.c_str());
+        //        httpd_resp_sendstr(req, "File deleted successfully");
+        //        return ESP_OK;
     }
     else
     {
         /* Skip leading "/delete" from URI to get filename */
         /* Note sizeof() counts NULL termination hence the -1 */
         const char *filename = get_path_from_uri(filepath, ((struct file_server_data *)req->user_ctx)->base_path,
-                                                req->uri  + sizeof("/delete") - 1, sizeof(filepath));
-        if (!filename) {
+                                                 req->uri + sizeof("/delete") - 1, sizeof(filepath));
+        if (!filename)
+        {
             /* Respond with 500 Internal Server Error */
             httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "Filename too long");
             return ESP_FAIL;
         }
 
         /* Filename cannot have a trailing '/' */
-        if (filename[strlen(filename) - 1] == '/') {
+        if (filename[strlen(filename) - 1] == '/')
+        {
             LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Invalid filename: " + string(filename));
             /* Respond with 400 Bad Request */
             httpd_resp_send_err(req, HTTPD_400_BAD_REQUEST, "Invalid filename");
             return ESP_FAIL;
         }
 
-        if (strcmp(filename, "wlan.ini") == 0) {
+        if (strcmp(filename, "wlan.ini") == 0)
+        {
             LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Failed to delete protected file : " + string(filename));
             httpd_resp_send_err(req, HTTPD_403_FORBIDDEN, "Not allowed to delete wlan.ini");
             return ESP_FAIL;
         }
 
-        if (stat(filepath, &file_stat) == -1) { // File does not exist
+        if (stat(filepath, &file_stat) == -1)
+        { // File does not exist
             /* This is ok, we would delete it anyway */
             LogFile.WriteToFile(ESP_LOG_INFO, TAG, "File does not exist: " + string(filename));
         }
@@ -884,7 +935,7 @@ static esp_err_t delete_post_handler(httpd_req_t *req)
         size_t found = zw;
         while (zw != std::string::npos)
         {
-            zw = directory.find("/", found+1);  
+            zw = directory.find("/", found + 1);
             if (zw != std::string::npos)
                 found = zw;
         }
@@ -894,7 +945,7 @@ static esp_err_t delete_post_handler(httpd_req_t *req)
         directory = directory.substr(start_fn, found - start_fn + 1);
         directory = "/fileserver" + directory;
         ESP_LOGD(TAG, "Directory danach 4: %s", directory.c_str());
-    
+
         //////////////////////////////////////////////////////////////
 
         /* Redirect onto root to see the updated file list */
@@ -908,11 +959,12 @@ static esp_err_t delete_post_handler(httpd_req_t *req)
             strcmp(filename, "/img_tmp/ref0_org.jpg") == 0 ||
             strcmp(filename, "/img_tmp/ref1.jpg") == 0 ||
             strcmp(filename, "/img_tmp/ref1_org.jpg") == 0 ||
-            strcmp(filename, "/img_tmp/reference.jpg") == 0 ) 
-        { 
+            strcmp(filename, "/img_tmp/reference.jpg") == 0)
+        {
             httpd_resp_set_status(req, HTTPD_200); // Avoid reloading of folder content
         }
-        else {
+        else
+        {
             httpd_resp_set_status(req, "303 See Other"); // Reload folder content after upload
         }
     }
@@ -928,328 +980,118 @@ void delete_all_in_directory(std::string _directory)
     DIR *dir = opendir(_directory.c_str());
     std::string filename;
 
-    if (!dir) {
+    if (!dir)
+    {
         LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Failed to stat dir: " + _directory);
         return;
     }
 
     /* Iterate over all files / folders and fetch their names and sizes */
-    while ((entry = readdir(dir)) != NULL) {
-        if (!(entry->d_type == DT_DIR)){
-            if (strcmp("wlan.ini", entry->d_name) != 0){                    // auf wlan.ini soll nicht zugegriffen werden !!!
+    while ((entry = readdir(dir)) != NULL)
+    {
+        if (!(entry->d_type == DT_DIR))
+        {
+            if (strcmp("wlan.ini", entry->d_name) != 0)
+            { // auf wlan.ini soll nicht zugegriffen werden !!!
                 filename = _directory + "/" + std::string(entry->d_name);
                 LogFile.WriteToFile(ESP_LOG_INFO, TAG, "Deleting file: " + filename);
                 /* Delete file */
-                unlink(filename.c_str());    
+                unlink(filename.c_str());
             }
         };
     }
     closedir(dir);
 }
 
-std::string unzip_new(std::string _in_zip_file, std::string _html_tmp, std::string _html_final, std::string _target_bin, std::string _main, bool _initial_setup)
-{
-    int i, sort_iter;
-    mz_bool status;
-    size_t uncomp_size;
-    mz_zip_archive zip_archive;
-    void* p;
-    char archive_filename[64];
-    std::string zw, ret = "";
-    std::string directory = "";
-
-    ESP_LOGD(TAG, "miniz.c version: %s", MZ_VERSION);
-    ESP_LOGD(TAG, "Zipfile: %s", _in_zip_file.c_str());
-
-    // Now try to open the archive.
-    memset(&zip_archive, 0, sizeof(zip_archive));
-    status = mz_zip_reader_init_file(&zip_archive, _in_zip_file.c_str(), 0);
-    if (!status)
-    {
-        ESP_LOGD(TAG, "mz_zip_reader_init_file() failed!");
-        return ret;
-    }
-
-    // Get and print information about each file in the archive.
-    int numberoffiles = (int)mz_zip_reader_get_num_files(&zip_archive);
-    LogFile.WriteToFile(ESP_LOG_INFO, TAG, "Files to be extracted: " + to_string(numberoffiles));
-
-    sort_iter = 0;
-    {
-        memset(&zip_archive, 0, sizeof(zip_archive));
-        status = mz_zip_reader_init_file(&zip_archive, _in_zip_file.c_str(), sort_iter ? MZ_ZIP_FLAG_DO_NOT_SORT_CENTRAL_DIRECTORY : 0);
-        if (!status)
-        {
-            ESP_LOGD(TAG, "mz_zip_reader_init_file() failed!");
-            return ret;
-        }
-
-        for (i = 0; i < numberoffiles; i++)
-        {
-            mz_zip_archive_file_stat file_stat;
-            mz_zip_reader_file_stat(&zip_archive, i, &file_stat);
-            sprintf(archive_filename, file_stat.m_filename);
-            
-            if (!file_stat.m_is_directory) {
-            // Try to extract all the files to the heap.
-            p = mz_zip_reader_extract_file_to_heap(&zip_archive, archive_filename, &uncomp_size, 0);
-                if (!p)
-                {
-                    LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "mz_zip_reader_extract_file_to_heap() failed on file " + string(archive_filename));
-                    mz_zip_reader_end(&zip_archive);
-                    return ret;
-                }
-            
-                // Save to File.
-                zw = std::string(archive_filename);
-                ESP_LOGD(TAG, "Rohfilename: %s", zw.c_str());
-
-                if (toUpper(zw) == "FIRMWARE.BIN")
-                {
-                    zw = _target_bin + zw;
-                    ret = zw;
-                }
-                else
-                {
-                    std::string _dir = getDirectory(zw);
-                    if ((_dir == "config-initial") && !_initial_setup)
-                    {
-                        continue;
-                    }
-                    else
-                    {
-                        _dir = "config";
-                        std::string _s1 = "config-initial";
-                        FindReplace(zw, _s1, _dir);
-                    }
-
-                    if (_dir.length() > 0)
-                    {
-                        zw = _main + zw;
-                    }
-                    else
-                    {
-                        zw = _html_tmp + zw;
-                    }
-
-                }
-
-                // files in the html folder shall be redirected to the temporary html folder
-                if (zw.find(_html_final) == 0) {
-                    FindReplace(zw, _html_final, _html_tmp);
-                }
-            
-                string filename_zw = zw + SUFFIX_ZW;
-
-                ESP_LOGI(TAG, "File to extract: %s, Temp. Filename: %s", zw.c_str(), filename_zw.c_str());
-
-                std::string folder = filename_zw.substr(0, filename_zw.find_last_of('/'));
-                MakeDir(folder);
-
-                // extrahieren in zwischendatei
-                DeleteFile(filename_zw);
-
-                FILE* fpTargetFile = fopen(filename_zw.c_str(), "wb");
-                uint writtenbytes = fwrite(p, 1, (uint)uncomp_size, fpTargetFile);
-                fclose(fpTargetFile);
-                
-                bool isokay = true;
-
-                if (writtenbytes == (uint)uncomp_size)
-                {
-                    isokay = true;
-                }
-                else
-                {
-                    isokay = false;
-                    LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "ERROR in writting extracted file (function fwrite) extracted file \"" +
-                            string(archive_filename) + "\", size " + to_string(uncomp_size));
-                }
-
-                DeleteFile(zw);
-                if (!isokay)
-                    LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "ERROR in fwrite \"" + string(archive_filename) + "\", size " + to_string(uncomp_size));
-                isokay = isokay && RenameFile(filename_zw, zw);
-                if (!isokay)
-                    LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "ERROR in Rename \"" + filename_zw + "\" to \"" + zw);
-
-                if (isokay)
-                    LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "Successfully extracted file \"" + string(archive_filename) + "\", size " + to_string(uncomp_size));
-                else
-                {
-                    LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "ERROR in extracting file \"" + string(archive_filename) + "\", size " + to_string(uncomp_size));
-                    ret = "ERROR";
-                }
-                mz_free(p);
-            }
-        }
-
-        // Close the archive, freeing any resources it was using
-        mz_zip_reader_end(&zip_archive);
-    }
-
-    ESP_LOGD(TAG, "Success.");
-    return ret;
-}
-
-void unzip(std::string _in_zip_file, std::string _target_directory){
-    int i, sort_iter;
-    mz_bool status;
-    size_t uncomp_size;
-    mz_zip_archive zip_archive;
-    void* p;
-    char archive_filename[64];
-    std::string zw;
-//    static const char* s_Test_archive_filename = "testhtml.zip";
-
-    ESP_LOGD(TAG, "miniz.c version: %s", MZ_VERSION);
-    ESP_LOGD(TAG, "Zipfile: %s", _in_zip_file.c_str());
-    ESP_LOGD(TAG, "Target Dir: %s", _target_directory.c_str());
-
-    // Now try to open the archive.
-    memset(&zip_archive, 0, sizeof(zip_archive));
-    status = mz_zip_reader_init_file(&zip_archive, _in_zip_file.c_str(), 0);
-    if (!status)
-    {
-        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "mz_zip_reader_init_file() failed!");
-        return;
-    }
-
-    // Get and print information about each file in the archive.
-    int numberoffiles = (int)mz_zip_reader_get_num_files(&zip_archive);
-    for (sort_iter = 0; sort_iter < 2; sort_iter++)
-    {
-        memset(&zip_archive, 0, sizeof(zip_archive));
-        status = mz_zip_reader_init_file(&zip_archive, _in_zip_file.c_str(), sort_iter ? MZ_ZIP_FLAG_DO_NOT_SORT_CENTRAL_DIRECTORY : 0);
-        if (!status)
-        {
-            LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "mz_zip_reader_init_file() failed!");
-            return;
-        }
-
-        for (i = 0; i < numberoffiles; i++)
-        {
-            mz_zip_archive_file_stat file_stat;
-            mz_zip_reader_file_stat(&zip_archive, i, &file_stat);
-            sprintf(archive_filename, file_stat.m_filename);
- 
-            // Try to extract all the files to the heap.
-            p = mz_zip_reader_extract_file_to_heap(&zip_archive, archive_filename, &uncomp_size, 0);
-            if (!p)
-            {
-                LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "mz_zip_reader_extract_file_to_heap() failed!");
-                mz_zip_reader_end(&zip_archive);
-                return;
-            }
-
-            // Save to File.
-            zw = std::string(archive_filename);
-            zw = _target_directory + zw;
-            ESP_LOGD(TAG, "File to extract: %s", zw.c_str());
-            FILE* fpTargetFile = fopen(zw.c_str(), "wb");
-            fwrite(p, 1, (uint)uncomp_size, fpTargetFile);
-            fclose(fpTargetFile);
-
-            ESP_LOGD(TAG, "Successfully extracted file \"%s\", size %u", archive_filename, (uint)uncomp_size);
-            //            ESP_LOGD(TAG, "File data: \"%s\"", (const char*)p);
-
-            // We're done.
-            mz_free(p);
-        }
-
-        // Close the archive, freeing any resources it was using
-        mz_zip_reader_end(&zip_archive);
-    }
-
-    ESP_LOGD(TAG, "Success.");
-}
-
 void register_server_file_uri(httpd_handle_t server, const char *base_path)
 {
     static struct file_server_data *server_data = NULL;
 
     /* Validate file storage base path */
-    if (!base_path) {
-//    if (!base_path || strcmp(base_path, "/spiffs") != 0) {
+    if (!base_path)
+    {
+        //    if (!base_path || strcmp(base_path, "/spiffs") != 0) {
         LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "File server base_path not set");
-//        return ESP_ERR_INVALID_ARG;
+        //        return ESP_ERR_INVALID_ARG;
     }
 
-    if (server_data) {
+    if (server_data)
+    {
         LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "File server already started");
-//        return ESP_ERR_INVALID_STATE;
+        //        return ESP_ERR_INVALID_STATE;
     }
 
     /* Allocate memory for server data */
-    server_data = (file_server_data *) calloc(1, sizeof(struct file_server_data));
-    if (!server_data) {
+    server_data = (file_server_data *)calloc(1, sizeof(struct file_server_data));
+    if (!server_data)
+    {
         LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Failed to allocate memory for server data");
-//        return ESP_ERR_NO_MEM;
+        //        return ESP_ERR_NO_MEM;
     }
     strlcpy(server_data->base_path, base_path,
             sizeof(server_data->base_path));
 
     /* URI handler for getting uploaded files */
-//    char zw[sizeof(serverprefix)+1];
-//    strcpy(zw, serverprefix);
-//    zw[strlen(serverprefix)] = '*';
-//    zw[strlen(serverprefix)+1] = '\0';    
-//    ESP_LOGD(TAG, "zw: %s", zw);
+    //    char zw[sizeof(serverprefix)+1];
+    //    strcpy(zw, serverprefix);
+    //    zw[strlen(serverprefix)] = '*';
+    //    zw[strlen(serverprefix)+1] = '\0';
+    //    ESP_LOGD(TAG, "zw: %s", zw);
     httpd_uri_t file_download = {
-        .uri       = "/fileserver*",  // Match all URIs of type /path/to/file
-        .method    = HTTP_GET,
+        .uri = "/fileserver*", // Match all URIs of type /path/to/file
+        .method = HTTP_GET,
         .handler = APPLY_BASIC_AUTH_FILTER(download_get_handler),
-        .user_ctx  = server_data    // Pass server data as context
+        .user_ctx = server_data // Pass server data as context
     };
     httpd_register_uri_handler(server, &file_download);
 
     httpd_uri_t file_datafileact = {
-        .uri       = "/datafileact",  // Match all URIs of type /path/to/file
-        .method    = HTTP_GET,
+        .uri = "/datafileact", // Match all URIs of type /path/to/file
+        .method = HTTP_GET,
         .handler = APPLY_BASIC_AUTH_FILTER(datafileact_get_full_handler),
-        .user_ctx  = server_data    // Pass server data as context
+        .user_ctx = server_data // Pass server data as context
     };
     httpd_register_uri_handler(server, &file_datafileact);
 
     httpd_uri_t file_datafile_last_part_handle = {
-        .uri       = "/data",  // Match all URIs of type /path/to/file
-        .method    = HTTP_GET,
+        .uri = "/data", // Match all URIs of type /path/to/file
+        .method = HTTP_GET,
         .handler = APPLY_BASIC_AUTH_FILTER(datafileact_get_last_part_handler),
-        .user_ctx  = server_data    // Pass server data as context
+        .user_ctx = server_data // Pass server data as context
     };
     httpd_register_uri_handler(server, &file_datafile_last_part_handle);
 
     httpd_uri_t file_logfileact = {
-        .uri       = "/logfileact",  // Match all URIs of type /path/to/file
-        .method    = HTTP_GET,
+        .uri = "/logfileact", // Match all URIs of type /path/to/file
+        .method = HTTP_GET,
         .handler = APPLY_BASIC_AUTH_FILTER(logfileact_get_full_handler),
-        .user_ctx  = server_data    // Pass server data as context
+        .user_ctx = server_data // Pass server data as context
     };
     httpd_register_uri_handler(server, &file_logfileact);
 
     httpd_uri_t file_logfile_last_part_handle = {
-        .uri       = "/log",  // Match all URIs of type /path/to/file
-        .method    = HTTP_GET,
+        .uri = "/log", // Match all URIs of type /path/to/file
+        .method = HTTP_GET,
         .handler = APPLY_BASIC_AUTH_FILTER(logfileact_get_last_part_handler),
-        .user_ctx  = server_data    // Pass server data as context
+        .user_ctx = server_data // Pass server data as context
     };
     httpd_register_uri_handler(server, &file_logfile_last_part_handle);
 
     /* URI handler for uploading files to server */
     httpd_uri_t file_upload = {
-        .uri       = "/upload/*",   // Match all URIs of type /upload/path/to/file
-        .method    = HTTP_POST,
+        .uri = "/upload/*", // Match all URIs of type /upload/path/to/file
+        .method = HTTP_POST,
         .handler = APPLY_BASIC_AUTH_FILTER(upload_post_handler),
-        .user_ctx  = server_data    // Pass server data as context
+        .user_ctx = server_data // Pass server data as context
     };
     httpd_register_uri_handler(server, &file_upload);
 
     /* URI handler for deleting files from server */
     httpd_uri_t file_delete = {
-        .uri       = "/delete/*",   // Match all URIs of type /delete/path/to/file
-        .method    = HTTP_POST,
+        .uri = "/delete/*", // Match all URIs of type /delete/path/to/file
+        .method = HTTP_POST,
         .handler = APPLY_BASIC_AUTH_FILTER(delete_post_handler),
-        .user_ctx  = server_data    // Pass server data as context
+        .user_ctx = server_data // Pass server data as context
     };
     httpd_register_uri_handler(server, &file_delete);
 }

code/components/jomjol_fileserver_ota/server_file.h

@@ -8,14 +8,10 @@
 
 void register_server_file_uri(httpd_handle_t server, const char *base_path);
 
-void unzip(std::string _in_zip_file, std::string _target_directory);
-std::string unzip_new(std::string _in_zip_file, std::string _html_tmp, std::string _html_final, std::string _target_bin, std::string _main = "/sdcard/", bool _initial_setup = false);
-
-
 void delete_all_in_directory(std::string _directory);
 
 esp_err_t get_tflite_file_handler(httpd_req_t *req);
 esp_err_t get_data_file_handler(httpd_req_t *req);
 esp_err_t get_numbers_file_handler(httpd_req_t *req);
 
-#endif //SERVERFILE_H
+#endif // SERVERFILE_H

code/components/jomjol_fileserver_ota/server_help.cpp

@@ -5,28 +5,27 @@
 #include <sys/param.h>
 #include <sys/unistd.h>
 #include <sys/stat.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
 #include <dirent.h>
-#ifdef __cplusplus
-}
-#endif
-
 #include "esp_err.h"
 #include "esp_log.h"
-#include "Helper.h"
 #include "esp_http_server.h"
+
+#include "miniz.h"
+
+#include "Helper.h"
+#include "ClassLogFile.h"
 #include "../../include/defines.h"
 
 static const char *TAG = "SERVER HELP";
 
+string SUFFIX_ZW = "_tmp";
+
 char scratch[SERVER_HELPER_SCRATCH_BUFSIZE];
 
-bool endsWith(std::string const &str, std::string const &suffix) 
+bool endsWith(std::string const &str, std::string const &suffix)
 {
-    if (str.length() < suffix.length()) {
+    if (str.length() < suffix.length())
+    {
         return false;
     }
     return str.compare(str.length() - suffix.length(), suffix.length(), suffix) == 0;
@@ -42,7 +41,8 @@ esp_err_t send_file(httpd_req_t *req, std::string filename)
     std::string _filename_temp = std::string(filename) + ".gz";
 
     // Checks whether the file is available as .gz
-    if (stat(_filename_temp.c_str(), &file_stat) == 0) {
+    if (stat(_filename_temp.c_str(), &file_stat) == 0)
+    {
         filename = _filename_temp;
 
         ESP_LOGD(TAG, "new filename: %s", filename.c_str());
@@ -50,9 +50,10 @@ esp_err_t send_file(httpd_req_t *req, std::string filename)
     }
 
     FILE *fd = fopen(filename.c_str(), "r");
-    if (!fd)  {
+    if (!fd)
+    {
         ESP_LOGE(TAG, "Failed to read file: %s", filename.c_str());
-		
+
         /* Respond with 404 Error */
         httpd_resp_send_err(req, HTTPD_404_NOT_FOUND, get404());
         return ESP_FAIL;
@@ -73,44 +74,51 @@ esp_err_t send_file(httpd_req_t *req, std::string filename)
         endsWith(filename, ".png") ||
         endsWith(filename, ".gif") ||
         // endsWith(filename, ".zip") ||
-        endsWith(filename, ".gz"))	{
-        if (filename == "/sdcard/html/setup.html") {
+        endsWith(filename, ".gz"))
+    {
+        if (filename == "/sdcard/html/setup.html")
+        {
             httpd_resp_set_hdr(req, "Clear-Site-Data", "\"*\"");
             set_content_type_from_file(req, filename.c_str());
         }
-        else if (_gz_file_exists) {
+        else if (_gz_file_exists)
+        {
             httpd_resp_set_hdr(req, "Cache-Control", "max-age=43200");
             httpd_resp_set_hdr(req, "Content-Encoding", "gzip");
             set_content_type_from_file(req, _filename_old.c_str());
         }
-        else {
+        else
+        {
             httpd_resp_set_hdr(req, "Cache-Control", "max-age=43200");
             set_content_type_from_file(req, filename.c_str());
         }
     }
-    else {
+    else
+    {
         set_content_type_from_file(req, filename.c_str());
     }
 
     /* Retrieve the pointer to scratch buffer for temporary storage */
     char *chunk = scratch;
     size_t chunksize;
-	
-    do  {
+
+    do
+    {
         /* Read file in chunks into the scratch buffer */
         chunksize = fread(chunk, 1, SERVER_HELPER_SCRATCH_BUFSIZE, fd);
 
         /* Send the buffer contents as HTTP response chunk */
-        if (httpd_resp_send_chunk(req, chunk, chunksize) != ESP_OK)  {
+        if (httpd_resp_send_chunk(req, chunk, chunksize) != ESP_OK)
+        {
             fclose(fd);
             ESP_LOGE(TAG, "File sending failed!");
-			
+
             /* Abort sending file */
             httpd_resp_sendstr_chunk(req, NULL);
-			
+
             /* Respond with 500 Internal Server Error */
             httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "Failed to send file");
-			
+
             return ESP_FAIL;
         }
 
@@ -120,27 +128,30 @@ esp_err_t send_file(httpd_req_t *req, std::string filename)
     /* Close file after sending complete */
     fclose(fd);
     ESP_LOGD(TAG, "File sending complete");
-	
-    return ESP_OK;    
+
+    return ESP_OK;
 }
 
 /* Copies the full path into destination buffer and returns
  * pointer to path (skipping the preceding base path) */
-const char* get_path_from_uri(char *dest, const char *base_path, const char *uri, size_t destsize)
+const char *get_path_from_uri(char *dest, const char *base_path, const char *uri, size_t destsize)
 {
     const size_t base_pathlen = strlen(base_path);
     size_t pathlen = strlen(uri);
 
     const char *quest = strchr(uri, '?');
-    if (quest) {
+    if (quest)
+    {
         pathlen = MIN(pathlen, quest - uri);
     }
     const char *hash = strchr(uri, '#');
-    if (hash) {
+    if (hash)
+    {
         pathlen = MIN(pathlen, hash - uri);
     }
 
-    if (base_pathlen + pathlen + 1 > destsize) {
+    if (base_pathlen + pathlen + 1 > destsize)
+    {
         /* Full path string won't fit into destination buffer */
         return NULL;
     }
@@ -156,43 +167,56 @@ const char* get_path_from_uri(char *dest, const char *base_path, const char *uri
 /* Set HTTP response content type according to file extension */
 esp_err_t set_content_type_from_file(httpd_req_t *req, const char *filename)
 {
-    if (IS_FILE_EXT(filename, ".pdf")) {
+    if (IS_FILE_EXT(filename, ".pdf"))
+    {
         return httpd_resp_set_type(req, "application/x-pdf");
     }
-    else if (IS_FILE_EXT(filename, ".htm")) {
+    else if (IS_FILE_EXT(filename, ".htm"))
+    {
         return httpd_resp_set_type(req, "text/html");
     }
-    else if (IS_FILE_EXT(filename, ".html")) {
+    else if (IS_FILE_EXT(filename, ".html"))
+    {
         return httpd_resp_set_type(req, "text/html");
     }
-    else if (IS_FILE_EXT(filename, ".jpeg")) {
+    else if (IS_FILE_EXT(filename, ".jpeg"))
+    {
         return httpd_resp_set_type(req, "image/jpeg");
     }
-    else if (IS_FILE_EXT(filename, ".jpg")) {
+    else if (IS_FILE_EXT(filename, ".jpg"))
+    {
         return httpd_resp_set_type(req, "image/jpeg");
     }
-    else if (IS_FILE_EXT(filename, ".gif")) {
+    else if (IS_FILE_EXT(filename, ".gif"))
+    {
         return httpd_resp_set_type(req, "image/gif");
     }
-    else if (IS_FILE_EXT(filename, ".png")) {
+    else if (IS_FILE_EXT(filename, ".png"))
+    {
         return httpd_resp_set_type(req, "image/png");
     }
-    else if (IS_FILE_EXT(filename, ".ico")) {
+    else if (IS_FILE_EXT(filename, ".ico"))
+    {
         return httpd_resp_set_type(req, "image/x-icon");
     }
-    else if (IS_FILE_EXT(filename, ".js")) {
+    else if (IS_FILE_EXT(filename, ".js"))
+    {
         return httpd_resp_set_type(req, "application/javascript");
     }
-    else if (IS_FILE_EXT(filename, ".css")) {
+    else if (IS_FILE_EXT(filename, ".css"))
+    {
         return httpd_resp_set_type(req, "text/css");
     }
-    else if (IS_FILE_EXT(filename, ".xml")) {
+    else if (IS_FILE_EXT(filename, ".xml"))
+    {
         return httpd_resp_set_type(req, "text/xml");
     }
-    else if (IS_FILE_EXT(filename, ".zip")) {
+    else if (IS_FILE_EXT(filename, ".zip"))
+    {
         return httpd_resp_set_type(req, "application/x-zip");
     }
-    else if (IS_FILE_EXT(filename, ".gz")) {
+    else if (IS_FILE_EXT(filename, ".gz"))
+    {
         return httpd_resp_set_type(req, "application/x-gzip");
     }
 
@@ -200,3 +224,204 @@ esp_err_t set_content_type_from_file(httpd_req_t *req, const char *filename)
     /* For any other type always set as plain text */
     return httpd_resp_set_type(req, "text/plain");
 }
+
+struct unzip_context_t
+{
+    FILE *file;
+};
+
+static size_t unzip_write_callback(void *pOpaque, mz_uint64 file_ofs, const void *pBuf, size_t n)
+{
+    (void)file_ofs;
+
+    unzip_context_t *ctx = (unzip_context_t *)pOpaque;
+    if (!ctx || !ctx->file)
+    {
+        return 0;
+    }
+
+    size_t written = fwrite(pBuf, 1, n, ctx->file);
+    if (written != n)
+    {
+        return 0;
+    }
+
+    return written;
+}
+
+static bool unzip_extract_file(mz_zip_archive *zip_archive, int i, const std::string &output_file, const mz_zip_archive_file_stat &file_stat)
+{
+    DeleteFile(output_file);
+
+    FILE *pFile = fopen(output_file.c_str(), "wb");
+    if (!pFile)
+    {
+        return false;
+    }
+
+    setvbuf(pFile, NULL, _IOFBF, SERVER_FILER_SCRATCH_BUFSIZE);
+
+    unzip_context_t ctx;
+    ctx.file = pFile;
+
+    mz_bool status = mz_zip_reader_extract_to_callback(zip_archive, i, unzip_write_callback, &ctx, 0);
+
+    fclose(pFile);
+
+    if (!status)
+    {
+        DeleteFile(output_file);
+        return false;
+    }
+
+    return true;
+}
+
+void unzip_file(std::string _in_zip_file, std::string _target_directory)
+{
+    mz_zip_archive zip_archive;
+
+    ESP_LOGD(TAG, "Zipfile: %s", _in_zip_file.c_str());
+    ESP_LOGD(TAG, "Target Dir: %s", _target_directory.c_str());
+
+    memset(&zip_archive, 0, sizeof(zip_archive));
+
+    if (!mz_zip_reader_init_file(&zip_archive, _in_zip_file.c_str(), 0))
+    {
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "mz_zip_reader_init_file() failed!");
+        return;
+    }
+
+    int numberoffiles = (int)mz_zip_reader_get_num_files(&zip_archive);
+
+    for (int i = 0; i < numberoffiles; i++)
+    {
+        mz_zip_archive_file_stat file_stat;
+
+        if (!mz_zip_reader_file_stat(&zip_archive, i, &file_stat))
+        {
+            continue;
+        }
+
+        if (file_stat.m_is_directory)
+        {
+            continue;
+        }
+
+        std::string out_file = _target_directory + std::string(file_stat.m_filename);
+
+        ESP_LOGD(TAG, "Extract: %s", out_file.c_str());
+
+        bool ok = unzip_extract_file(&zip_archive, i, out_file, file_stat);
+
+        if (!ok)
+        {
+            LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Extract failed: " + std::string(file_stat.m_filename));
+            continue;
+        }
+    }
+
+    mz_zip_reader_end(&zip_archive);
+}
+
+std::string unzip_firmware(std::string _in_zip_file, std::string _html_tmp, std::string _html_final, std::string _target_bin, std::string _main, bool _initial_setup)
+{
+    mz_zip_archive zip_archive;
+
+    ESP_LOGD(TAG, "Zipfile: %s", _in_zip_file.c_str());
+
+    memset(&zip_archive, 0, sizeof(zip_archive));
+
+    if (!mz_zip_reader_init_file(&zip_archive, _in_zip_file.c_str(), 0))
+    {
+        ESP_LOGD(TAG, "mz_zip_reader_init_file() failed!");
+        return "";
+    }
+
+    int numberoffiles = (int)mz_zip_reader_get_num_files(&zip_archive);
+
+    std::string ret = "";
+
+    for (int i = 0; i < numberoffiles; i++)
+    {
+        mz_zip_archive_file_stat file_stat;
+
+        if (!mz_zip_reader_file_stat(&zip_archive, i, &file_stat))
+        {
+            continue;
+        }
+
+        if (file_stat.m_is_directory)
+        {
+            continue;
+        }
+
+        std::string path(file_stat.m_filename);
+
+        std::string logical_path;
+
+        if (toUpper(path) == "FIRMWARE.BIN")
+        {
+            logical_path = _target_bin + path;
+            ret = logical_path;
+        }
+        else
+        {
+            std::string dir = getDirectory(path);
+
+            if (dir == "config-initial" && !_initial_setup)
+            {
+                continue;
+            }
+
+            std::string modified = path;
+            std::string _s1 = "config-initial";
+            std::string _dir_new = "config";
+            FindReplace(modified, _s1, _dir_new);
+
+            if (!dir.empty())
+            {
+                logical_path = _main + modified;
+            }
+            else
+            {
+                logical_path = _html_tmp + modified;
+            }
+        }
+
+        if (logical_path.find(_html_final) == 0)
+        {
+            FindReplace(logical_path, _html_final, _html_tmp);
+        }
+
+        std::string temp_file = logical_path + SUFFIX_ZW;
+
+        std::string folder = temp_file.substr(0, temp_file.find_last_of('/'));
+        MakeDir(folder);
+
+        ESP_LOGI(TAG, "Extract: %s", temp_file.c_str());
+
+        bool ok = unzip_extract_file(&zip_archive, i, temp_file, file_stat);
+
+        if (!ok)
+        {
+            LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Extract failed: " + std::string(file_stat.m_filename));
+            ret = "ERROR";
+            continue;
+        }
+
+        DeleteFile(logical_path);
+
+        if (!RenameFile(temp_file, logical_path))
+        {
+            DeleteFile(temp_file);
+            LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Rename failed: " + temp_file);
+            ret = "ERROR";
+            continue;
+        }
+    }
+
+    mz_zip_reader_end(&zip_archive);
+
+    return ret;
+}

code/components/jomjol_fileserver_ota/server_help.h

@@ -4,14 +4,14 @@
 #define SERVERHELP_H
 
 #include <string>
-//#include <sys/param.h>
+#include <string.h>
 #include "esp_http_server.h"
 
-
-const char* get_path_from_uri(char *dest, const char *base_path, const char *uri, size_t destsize);
-
+const char *get_path_from_uri(char *dest, const char *base_path, const char *uri, size_t destsize);
 esp_err_t send_file(httpd_req_t *req, std::string filename);
-
 esp_err_t set_content_type_from_file(httpd_req_t *req, const char *filename);
 
-#endif //SERVERHELP_H
+void unzip_file(std::string _in_zip_file, std::string _target_directory);
+std::string unzip_firmware(std::string _in_zip_file, std::string _html_tmp, std::string _html_final, std::string _target_bin, std::string _main, bool _initial_setup);
+
+#endif // SERVERHELP_H

code/components/jomjol_fileserver_ota/server_ota.cpp

@@ -26,10 +26,11 @@
 
 #include "MainFlowControl.h"
 #include "server_file.h"
+#include "server_help.h"
 #include "server_GPIO.h"
 #ifdef ENABLE_MQTT
-    #include "interface_mqtt.h"
-#endif //ENABLE_MQTT
+#include "interface_mqtt.h"
+#endif // ENABLE_MQTT
 #include "ClassControllCamera.h"
 #include "connect_wlan.h"
 
@@ -41,7 +42,7 @@
 #include "../../include/defines.h"
 
 /*an ota data write buffer ready to write to the flash*/
-static char ota_write_data[SERVER_OTA_SCRATCH_BUFSIZE + 1] = { 0 };
+static char ota_write_data[SERVER_OTA_SCRATCH_BUFSIZE + 1] = {0};
 
 static const char *TAG = "OTA";
 
@@ -53,9 +54,9 @@ bool initial_setup = false;
 
 void task_do_Update_ZIP(void *pvParameter)
 {
-    StatusLED(AP_OR_OTA, 1, true);  // Signaling an OTA update
+    StatusLED(AP_OR_OTA, 1, true); // Signaling an OTA update
     std::string filetype = toUpper(getFileType(_file_name_update));
-  	LogFile.WriteToFile(ESP_LOG_INFO, TAG, "File: " + _file_name_update + " Filetype: " + filetype);
+    LogFile.WriteToFile(ESP_LOG_INFO, TAG, "File: " + _file_name_update + " Filetype: " + filetype);
 
     if (filetype == "ZIP")
     {
@@ -72,8 +73,8 @@ void task_do_Update_ZIP(void *pvParameter)
 
         /* Extract the ZIP file. The content of the html folder gets extracted to the temporar folder html-temp. */
         LogFile.WriteToFile(ESP_LOG_INFO, TAG, "Extracting ZIP file " + _file_name_update + "...");
-        retfirmware = unzip_new(_file_name_update, outHtmlTmp+"/", outHtml+"/", outbin+"/", "/sdcard/", initial_setup);
-    	LogFile.WriteToFile(ESP_LOG_INFO, TAG, "Files unzipped.");
+        retfirmware = unzip_firmware(_file_name_update, outHtmlTmp + "/", outHtml + "/", outbin + "/", "/sdcard/", initial_setup);
+        LogFile.WriteToFile(ESP_LOG_INFO, TAG, "Files unzipped.");
 
         /* ZIP file got extracted, replace the old html folder with the new one */
         LogFile.WriteToFile(ESP_LOG_INFO, TAG, "Renaming folder " + outHtml + " to " + outHtmlOld + "...");
@@ -91,49 +92,50 @@ void task_do_Update_ZIP(void *pvParameter)
 
         LogFile.WriteToFile(ESP_LOG_INFO, TAG, "Trigger reboot due to firmware update");
         doRebootOTA();
-    } 
-	else if (filetype == "BIN")
+    }
+    else if (filetype == "BIN")
     {
-       	LogFile.WriteToFile(ESP_LOG_INFO, TAG, "Do firmware update - file: " + _file_name_update);
+        LogFile.WriteToFile(ESP_LOG_INFO, TAG, "Do firmware update - file: " + _file_name_update);
         ota_update_task(_file_name_update);
         LogFile.WriteToFile(ESP_LOG_INFO, TAG, "Trigger reboot due to firmware update");
         doRebootOTA();
     }
     else
     {
-    	LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Only ZIP-Files support for update during startup!");
+        LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Only ZIP-Files support for update during startup!");
     }
 }
 
 void CheckUpdate()
 {
- 	FILE *pfile = fopen("/sdcard/update.txt", "r");
+    FILE *pfile = fopen("/sdcard/update.txt", "r");
     if (pfile == NULL)
     {
-		LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "No pending update");
+        LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "No pending update");
         return;
-	}
+    }
 
-	char zw[1024] = "";
-	fgets(zw, 1024, pfile);
+    char zw[1024] = "";
+    fgets(zw, 1024, pfile);
     _file_name_update = std::string(zw);
-	
+
     if (fgets(zw, 1024, pfile))
-	{
-		std::string _szw = std::string(zw);
+    {
+        std::string _szw = std::string(zw);
         if (_szw == "init")
         {
-       		LogFile.WriteToFile(ESP_LOG_INFO, TAG, "Inital Setup triggered");
+            LogFile.WriteToFile(ESP_LOG_INFO, TAG, "Inital Setup triggered");
         }
-	}
+    }
 
     fclose(pfile);
-    DeleteFile("/sdcard/update.txt");   // Prevent Boot Loop!!!
-	LogFile.WriteToFile(ESP_LOG_INFO, TAG, "Start update process (" + _file_name_update + ")");
+    DeleteFile("/sdcard/update.txt"); // Prevent Boot Loop!!!
+    LogFile.WriteToFile(ESP_LOG_INFO, TAG, "Start update process (" + _file_name_update + ")");
 
-    xTaskCreate(&task_do_Update_ZIP, "task_do_Update_ZIP", configMINIMAL_STACK_SIZE * 35, NULL, tskIDLE_PRIORITY+1, NULL);
-    while(1) { 
-		// wait until reboot within task_do_Update_ZIP
+    xTaskCreate(&task_do_Update_ZIP, "task_do_Update_ZIP", configMINIMAL_STACK_SIZE * 35, NULL, tskIDLE_PRIORITY + 1, NULL);
+    while (1)
+    {
+        // wait until reboot within task_do_Update_ZIP
         vTaskDelay(1000 / portTICK_PERIOD_MS);
     }
 }
@@ -145,25 +147,28 @@ static bool ota_update_task(std::string fn)
     const esp_partition_t *configured = esp_ota_get_boot_partition();
     const esp_partition_t *running = esp_ota_get_running_partition();
 
-    if (configured != running) {        
+    if (configured != running)
+    {
         LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Configured OTA boot partition at offset " + to_string(configured->address) + ", but running from offset " + to_string(running->address));
         LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "(This can happen if either the OTA boot data or preferred boot image become somehow corrupted.)");
     }
-	
+
     ESP_LOGI(TAG, "Running partition type %d subtype %d (offset 0x%08x)", running->type, running->subtype, (unsigned int)running->address);
 
     const esp_partition_t *update_partition = esp_ota_get_next_update_partition(NULL);
     ESP_LOGI(TAG, "Writing to partition subtype %d at offset 0x%x", update_partition->subtype, (unsigned int)update_partition->address);
 
-    FILE *f = fopen(fn.c_str(), "rb");     // previously only "r
-    if (f == NULL) { 
-		// File does not exist
+    FILE *f = fopen(fn.c_str(), "rb"); // previously only "r
+    if (f == NULL)
+    {
+        // File does not exist
         return false;
     }
 
     int data_read = fread(ota_write_data, 1, SERVER_OTA_SCRATCH_BUFSIZE, f);
 
-    if (data_read <= 0) {
+    if (data_read <= 0)
+    {
         LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Error: SSL data read error");
         return false;
     }
@@ -172,29 +177,36 @@ static bool ota_update_task(std::string fn)
     esp_ota_handle_t update_handle = 0;
     int binary_file_length = 0;
     bool image_header_was_checked = false;
-	
-    while (data_read > 0) {
-        if (image_header_was_checked == false) {
+
+    while (data_read > 0)
+    {
+        if (image_header_was_checked == false)
+        {
             esp_app_desc_t new_app_info;
-            if (data_read > sizeof(esp_image_header_t) + sizeof(esp_image_segment_header_t) + sizeof(esp_app_desc_t)) {
+            if (data_read > sizeof(esp_image_header_t) + sizeof(esp_image_segment_header_t) + sizeof(esp_app_desc_t))
+            {
                 // check current version with downloading
                 memcpy(&new_app_info, &ota_write_data[sizeof(esp_image_header_t) + sizeof(esp_image_segment_header_t)], sizeof(esp_app_desc_t));
                 ESP_LOGI(TAG, "New firmware version: %s", new_app_info.version);
 
                 esp_app_desc_t running_app_info;
-                if (esp_ota_get_partition_description(running, &running_app_info) == ESP_OK) {
+                if (esp_ota_get_partition_description(running, &running_app_info) == ESP_OK)
+                {
                     ESP_LOGI(TAG, "Running firmware version: %s", running_app_info.version);
                 }
 
-                const esp_partition_t* last_invalid_app = esp_ota_get_last_invalid_partition();
+                const esp_partition_t *last_invalid_app = esp_ota_get_last_invalid_partition();
                 esp_app_desc_t invalid_app_info;
-                if (esp_ota_get_partition_description(last_invalid_app, &invalid_app_info) == ESP_OK) {
+                if (esp_ota_get_partition_description(last_invalid_app, &invalid_app_info) == ESP_OK)
+                {
                     ESP_LOGI(TAG, "Last invalid firmware version: %s", invalid_app_info.version);
                 }
 
                 // check current version with last invalid partition
-                if (last_invalid_app != NULL) {
-                    if (memcmp(invalid_app_info.version, new_app_info.version, sizeof(new_app_info.version)) == 0) {
+                if (last_invalid_app != NULL)
+                {
+                    if (memcmp(invalid_app_info.version, new_app_info.version, sizeof(new_app_info.version)) == 0)
+                    {
                         LogFile.WriteToFile(ESP_LOG_WARN, TAG, "New version is the same as invalid version");
                         LogFile.WriteToFile(ESP_LOG_WARN, TAG, "Previously, there was an attempt to launch the firmware with " + string(invalid_app_info.version) + " version, but it failed");
                         LogFile.WriteToFile(ESP_LOG_WARN, TAG, "The firmware has been rolled back to the previous version");
@@ -205,35 +217,40 @@ static bool ota_update_task(std::string fn)
                 image_header_was_checked = true;
 
                 err = esp_ota_begin(update_partition, OTA_SIZE_UNKNOWN, &update_handle);
-                if (err != ESP_OK) {
+                if (err != ESP_OK)
+                {
                     LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "esp_ota_begin failed (" + string(esp_err_to_name(err)) + ")");
                     return false;
                 }
                 ESP_LOGI(TAG, "esp_ota_begin succeeded");
-            } 
-			else {
+            }
+            else
+            {
                 LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "received package is not fit len");
                 return false;
             }
         }
-		
-        err = esp_ota_write( update_handle, (const void *)ota_write_data, data_read);
-        if (err != ESP_OK) {
+
+        err = esp_ota_write(update_handle, (const void *)ota_write_data, data_read);
+        if (err != ESP_OK)
+        {
             return false;
         }
-		
+
         binary_file_length += data_read;
         ESP_LOGD(TAG, "Written image length %d", binary_file_length);
 
         data_read = fread(ota_write_data, 1, SERVER_OTA_SCRATCH_BUFSIZE, f);
     }
-    fclose(f);  
+    fclose(f);
 
     ESP_LOGI(TAG, "Total Write binary data length: %d", binary_file_length);
 
     err = esp_ota_end(update_handle);
-    if (err != ESP_OK) {
-        if (err == ESP_ERR_OTA_VALIDATE_FAILED) {
+    if (err != ESP_OK)
+    {
+        if (err == ESP_ERR_OTA_VALIDATE_FAILED)
+        {
             LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Image validation failed, image is corrupted");
         }
         LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "esp_ota_end failed (" + string(esp_err_to_name(err)) + ")!");
@@ -241,23 +258,24 @@ static bool ota_update_task(std::string fn)
     }
 
     err = esp_ota_set_boot_partition(update_partition);
-    if (err != ESP_OK) {
+    if (err != ESP_OK)
+    {
         LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "esp_ota_set_boot_partition failed (" + string(esp_err_to_name(err)) + ")!");
-
     }
 
     return true;
 }
 
-static void print_sha256 (const uint8_t *image_hash, const char *label)
+static void print_sha256(const uint8_t *image_hash, const char *label)
 {
     char hash_print[HASH_LEN * 2 + 1];
     hash_print[HASH_LEN * 2] = 0;
-	
-    for (int i = 0; i < HASH_LEN; ++i) {
+
+    for (int i = 0; i < HASH_LEN; ++i)
+    {
         sprintf(&hash_print[i * 2], "%02x", image_hash[i]);
     }
-	
+
     ESP_LOGI(TAG, "%s: %s", label, hash_print);
 }
 
@@ -265,20 +283,20 @@ void CheckOTAUpdate(void)
 {
     ESP_LOGI(TAG, "Start CheckOTAUpdateCheck...");
 
-    uint8_t sha_256[HASH_LEN] = { 0 };
+    uint8_t sha_256[HASH_LEN] = {0};
     esp_partition_t partition;
 
     // get sha256 digest for the partition table
-    partition.address   = ESP_PARTITION_TABLE_OFFSET;
-    partition.size      = ESP_PARTITION_TABLE_MAX_LEN;
-    partition.type      = ESP_PARTITION_TYPE_DATA;
+    partition.address = ESP_PARTITION_TABLE_OFFSET;
+    partition.size = ESP_PARTITION_TABLE_MAX_LEN;
+    partition.type = ESP_PARTITION_TYPE_DATA;
     esp_partition_get_sha256(&partition, sha_256);
     print_sha256(sha_256, "SHA-256 for the partition table: ");
 
     // get sha256 digest for bootloader
-    partition.address   = ESP_BOOTLOADER_OFFSET;
-    partition.size      = ESP_PARTITION_TABLE_OFFSET;
-    partition.type      = ESP_PARTITION_TYPE_APP;
+    partition.address = ESP_BOOTLOADER_OFFSET;
+    partition.size = ESP_PARTITION_TABLE_OFFSET;
+    partition.type = ESP_PARTITION_TYPE_APP;
     esp_partition_get_sha256(&partition, sha_256);
     print_sha256(sha_256, "SHA-256 for bootloader: ");
 
@@ -289,44 +307,47 @@ void CheckOTAUpdate(void)
     const esp_partition_t *running = esp_ota_get_running_partition();
     esp_ota_img_states_t ota_state;
     esp_err_t res_stat_partition = esp_ota_get_state_partition(running, &ota_state);
-	
+
     switch (res_stat_partition)
     {
-        case ESP_OK:
-            ESP_LOGD(TAG, "CheckOTAUpdate Partition: ESP_OK");
-            if (ota_state == ESP_OTA_IMG_PENDING_VERIFY) {
-                if (getSystemStatus() == 0) {
-                    ESP_LOGI(TAG, "Diagnostics completed successfully! Continuing execution...");
-                    esp_ota_mark_app_valid_cancel_rollback();
-                } 
-				else {
-                    LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Diagnostics failed! Start rollback to the previous version...");
-                    esp_ota_mark_app_invalid_rollback_and_reboot();
-                }
+    case ESP_OK:
+        ESP_LOGD(TAG, "CheckOTAUpdate Partition: ESP_OK");
+        if (ota_state == ESP_OTA_IMG_PENDING_VERIFY)
+        {
+            if (getSystemStatus() == 0)
+            {
+                ESP_LOGI(TAG, "Diagnostics completed successfully! Continuing execution...");
+                esp_ota_mark_app_valid_cancel_rollback();
             }
-            break;
-        case ESP_ERR_INVALID_ARG:
-            ESP_LOGD(TAG, "CheckOTAUpdate Partition: ESP_ERR_INVALID_ARG");
-            break;
-        case ESP_ERR_NOT_SUPPORTED:
-            ESP_LOGD(TAG, "CheckOTAUpdate Partition: ESP_ERR_NOT_SUPPORTED");
-            break;
-        case ESP_ERR_NOT_FOUND:
-            ESP_LOGD(TAG, "CheckOTAUpdate Partition: ESP_ERR_NOT_FOUND");
-            break;
+            else
+            {
+                LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Diagnostics failed! Start rollback to the previous version...");
+                esp_ota_mark_app_invalid_rollback_and_reboot();
+            }
+        }
+        break;
+    case ESP_ERR_INVALID_ARG:
+        ESP_LOGD(TAG, "CheckOTAUpdate Partition: ESP_ERR_INVALID_ARG");
+        break;
+    case ESP_ERR_NOT_SUPPORTED:
+        ESP_LOGD(TAG, "CheckOTAUpdate Partition: ESP_ERR_NOT_SUPPORTED");
+        break;
+    case ESP_ERR_NOT_FOUND:
+        ESP_LOGD(TAG, "CheckOTAUpdate Partition: ESP_ERR_NOT_FOUND");
+        break;
     }
 }
 
 esp_err_t handler_ota_update(httpd_req_t *req)
 {
-#ifdef DEBUG_DETAIL_ON     
-    LogFile.WriteHeapInfo("handler_ota_update - Start");    
+#ifdef DEBUG_DETAIL_ON
+    LogFile.WriteHeapInfo("handler_ota_update - Start");
 #endif
 
     LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "handler_ota_update");
     char _query[200];
     char _filename[100];
-    char _valuechar[30];    
+    char _valuechar[30];
     std::string fn = "/sdcard/firmware/";
     bool _file_del = false;
     std::string _task = "";
@@ -334,7 +355,7 @@ esp_err_t handler_ota_update(httpd_req_t *req)
     if (httpd_req_get_url_query_str(req, _query, 200) == ESP_OK)
     {
         ESP_LOGD(TAG, "Query: %s", _query);
-        
+
         if (httpd_query_key_value(_query, "task", _valuechar, 30) == ESP_OK)
         {
             ESP_LOGD(TAG, "task is found: %s", _valuechar);
@@ -352,7 +373,6 @@ esp_err_t handler_ota_update(httpd_req_t *req)
             _file_del = true;
             ESP_LOGD(TAG, "Delete Default File: %s", fn.c_str());
         }
-
     }
 
     if (_task.compare("emptyfirmwaredir") == 0)
@@ -362,11 +382,11 @@ esp_err_t handler_ota_update(httpd_req_t *req)
         std::string zw = "firmware directory deleted - v2\n";
         ESP_LOGD(TAG, "%s", zw.c_str());
         printf("Ausgabe: %s\n", zw.c_str());
-    
+
         httpd_resp_set_hdr(req, "Access-Control-Allow-Origin", "*");
-        httpd_resp_send(req, zw.c_str(), strlen(zw.c_str())); 
+        httpd_resp_send(req, zw.c_str(), strlen(zw.c_str()));
         /* Respond with an empty chunk to signal HTTP response completion */
-        httpd_resp_send_chunk(req, NULL, 0);  
+        httpd_resp_send_chunk(req, NULL, 0);
 
         ESP_LOGD(TAG, "Done empty directory /firmware");
         return ESP_OK;
@@ -379,8 +399,8 @@ esp_err_t handler_ota_update(httpd_req_t *req)
         {
             std::string zw = "Update failed - no file specified (zip, bin, tfl, tlite)";
             httpd_resp_sendstr_chunk(req, zw.c_str());
-            httpd_resp_sendstr_chunk(req, NULL);  
-            return ESP_OK;        
+            httpd_resp_sendstr_chunk(req, NULL);
+            return ESP_OK;
         }
 
         if ((filetype == "TFLITE") || (filetype == "TFL"))
@@ -390,9 +410,9 @@ esp_err_t handler_ota_update(httpd_req_t *req)
             CopyFile(fn, out);
             DeleteFile(fn);
 
-            const char*  resp_str = "Neural Network File copied.";
+            const char *resp_str = "Neural Network File copied.";
             httpd_resp_sendstr_chunk(req, resp_str);
-            httpd_resp_sendstr_chunk(req, NULL);  
+            httpd_resp_sendstr_chunk(req, NULL);
             return ESP_OK;
         }
 
@@ -405,15 +425,15 @@ esp_err_t handler_ota_update(httpd_req_t *req)
 
             std::string zw = "reboot\n";
             httpd_resp_sendstr_chunk(req, zw.c_str());
-            httpd_resp_sendstr_chunk(req, NULL);  
+            httpd_resp_sendstr_chunk(req, NULL);
             ESP_LOGD(TAG, "Send reboot");
             return ESP_OK;
         }
 
         std::string zw = "Update failed - no valid file specified (zip, bin, tfl, tlite)!";
         httpd_resp_sendstr_chunk(req, zw.c_str());
-        httpd_resp_sendstr_chunk(req, NULL);  
-        return ESP_OK;        
+        httpd_resp_sendstr_chunk(req, NULL);
+        return ESP_OK;
     }
 
     if (_task.compare("unziphtml") == 0)
@@ -425,11 +445,11 @@ esp_err_t handler_ota_update(httpd_req_t *req)
 
         delete_all_in_directory(out);
 
-        unzip(in, out+"/");
+        unzip_file(in, out + "/");
         std::string zw = "Web Interface Update Successfull!\nNo reboot necessary";
         httpd_resp_send(req, zw.c_str(), strlen(zw.c_str()));
-        httpd_resp_sendstr_chunk(req, NULL);  
-        return ESP_OK;        
+        httpd_resp_sendstr_chunk(req, NULL);
+        return ESP_OK;
     }
 
     if (_file_del)
@@ -438,8 +458,9 @@ esp_err_t handler_ota_update(httpd_req_t *req)
         struct stat file_stat;
         int _result = stat(fn.c_str(), &file_stat);
         ESP_LOGD(TAG, "Ergebnis %d\n", _result);
-		
-        if (_result == 0) {
+
+        if (_result == 0)
+        {
             ESP_LOGD(TAG, "Deleting file: %s", fn.c_str());
             /* Delete file */
             unlink(fn.c_str());
@@ -448,7 +469,7 @@ esp_err_t handler_ota_update(httpd_req_t *req)
         {
             LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "File does not exist: " + fn);
         }
-		
+
         /* Respond with an empty chunk to signal HTTP response completion */
         std::string zw = "file deleted\n";
         ESP_LOGD(TAG, "%s", zw.c_str());
@@ -459,64 +480,66 @@ esp_err_t handler_ota_update(httpd_req_t *req)
 
     std::string zw = "ota without parameter - should not be the case!";
     httpd_resp_set_hdr(req, "Access-Control-Allow-Origin", "*");
-    httpd_resp_send(req, zw.c_str(), strlen(zw.c_str())); 
-    httpd_resp_send_chunk(req, NULL, 0);  
+    httpd_resp_send(req, zw.c_str(), strlen(zw.c_str()));
+    httpd_resp_send_chunk(req, NULL, 0);
 
     LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "ota without parameter - should not be the case!");
 
-    #ifdef DEBUG_DETAIL_ON 
-        LogFile.WriteHeapInfo("handler_ota_update - Done");    
-    #endif
+#ifdef DEBUG_DETAIL_ON
+    LogFile.WriteHeapInfo("handler_ota_update - Done");
+#endif
 
     return ESP_OK;
 }
 
-void hard_restart() 
+void hard_restart()
 {
-  esp_task_wdt_config_t twdt_config = {
-    .timeout_ms = 1,
-    .idle_core_mask = (1 << portNUM_PROCESSORS) - 1,    // Bitmask of all cores
-    .trigger_panic = true,
-  };
-  ESP_ERROR_CHECK(esp_task_wdt_init(&twdt_config));
-
-  esp_task_wdt_add(NULL);
-  while(true);
+    esp_task_wdt_config_t twdt_config = {
+        .timeout_ms = 1,
+        .idle_core_mask = (1 << portNUM_PROCESSORS) - 1, // Bitmask of all cores
+        .trigger_panic = true,
+    };
+    ESP_ERROR_CHECK(esp_task_wdt_init(&twdt_config));
+
+    esp_task_wdt_add(NULL);
+    while (true)
+        ;
 }
 
 void task_reboot(void *DeleteMainFlow)
 {
     // write a reboot, to identify a reboot by purpouse
-    FILE* pfile = fopen("/sdcard/reboot.txt", "w");
-    std::string _s_zw= "reboot";
+    FILE *pfile = fopen("/sdcard/reboot.txt", "w");
+    std::string _s_zw = "reboot";
     fwrite(_s_zw.c_str(), strlen(_s_zw.c_str()), 1, pfile);
     fclose(pfile);
 
     vTaskDelay(3000 / portTICK_PERIOD_MS);
 
-    if ((bool)DeleteMainFlow) {
-        DeleteMainFlowTask();  // Kill autoflow task if executed in extra task, if not don't kill parent task
+    if ((bool)DeleteMainFlow)
+    {
+        DeleteMainFlowTask(); // Kill autoflow task if executed in extra task, if not don't kill parent task
     }
 
     Camera.LightOnOff(false);
     StatusLEDOff();
 
-    /* Stop service tasks */
-    #ifdef ENABLE_MQTT
-        MQTTdestroy_client(true);
-    #endif //ENABLE_MQTT
+/* Stop service tasks */
+#ifdef ENABLE_MQTT
+    MQTTdestroy_client(true);
+#endif // ENABLE_MQTT
     gpio_handler_destroy();
     esp_camera_deinit();
     WIFIDestroy();
 
     vTaskDelay(3000 / portTICK_PERIOD_MS);
-    esp_restart();      // Reset type: CPU reset (Reset both CPUs)
+    esp_restart(); // Reset type: CPU reset (Reset both CPUs)
 
     vTaskDelay(5000 / portTICK_PERIOD_MS);
-    hard_restart();     // Reset type: System reset (Triggered by watchdog), if esp_restart stalls (WDT needs to be activated)
+    hard_restart(); // Reset type: System reset (Triggered by watchdog), if esp_restart stalls (WDT needs to be activated)
 
     LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "Reboot failed!");
-    vTaskDelete(NULL); //Delete this task if it comes to this point
+    vTaskDelete(NULL); // Delete this task if it comes to this point
 }
 
 void doReboot()
@@ -524,11 +547,11 @@ void doReboot()
     LogFile.WriteToFile(ESP_LOG_INFO, TAG, "Reboot triggered by Software (5s)");
     LogFile.WriteToFile(ESP_LOG_WARN, TAG, "Reboot in 5sec");
 
-    BaseType_t xReturned = xTaskCreate(&task_reboot, "task_reboot", configMINIMAL_STACK_SIZE * 4, (void*) true, 10, NULL);
-    if( xReturned != pdPASS )
+    BaseType_t xReturned = xTaskCreate(&task_reboot, "task_reboot", configMINIMAL_STACK_SIZE * 4, (void *)true, 10, NULL);
+    if (xReturned != pdPASS)
     {
         LogFile.WriteToFile(ESP_LOG_ERROR, TAG, "task_reboot not created -> force reboot without killing flow");
-        task_reboot((void*) false);
+        task_reboot((void *)false);
     }
     vTaskDelay(10000 / portTICK_PERIOD_MS); // Prevent serving web client fetch response until system is shuting down
 }
@@ -542,39 +565,39 @@ void doRebootOTA()
     esp_camera_deinit();
 
     vTaskDelay(5000 / portTICK_PERIOD_MS);
-    esp_restart();      // Reset type: CPU reset (Reset both CPUs)
+    esp_restart(); // Reset type: CPU reset (Reset both CPUs)
 
     vTaskDelay(5000 / portTICK_PERIOD_MS);
-    hard_restart();     // Reset type: System reset (Triggered by watchdog), if esp_restart stalls (WDT needs to be activated)
+    hard_restart(); // Reset type: System reset (Triggered by watchdog), if esp_restart stalls (WDT needs to be activated)
 }
 
 esp_err_t handler_reboot(httpd_req_t *req)
 {
-    #ifdef DEBUG_DETAIL_ON     
-        LogFile.WriteHeapInfo("handler_reboot - Start");
-    #endif    
+#ifdef DEBUG_DETAIL_ON
+    LogFile.WriteHeapInfo("handler_reboot - Start");
+#endif
 
     LogFile.WriteToFile(ESP_LOG_DEBUG, TAG, "handler_reboot");
     LogFile.WriteToFile(ESP_LOG_INFO, TAG, "!!! System will restart within 5 sec!!!");
 
-    std::string response = 
+    std::string response =
         "<html><head><script>"
-            "function m(h) {"
-                "document.getElementById('t').innerHTML=h;"
-                "setInterval(function (){h +='.'; document.getElementById('t').innerHTML=h;"
-                "fetch('reboot_page.html',{mode: 'no-cors'}).then(r=>{parent.location.href=('index.html');})}, 1000);"
-            "}</script></head></html><body style='font-family: arial'><h3 id=t></h3>"
-            "<script>m('Rebooting!<br>The page will automatically reload in around 25..60s.<br><br>');</script>"
-            "</body></html>";
+        "function m(h) {"
+        "document.getElementById('t').innerHTML=h;"
+        "setInterval(function (){h +='.'; document.getElementById('t').innerHTML=h;"
+        "fetch('reboot_page.html',{mode: 'no-cors'}).then(r=>{parent.location.href=('index.html');})}, 1000);"
+        "}</script></head></html><body style='font-family: arial'><h3 id=t></h3>"
+        "<script>m('Rebooting!<br>The page will automatically reload in around 25..60s.<br><br>');</script>"
+        "</body></html>";
 
     httpd_resp_set_hdr(req, "Access-Control-Allow-Origin", "*");
     httpd_resp_send(req, response.c_str(), strlen(response.c_str()));
-    
+
     doReboot();
 
-    #ifdef DEBUG_DETAIL_ON 
-        LogFile.WriteHeapInfo("handler_reboot - Done");    
-    #endif
+#ifdef DEBUG_DETAIL_ON
+    LogFile.WriteHeapInfo("handler_reboot - Done");
+#endif
 
     return ESP_OK;
 }
@@ -582,17 +605,17 @@ esp_err_t handler_reboot(httpd_req_t *req)
 void register_server_ota_sdcard_uri(httpd_handle_t server)
 {
     ESP_LOGI(TAG, "Registering URI handlers");
-    
-    httpd_uri_t camuri = { };
-    camuri.method    = HTTP_GET;
-    camuri.uri       = "/ota";
+
+    httpd_uri_t camuri = {};
+    camuri.method = HTTP_GET;
+    camuri.uri = "/ota";
     camuri.handler = APPLY_BASIC_AUTH_FILTER(handler_ota_update);
-    camuri.user_ctx  = (void*) "Do OTA";    
+    camuri.user_ctx = (void *)"Do OTA";
     httpd_register_uri_handler(server, &camuri);
 
-    camuri.method    = HTTP_GET;
-    camuri.uri       = "/reboot";
+    camuri.method = HTTP_GET;
+    camuri.uri = "/reboot";
     camuri.handler = APPLY_BASIC_AUTH_FILTER(handler_reboot);
-    camuri.user_ctx  = (void*) "Reboot";    
+    camuri.user_ctx = (void *)"Reboot";
     httpd_register_uri_handler(server, &camuri);
 }

code/components/jomjol_fileserver_ota/server_ota.h

@@ -9,7 +9,6 @@
 
 #include <string>
 
-
 void register_server_ota_sdcard_uri(httpd_handle_t server);
 void CheckOTAUpdate();
 void doReboot();
@@ -17,4 +16,4 @@ void doRebootOTA();
 void hard_restart();
 void CheckUpdate();
 
-#endif //SERVEROTA_H
+#endif // SERVEROTA_H

code/components/jomjol_helper/sdcard_init.c

@@ -1,646 +0,0 @@
-/*
- * SPDX-FileCopyrightText: 2015-2022 Espressif Systems (Shanghai) CO LTD
- *
- * SPDX-License-Identifier: Apache-2.0
- */
-
-#include <stdlib.h>
-#include <string.h>
-
-#include "sdcard_init.h"
-
-#include "esp_log.h"
-#include "ffconf.h"
-#include "esp_compiler.h"
-#include "esp_vfs.h"
-#include "vfs_fat_internal.h"
-#include "diskio_impl.h"
-#include "diskio_sdmmc.h"
-#include "soc/soc_caps.h"
-#include "driver/sdmmc_defs.h"
-
-#if SOC_SDMMC_HOST_SUPPORTED
-	#include "driver/sdmmc_host.h"
-#endif
-
-static sdmmc_card_t* s_cards[FF_VOLUMES] = { NULL };
-static bool s_disk_status_check_en[FF_VOLUMES] = { };
-
-static const char* TAG = "sdcard_init";
-
-#define CHECK_EXECUTE_RESULT(err, str) do { \
-    if ((err) !=ESP_OK) { \
-        ESP_LOGE(TAG, str" (0x%x).", err); \
-        goto cleanup; \
-    } \
-    } while(0)
-
-typedef struct mh_vfs_fat_sd_ctx_t {
-    BYTE pdrv;                                  //Drive number that is mounted
-    esp_vfs_fat_mount_config_t mount_config;    //Mount configuration
-    FATFS *fs;                                  //FAT structure pointer that is registered
-    sdmmc_card_t *card;                         //Card info
-    char *base_path;                            //Path where partition is registered
-} mh_vfs_fat_sd_ctx_t;
-
-static mh_vfs_fat_sd_ctx_t *s_ctx[FF_VOLUMES] = {};
-
-/**
- * This `s_saved_ctx_id` is only used by `esp_vfs_fat_sdmmc_unmount`, which is deprecated.
- * This variable together with `esp_vfs_fat_sdmmc_unmount` should be removed in next major version
- */
-static uint32_t s_saved_ctx_id = FF_VOLUMES;
-
-
-static void call_host_deinit_mh(const sdmmc_host_t *host_config);
-static esp_err_t partition_card_mh(const esp_vfs_fat_mount_config_t *mount_config, const char *drv, sdmmc_card_t *card, BYTE pdrv);
-
-
-//Check if SD/MMC card is present
-static DSTATUS ff_sdmmc_card_available_mh(BYTE pdrv)
-{
-    sdmmc_card_t* card = s_cards[pdrv];
-    assert(card);
-    esp_err_t err = sdmmc_get_status(card);
-	
-    if (unlikely(err != ESP_OK)) {
-        ESP_LOGE(TAG, "Check status failed (0x%x)", err);
-        return STA_NOINIT;
-    }
-    return 0;
-}
-
-/**
-*   ff_sdmmc_status() and ff_sdmmc_initialize() return STA_NOINIT when sdmmc_get_status()
-*   fails. This error value is checked throughout the FATFS code.
-*   Both functions return 0 on success.
-*/
-DSTATUS ff_sdmmc_initialize_mh (BYTE pdrv)
-{
-    return ff_sdmmc_card_available_mh(pdrv);
-}
-
-DSTATUS ff_sdmmc_status_mh(BYTE pdrv)
-{
-    if (s_disk_status_check_en[pdrv]) {
-        return ff_sdmmc_card_available_mh(pdrv);
-    }
-    return 0;
-}
-
-DRESULT ff_sdmmc_read_mh (BYTE pdrv, BYTE* buff, DWORD sector, UINT count)
-{
-    sdmmc_card_t* card = s_cards[pdrv];
-    assert(card);
-    esp_err_t err = sdmmc_read_sectors(card, buff, sector, count);
-    if (unlikely(err != ESP_OK)) {
-        ESP_LOGE(TAG, "sdmmc_read_blocks failed (%d)", err);
-        return RES_ERROR;
-    }
-    return RES_OK;
-}
-
-DRESULT ff_sdmmc_write_mh (BYTE pdrv, const BYTE* buff, DWORD sector, UINT count)
-{
-    sdmmc_card_t* card = s_cards[pdrv];
-    assert(card);
-    esp_err_t err = sdmmc_write_sectors(card, buff, sector, count);
-    if (unlikely(err != ESP_OK)) {
-        ESP_LOGE(TAG, "sdmmc_write_blocks failed (%d)", err);
-        return RES_ERROR;
-    }
-    return RES_OK;
-}
-
-#if FF_USE_TRIM
-DRESULT ff_sdmmc_trim_mh (BYTE pdrv, DWORD start_sector, DWORD sector_count)
-{
-    sdmmc_card_t* card = s_cards[pdrv];
-    assert(card);
-    sdmmc_erase_arg_t arg;
-
-    arg = sdmmc_can_discard(card) == ESP_OK ? SDMMC_DISCARD_ARG : SDMMC_ERASE_ARG;
-    esp_err_t err = sdmmc_erase_sectors(card, start_sector, sector_count, arg);
-    if (unlikely(err != ESP_OK)) {
-        ESP_LOGE(TAG, "sdmmc_erase_sectors failed (%d)", err);
-        return RES_ERROR;
-    }
-    return RES_OK;
-}
-#endif //FF_USE_TRIM
-
-DRESULT ff_sdmmc_ioctl_mh (BYTE pdrv, BYTE cmd, void* buff)
-{
-    sdmmc_card_t* card = s_cards[pdrv];
-    assert(card);
-    switch(cmd) {
-        case CTRL_SYNC:
-            return RES_OK;
-        case GET_SECTOR_COUNT:
-            *((DWORD*) buff) = card->csd.capacity;
-            return RES_OK;
-        case GET_SECTOR_SIZE:
-            *((WORD*) buff) = card->csd.sector_size;
-            return RES_OK;
-        case GET_BLOCK_SIZE:
-            return RES_ERROR;
-#if FF_USE_TRIM
-        case CTRL_TRIM:
-            if (sdmmc_can_trim(card) != ESP_OK) {
-                return RES_PARERR;
-            }
-            return ff_sdmmc_trim_mh (pdrv, *((DWORD*)buff), //start_sector
-                    (*((DWORD*)buff + 1) - *((DWORD*)buff) + 1)); //sector_count
-#endif //FF_USE_TRIM
-    }
-    return RES_ERROR;
-}
-
-void ff_sdmmc_set_disk_status_check_mh(BYTE pdrv, bool enable)
-{
-    s_disk_status_check_en[pdrv] = enable;
-}
-
-void ff_diskio_register_sdmmc_mh(BYTE pdrv, sdmmc_card_t* card)
-{
-    static const ff_diskio_impl_t sdmmc_impl = {
-        .init = &ff_sdmmc_initialize_mh,
-        .status = &ff_sdmmc_status_mh,
-        .read = &ff_sdmmc_read_mh,
-        .write = &ff_sdmmc_write_mh,
-        .ioctl = &ff_sdmmc_ioctl_mh
-    };
-    s_cards[pdrv] = card;
-    s_disk_status_check_en[pdrv] = false;
-    ff_diskio_register(pdrv, &sdmmc_impl);
-}
-
-BYTE ff_diskio_get_pdrv_card_mh(const sdmmc_card_t* card)
-{
-    for (int i = 0; i < FF_VOLUMES; i++) {
-        if (card == s_cards[i]) {
-            return i;
-        }
-    }
-    return 0xff;
-}
-
-static bool s_get_context_id_by_card_mh(const sdmmc_card_t *card, uint32_t *out_id)
-{
-    mh_vfs_fat_sd_ctx_t *p_ctx = NULL;
-    for (int i = 0; i < FF_VOLUMES; i++) {
-        p_ctx = s_ctx[i];
-        if (p_ctx) {
-            if (p_ctx->card == card) {
-                *out_id = i;
-                return true;
-            }
-        }
-    }
-    return false;
-}
-
-static uint32_t s_get_unused_context_id_mh(void)
-{
-    for (uint32_t i = 0; i < FF_VOLUMES; i++) {
-        if (!s_ctx[i]) {
-            return i;
-        }
-    }
-    return FF_VOLUMES;
-}
-
-static esp_err_t mount_prepare_mem_mh(const char *base_path, BYTE *out_pdrv, char **out_dup_path, sdmmc_card_t** out_card)
-{
-    esp_err_t err = ESP_OK;
-    char* dup_path = NULL;
-    sdmmc_card_t* card = NULL;
-
-    // connect SDMMC driver to FATFS
-    BYTE pdrv = FF_DRV_NOT_USED;
-
-    if (ff_diskio_get_drive(&pdrv) != ESP_OK || pdrv == FF_DRV_NOT_USED) {
-        ESP_LOGD(TAG, "the maximum count of volumes is already mounted");
-        return ESP_ERR_NO_MEM;
-    }
-
-    // not using ff_memalloc here, as allocation in internal RAM is preferred
-    card = (sdmmc_card_t*)malloc(sizeof(sdmmc_card_t));
-
-    if (card == NULL) {
-        ESP_LOGD(TAG, "could not locate new sdmmc_card_t");
-        err = ESP_ERR_NO_MEM;
-        goto cleanup;
-    }
-
-    dup_path = strdup(base_path);
-
-    if(!dup_path){
-        ESP_LOGD(TAG, "could not copy base_path");
-        err = ESP_ERR_NO_MEM;
-        goto cleanup;
-    }
-
-    *out_card = card;
-    *out_pdrv = pdrv;
-    *out_dup_path = dup_path;
-    return ESP_OK;
-cleanup:
-    free(card);
-    free(dup_path);
-    return err;
-}
-
-static esp_err_t s_f_mount_mh(sdmmc_card_t *card, FATFS *fs, const char *drv, uint8_t pdrv, const esp_vfs_fat_mount_config_t *mount_config)
-{
-    esp_err_t err = ESP_OK;
-    FRESULT res = f_mount(fs, drv, 1);
-    if (res != FR_OK) {
-        err = ESP_FAIL;
-        ESP_LOGW(TAG, "failed to mount card (%d)", res);
-
-        bool need_mount_again = (res == FR_NO_FILESYSTEM || res == FR_INT_ERR) && mount_config->format_if_mount_failed;
-
-        if (!need_mount_again) {
-            return ESP_FAIL;
-        }
-
-        err = partition_card_mh(mount_config, drv, card, pdrv);
-
-        if (err != ESP_OK) {
-            return err;
-        }
-
-        ESP_LOGW(TAG, "mounting again");
-        res = f_mount(fs, drv, 0);
-
-        if (res != FR_OK) {
-            err = ESP_FAIL;
-            ESP_LOGD(TAG, "f_mount failed after formatting (%d)", res);
-            return err;
-        }
-    }
-
-    return ESP_OK;
-}
-
-static esp_err_t mount_to_vfs_fat_mh(const esp_vfs_fat_mount_config_t *mount_config, sdmmc_card_t *card, uint8_t pdrv, const char *base_path, FATFS **out_fs)
-{
-    FATFS *fs = NULL;
-    esp_err_t err;
-    ff_diskio_register_sdmmc_mh(pdrv, card);
-    ff_sdmmc_set_disk_status_check_mh(pdrv, mount_config->disk_status_check_enable);
-    ESP_LOGD(TAG, "using pdrv=%i", pdrv);
-    char drv[3] = {(char)('0' + pdrv), ':', 0};
-
-    // connect FATFS to VFS
-    err = esp_vfs_fat_register(base_path, drv, mount_config->max_files, &fs);
-    *out_fs = fs;
-
-    if (err == ESP_ERR_INVALID_STATE) {
-        // it's okay, already registered with VFS
-    } else if (err != ESP_OK) {
-        ESP_LOGD(TAG, "esp_vfs_fat_register failed 0x(%x)", err);
-        goto fail;
-    }
-
-    // Try to mount partition
-    err = s_f_mount_mh(card, fs, drv, pdrv, mount_config);
-
-    if (err != ESP_OK) {
-        goto fail;
-    }
-    return ESP_OK;
-
-fail:
-    if (fs) {
-        f_mount(NULL, drv, 0);
-    }
-    esp_vfs_fat_unregister_path(base_path);
-    ff_diskio_unregister(pdrv);
-    return err;
-}
-
-static esp_err_t partition_card_mh(const esp_vfs_fat_mount_config_t *mount_config, const char *drv, sdmmc_card_t *card, BYTE pdrv)
-{
-    FRESULT res = FR_OK;
-    esp_err_t err;
-    const size_t workbuf_size = 4096;
-    void* workbuf = NULL;
-    ESP_LOGW(TAG, "partitioning card");
-
-    workbuf = ff_memalloc(workbuf_size);
-
-    if (workbuf == NULL) {
-        return ESP_ERR_NO_MEM;
-    }
-
-    LBA_t plist[] = {100, 0, 0, 0};
-    res = f_fdisk(pdrv, plist, workbuf);
-
-    if (res != FR_OK) {
-        err = ESP_FAIL;
-        ESP_LOGD(TAG, "f_fdisk failed (%d)", res);
-        goto fail;
-    }
-
-    size_t alloc_unit_size = esp_vfs_fat_get_allocation_unit_size(card->csd.sector_size, mount_config->allocation_unit_size);
-
-    ESP_LOGW(TAG, "formatting card, allocation unit size=%d", alloc_unit_size);
-    const MKFS_PARM opt = {(BYTE)FM_ANY, 0, 0, 0, alloc_unit_size};
-    res = f_mkfs(drv, &opt, workbuf, workbuf_size);
-
-    if (res != FR_OK) {
-        err = ESP_FAIL;
-        ESP_LOGD(TAG, "f_mkfs failed (%d)", res);
-        goto fail;
-    }
-
-    free(workbuf);
-    return ESP_OK;
-fail:
-    free(workbuf);
-    return err;
-}
-
-#if SOC_SDMMC_HOST_SUPPORTED
-static esp_err_t init_sdmmc_host_mh(int slot, const void *slot_config, int *out_slot)
-{
-    *out_slot = slot;
-    return sdmmc_host_init_slot(slot, (const sdmmc_slot_config_t*) slot_config);
-}
-
-esp_err_t esp_vfs_fat_sdmmc_mount_mh(const char* base_path, const sdmmc_host_t* host_config, const void* slot_config, const esp_vfs_fat_mount_config_t* mount_config, sdmmc_card_t** out_card)
-{
-    esp_err_t err;
-    mh_vfs_fat_sd_ctx_t *ctx = NULL;
-    uint32_t ctx_id = FF_VOLUMES;
-    FATFS *fs = NULL;
-    int card_handle = -1;   //uninitialized
-    sdmmc_card_t* card = NULL;
-    BYTE pdrv = FF_DRV_NOT_USED;
-    char* dup_path = NULL;
-    bool host_inited = false;
-
-    err = mount_prepare_mem_mh(base_path, &pdrv, &dup_path, &card);
-
-    if (err != ESP_OK) {
-        ESP_LOGE(TAG, "mount_prepare failed");
-        return err;
-    }
-
-    err = (*host_config->init)();
-    CHECK_EXECUTE_RESULT(err, "host init failed");
-    //deinit() needs to be called to revert the init
-    host_inited = true;
-    //If this failed (indicated by card_handle != -1), slot deinit needs to called()
-    //leave card_handle as is to indicate that (though slot deinit not implemented yet.
-    err = init_sdmmc_host_mh(host_config->slot, slot_config, &card_handle);
-    CHECK_EXECUTE_RESULT(err, "slot init failed");
-
-    // probe and initialize card
-    err = sdmmc_card_init(host_config, card);
-    CHECK_EXECUTE_RESULT(err, "sdmmc_card_init failed");
-
-    err = mount_to_vfs_fat_mh(mount_config, card, pdrv, dup_path, &fs);
-    CHECK_EXECUTE_RESULT(err, "mount_to_vfs failed");
-
-    if (out_card != NULL) {
-        *out_card = card;
-    }
-
-    //For deprecation backward compatibility
-    if (s_saved_ctx_id == FF_VOLUMES) {
-        s_saved_ctx_id = 0;
-    }
-
-    ctx = calloc(sizeof(mh_vfs_fat_sd_ctx_t), 1);
-
-    if (!ctx) {
-        CHECK_EXECUTE_RESULT(ESP_ERR_NO_MEM, "no mem");
-    }
-
-    ctx->pdrv = pdrv;
-    memcpy(&ctx->mount_config, mount_config, sizeof(esp_vfs_fat_mount_config_t));
-    ctx->card = card;
-    ctx->base_path = dup_path;
-    ctx->fs = fs;
-    ctx_id = s_get_unused_context_id_mh();
-    assert(ctx_id != FF_VOLUMES);
-    s_ctx[ctx_id] = ctx;
-
-    return ESP_OK;
-cleanup:
-    if (host_inited) {
-        call_host_deinit_mh(host_config);
-    }
-
-    free(card);
-    free(dup_path);
-    return err;
-}
-#endif
-
-static esp_err_t init_sdspi_host_mh(int slot, const void *slot_config, int *out_slot)
-{
-    esp_err_t err = sdspi_host_init_device((const sdspi_device_config_t*)slot_config, out_slot);
-    if (err != ESP_OK) {
-        ESP_LOGE(TAG,
-"Failed to attach sdspi device onto an SPI bus (rc=0x%x), please initialize the \
-bus first and check the device parameters."
-            , err);
-    }
-    return err;
-}
-
-esp_err_t esp_vfs_fat_sdspi_mount_mh(const char* base_path, const sdmmc_host_t* host_config_input, const sdspi_device_config_t* slot_config, const esp_vfs_fat_mount_config_t* mount_config, sdmmc_card_t** out_card)
-{
-    const sdmmc_host_t* host_config = host_config_input;
-    esp_err_t err;
-    mh_vfs_fat_sd_ctx_t *ctx = NULL;
-    uint32_t ctx_id = FF_VOLUMES;
-    FATFS *fs = NULL;
-    int card_handle = -1;   //uninitialized
-    bool host_inited = false;
-    BYTE pdrv = FF_DRV_NOT_USED;
-    sdmmc_card_t* card = NULL;
-    char* dup_path = NULL;
-
-    err = mount_prepare_mem_mh(base_path, &pdrv, &dup_path, &card);
-    if (err != ESP_OK) {
-        ESP_LOGE(TAG, "mount_prepare failed");
-        return err;
-    }
-
-    //the init() function is usually empty, doesn't require any deinit to revert it
-    err = (*host_config->init)();
-    CHECK_EXECUTE_RESULT(err, "host init failed");
-
-    err = init_sdspi_host_mh(host_config->slot, slot_config, &card_handle);
-    CHECK_EXECUTE_RESULT(err, "slot init failed");
-    //Set `host_inited` to true to indicate that host_config->deinit() needs
-    //to be called to revert `init_sdspi_host`
-    host_inited = true;
-
-    //The `slot` argument inside host_config should be replaced by the SD SPI handled returned
-    //above. But the input pointer is const, so create a new variable.
-
-    sdmmc_host_t new_config;
-
-    if (card_handle != host_config->slot) {
-        new_config = *host_config_input;
-        host_config = &new_config;
-        new_config.slot = card_handle;
-    }
-
-    // probe and initialize card
-    err = sdmmc_card_init(host_config, card);
-    CHECK_EXECUTE_RESULT(err, "sdmmc_card_init failed");
-
-    err = mount_to_vfs_fat_mh(mount_config, card, pdrv, dup_path, &fs);
-    CHECK_EXECUTE_RESULT(err, "mount_to_vfs failed");
-
-    if (out_card != NULL) {
-        *out_card = card;
-    }
-
-    //For deprecation backward compatibility
-    if (s_saved_ctx_id == FF_VOLUMES) {
-        s_saved_ctx_id = 0;
-    }
-
-    ctx = calloc(sizeof(mh_vfs_fat_sd_ctx_t), 1);
-
-    if (!ctx) {
-        CHECK_EXECUTE_RESULT(ESP_ERR_NO_MEM, "no mem");
-    }
-
-    ctx->pdrv = pdrv;
-    memcpy(&ctx->mount_config, mount_config, sizeof(esp_vfs_fat_mount_config_t));
-    ctx->card = card;
-    ctx->base_path = dup_path;
-    ctx->fs = fs;
-    ctx_id = s_get_unused_context_id_mh();
-    assert(ctx_id != FF_VOLUMES);
-    s_ctx[ctx_id] = ctx;
-
-    return ESP_OK;
-
-cleanup:
-    if (host_inited) {
-        call_host_deinit_mh(host_config);
-    }
-
-    free(card);
-    free(dup_path);
-    return err;
-}
-
-static void call_host_deinit_mh(const sdmmc_host_t *host_config)
-{
-    if (host_config->flags & SDMMC_HOST_FLAG_DEINIT_ARG) {
-        host_config->deinit_p(host_config->slot);
-    } else {
-        host_config->deinit();
-    }
-}
-
-static esp_err_t unmount_card_core_mh(const char *base_path, sdmmc_card_t *card)
-{
-    BYTE pdrv = ff_diskio_get_pdrv_card_mh(card);
-
-    if (pdrv == 0xff) {
-        return ESP_ERR_INVALID_ARG;
-    }
-
-    // unmount
-    char drv[3] = {(char)('0' + pdrv), ':', 0};
-    f_mount(0, drv, 0);
-    // release SD driver
-    ff_diskio_unregister(pdrv);
-
-    call_host_deinit_mh(&card->host);
-    free(card);
-
-    esp_err_t err = esp_vfs_fat_unregister_path(base_path);
-    return err;
-}
-
-esp_err_t esp_vfs_fat_sdmmc_unmount_mh(void)
-{
-    esp_err_t err = unmount_card_core_mh(s_ctx[s_saved_ctx_id]->base_path, s_ctx[s_saved_ctx_id]->card);
-    free(s_ctx[s_saved_ctx_id]);
-    s_ctx[s_saved_ctx_id] = NULL;
-    s_saved_ctx_id = FF_VOLUMES;
-    return err;
-}
-
-esp_err_t esp_vfs_fat_sdcard_unmount_mh(const char *base_path, sdmmc_card_t *card)
-{
-    uint32_t id = FF_VOLUMES;
-    bool found = s_get_context_id_by_card_mh(card, &id);
-
-    if (!found) {
-        return ESP_ERR_INVALID_ARG;
-    }
-
-    free(s_ctx[id]);
-    s_ctx[id] = NULL;
-
-    esp_err_t err = unmount_card_core_mh(base_path, card);
-
-    return err;
-}
-
-esp_err_t esp_vfs_fat_sdcard_format_mh(const char *base_path, sdmmc_card_t *card)
-{
-    esp_err_t ret = ESP_OK;
-
-    if (!card) {
-        ESP_LOGE(TAG, "card not initialized");
-        return ESP_ERR_INVALID_STATE;
-    }
-
-    BYTE pdrv = ff_diskio_get_pdrv_card_mh(card);
-
-    if (pdrv == 0xff) {
-        ESP_LOGE(TAG, "card driver not registered");
-        return ESP_ERR_INVALID_STATE;
-    }
-
-    const size_t workbuf_size = 4096;
-    void *workbuf = ff_memalloc(workbuf_size);
-
-    if (workbuf == NULL) {
-        return ESP_ERR_NO_MEM;
-    }
-
-    //unmount
-    char drv[3] = {(char)('0' + pdrv), ':', 0};
-    f_mount(0, drv, 0);
-
-    //format
-    uint32_t id = FF_VOLUMES;
-    bool found = s_get_context_id_by_card_mh(card, &id);
-    assert(found);
-    size_t alloc_unit_size = esp_vfs_fat_get_allocation_unit_size(card->csd.sector_size, s_ctx[id]->mount_config.allocation_unit_size);
-    ESP_LOGI(TAG, "Formatting card, allocation unit size=%d", alloc_unit_size);
-    const MKFS_PARM opt = {(BYTE)FM_ANY, 0, 0, 0, alloc_unit_size};
-    FRESULT res = f_mkfs(drv, &opt, workbuf, workbuf_size);
-    free(workbuf);
-
-    if (res != FR_OK) {
-        ret = ESP_FAIL;
-        ESP_LOGD(TAG, "f_mkfs failed (%d)", res);
-    }
-
-    //mount back
-    esp_err_t err = s_f_mount_mh(card, s_ctx[id]->fs, drv, pdrv, &s_ctx[id]->mount_config);
-
-    if (err != ESP_OK) {
-        unmount_card_core_mh(base_path, card);
-        ESP_LOGE(TAG, "failed to format, resources recycled, please mount again");
-    }
-
-    return ret;
-}

code/components/jomjol_helper/sdcard_init.h

@@ -1,111 +0,0 @@
-/*
- * SPDX-FileCopyrightText: 2015-2022 Espressif Systems (Shanghai) CO LTD
- *
- * SPDX-License-Identifier: Apache-2.0
- */
-
-#pragma once
-
-#include <stddef.h>
-#include "esp_err.h"
-#include "driver/gpio.h"
-#include "sdmmc_cmd.h"
-#include "driver/sdmmc_types.h"
-#include "driver/sdspi_host.h"
-#include "ff.h"
-#include "esp_vfs_fat.h"
-#include "wear_levelling.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- * @brief Convenience function to get FAT filesystem on SD card registered in VFS
- *
- * This is an all-in-one function which does the following:
- * - initializes SDMMC driver or SPI driver with configuration in host_config
- * - initializes SD card with configuration in slot_config
- * - mounts FAT partition on SD card using FATFS library, with configuration in mount_config
- * - registers FATFS library with VFS, with prefix given by base_prefix variable
- *
- * This function is intended to make example code more compact.
- * For real world applications, developers should implement the logic of
- * probing SD card, locating and mounting partition, and registering FATFS in VFS,
- * with proper error checking and handling of exceptional conditions.
- *
- * @note Use this API to mount a card through SDSPI is deprecated. Please call
- *       `esp_vfs_fat_sdspi_mount()` instead for that case.
- *
- * @param base_path     path where partition should be registered (e.g. "/sdcard")
- * @param host_config   Pointer to structure describing SDMMC host. When using
- *                      SDMMC peripheral, this structure can be initialized using
- *                      SDMMC_HOST_DEFAULT() macro. When using SPI peripheral,
- *                      this structure can be initialized using SDSPI_HOST_DEFAULT()
- *                      macro.
- * @param slot_config   Pointer to structure with slot configuration.
- *                      For SDMMC peripheral, pass a pointer to sdmmc_slot_config_t
- *                      structure initialized using SDMMC_SLOT_CONFIG_DEFAULT.
- * @param mount_config  pointer to structure with extra parameters for mounting FATFS
- * @param[out] out_card  if not NULL, pointer to the card information structure will be returned via this argument
- * @return
- *      - ESP_OK on success
- *      - ESP_ERR_INVALID_STATE if esp_vfs_fat_sdmmc_mount was already called
- *      - ESP_ERR_NO_MEM if memory can not be allocated
- *      - ESP_FAIL if partition can not be mounted
- *      - other error codes from SDMMC or SPI drivers, SDMMC protocol, or FATFS drivers
- */
-esp_err_t esp_vfs_fat_sdmmc_mount_mh(const char* base_path, const sdmmc_host_t* host_config, const void* slot_config, const esp_vfs_fat_mount_config_t* mount_config, sdmmc_card_t** out_card);
-
-/**
- * @brief Convenience function to get FAT filesystem on SD card registered in VFS
- *
- * This is an all-in-one function which does the following:
- * - initializes an SPI Master device based on the SPI Master driver with configuration in
- *   slot_config, and attach it to an initialized SPI bus.
- * - initializes SD card with configuration in host_config_input
- * - mounts FAT partition on SD card using FATFS library, with configuration in mount_config
- * - registers FATFS library with VFS, with prefix given by base_prefix variable
- *
- * This function is intended to make example code more compact.
- * For real world applications, developers should implement the logic of
- * probing SD card, locating and mounting partition, and registering FATFS in VFS,
- * with proper error checking and handling of exceptional conditions.
- *
- * @note This function try to attach the new SD SPI device to the bus specified in host_config.
- *       Make sure the SPI bus specified in `host_config->slot` have been initialized by
- *       `spi_bus_initialize()` before.
- *
- * @param base_path     path where partition should be registered (e.g. "/sdcard")
- * @param host_config_input Pointer to structure describing SDMMC host. This structure can be
- *                          initialized using SDSPI_HOST_DEFAULT() macro.
- * @param slot_config   Pointer to structure with slot configuration.
- *                      For SPI peripheral, pass a pointer to sdspi_device_config_t
- *                      structure initialized using SDSPI_DEVICE_CONFIG_DEFAULT().
- * @param mount_config  pointer to structure with extra parameters for mounting FATFS
- * @param[out] out_card If not NULL, pointer to the card information structure will be returned via
- *                      this argument. It is suggested to hold this handle and use it to unmount the card later if
- *                      needed. Otherwise it's not suggested to use more than one card at the same time and unmount one
- *                      of them in your application.
- * @return
- *      - ESP_OK on success
- *      - ESP_ERR_INVALID_STATE if esp_vfs_fat_sdmmc_mount was already called
- *      - ESP_ERR_NO_MEM if memory can not be allocated
- *      - ESP_FAIL if partition can not be mounted
- *      - other error codes from SDMMC or SPI drivers, SDMMC protocol, or FATFS drivers
- */
-esp_err_t esp_vfs_fat_sdspi_mount_mh(const char* base_path, const sdmmc_host_t* host_config_input, const sdspi_device_config_t* slot_config, const esp_vfs_fat_mount_config_t* mount_config, sdmmc_card_t** out_card);
-
-#ifdef __cplusplus
-}
-#endif
-
-
-
-
-
-
-
-
-
-