Initial Code v0.1.0

code/lib/jomjol_fileserver_ota/server_file.cpp

@@ -0,0 +1,539 @@
+/* HTTP File Server Example
+
+   This example code is in the Public Domain (or CC0 licensed, at your option.)
+
+   Unless required by applicable law or agreed to in writing, this
+   software is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+   CONDITIONS OF ANY KIND, either express or implied.
+*/
+
+
+#include "server_file.h"
+
+
+#include <stdio.h>
+#include <string.h>
+#include <string>
+#include <sys/param.h>
+#include <sys/unistd.h>
+#include <sys/stat.h>
+#include <dirent.h>
+
+#include "esp_err.h"
+#include "esp_log.h"
+
+#include "esp_vfs.h"
+#include "esp_spiffs.h"
+#include "esp_http_server.h"
+
+#include "ClassLogFile.h"
+
+#include "server_help.h"
+
+/* Max length a file path can have on storage */
+// #define FILE_PATH_MAX (ESP_VFS_PATH_MAX + CONFIG_SPIFFS_OBJ_NAME_LEN)
+#define FILE_PATH_MAX (255)
+
+/* Max size of an individual file. Make sure this
+ * value is same as that set in upload_script.html */
+#define MAX_FILE_SIZE   (2000*1024) // 200 KB
+#define MAX_FILE_SIZE_STR "2000KB"
+
+/* Scratch buffer size */
+#define SCRATCH_BUFSIZE  8192 
+
+struct file_server_data {
+    /* Base path of file storage */
+    char base_path[ESP_VFS_PATH_MAX + 1];
+
+    /* Scratch buffer for temporary storage during file transfer */
+    char scratch[SCRATCH_BUFSIZE];
+};
+
+static const char *TAG = "file_server";
+
+/* Handler to redirect incoming GET request for /index.html to /
+ * This can be overridden by uploading file with same name */
+static esp_err_t index_html_get_handler(httpd_req_t *req)
+{
+    httpd_resp_set_status(req, "307 Temporary Redirect");
+    httpd_resp_set_hdr(req, "Location", "/");
+    httpd_resp_send(req, NULL, 0);  // Response body can be empty
+    return ESP_OK;
+}
+
+/* Handler to respond with an icon file embedded in flash.
+ * Browsers expect to GET website icon at URI /favicon.ico.
+ * This can be overridden by uploading file with same name */
+static esp_err_t favicon_get_handler(httpd_req_t *req)
+{
+    extern const unsigned char favicon_ico_start[] asm("_binary_favicon_ico_start");
+    extern const unsigned char favicon_ico_end[]   asm("_binary_favicon_ico_end");
+    const size_t favicon_ico_size = (favicon_ico_end - favicon_ico_start);
+    httpd_resp_set_type(req, "image/x-icon");
+    httpd_resp_send(req, (const char *)favicon_ico_start, favicon_ico_size);
+    /* Respond with an empty chunk to signal HTTP response completion */
+    httpd_resp_send_chunk(req, NULL, 0);       
+    return ESP_OK;
+}
+
+/* Send HTTP response with a run-time generated html consisting of
+ * a list of all files and folders under the requested path.
+ * In case of SPIFFS this returns empty list when path is any
+ * string other than '/', since SPIFFS doesn't support directories */
+static esp_err_t http_resp_dir_html(httpd_req_t *req, const char *dirpath)
+{
+    char entrypath[FILE_PATH_MAX];
+    char entrysize[16];
+    const char *entrytype;
+
+    struct dirent *entry;
+    struct stat entry_stat;
+
+    char dirpath_corrected[FILE_PATH_MAX];
+    strcpy(dirpath_corrected, dirpath);
+
+    file_server_data * server_data = (file_server_data *) req->user_ctx;
+    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';
+
+    DIR *dir = opendir(dirpath_corrected);
+
+    const size_t dirpath_len = strlen(dirpath);
+    printf("Dirpath: <%s>, Pathlength: %d\n", dirpath, dirpath_len);    
+
+    /* Retrieve the base path of file storage to construct the full path */
+    strlcpy(entrypath, dirpath, sizeof(entrypath));
+    printf("entrypath: <%s>\n", entrypath);    
+
+    if (!dir) {
+        ESP_LOGE(TAG, "Failed to stat dir : %s", dirpath);
+        /* Respond with 404 Not Found */
+        httpd_resp_send_err(req, HTTPD_404_NOT_FOUND, "Directory does not exist");
+        return ESP_FAIL;
+    }
+
+    /* Send HTML file header */
+    httpd_resp_sendstr_chunk(req, "<!DOCTYPE html><html><body>");
+
+    /* Get handle to embedded file upload script */
+    extern const unsigned char upload_script_start[] asm("_binary_upload_script_html_start");
+    extern const unsigned char upload_script_end[]   asm("_binary_upload_script_html_end");
+    const size_t upload_script_size = (upload_script_end - upload_script_start);
+
+    /* Add file upload form and script which on execution sends a POST request to /upload */
+    httpd_resp_send_chunk(req, (const char *)upload_script_start, upload_script_size);
+
+
+/////////////////////////////////////////////////
+/*
+    FILE *fd = fopen("/sdcard/html/file_server_upload_script.html", "r");
+    char *chunk = ((struct file_server_data *)req->user_ctx)->scratch;
+    size_t chunksize;
+    do {
+        chunksize = fread(chunk, 1, SCRATCH_BUFSIZE, fd);
+        if (httpd_resp_send_chunk(req, chunk, chunksize) != ESP_OK) {
+            fclose(fd);
+            ESP_LOGE(TAG, "File sending failed!");
+            return ESP_FAIL;
+        }
+    } while (chunksize != 0);
+    fclose(fd);
+    ESP_LOGI(TAG, "File sending complete");
+    httpd_resp_send_chunk(req, NULL, 0);
+*/
+///////////////////////////////
+
+
+    /* Send file-list table definition and column labels */
+    httpd_resp_sendstr_chunk(req,
+        "<table class=\"fixed\" border=\"1\">"
+        "<col width=\"800px\" /><col width=\"300px\" /><col width=\"300px\" /><col width=\"100px\" />"
+        "<thead><tr><th>Name</th><th>Type</th><th>Size (Bytes)</th><th>Delete</th></tr></thead>"
+        "<tbody>");
+
+    /* Iterate over all files / folders and fetch their names and sizes */
+    while ((entry = readdir(dir)) != NULL) {
+        entrytype = (entry->d_type == DT_DIR ? "directory" : "file");
+
+        strlcpy(entrypath + dirpath_len, entry->d_name, sizeof(entrypath) - dirpath_len);
+        printf("Entrypath: %s\n", entrypath);
+        if (stat(entrypath, &entry_stat) == -1) {
+            ESP_LOGE(TAG, "Failed to stat %s : %s", entrytype, entry->d_name);
+            continue;
+        }
+        sprintf(entrysize, "%ld", entry_stat.st_size);
+        ESP_LOGI(TAG, "Found %s : %s (%s bytes)", entrytype, entry->d_name, entrysize);
+
+        /* Send chunk of HTML file containing table entries with file name and size */
+        httpd_resp_sendstr_chunk(req, "<tr><td><a href=\"");
+        httpd_resp_sendstr_chunk(req, req->uri);
+        httpd_resp_sendstr_chunk(req, entry->d_name);
+        if (entry->d_type == DT_DIR) {
+            httpd_resp_sendstr_chunk(req, "/");
+        }
+        httpd_resp_sendstr_chunk(req, "\">");
+        httpd_resp_sendstr_chunk(req, entry->d_name);
+        httpd_resp_sendstr_chunk(req, "</a></td><td>");
+        httpd_resp_sendstr_chunk(req, entrytype);
+        httpd_resp_sendstr_chunk(req, "</td><td>");
+        httpd_resp_sendstr_chunk(req, entrysize);
+        httpd_resp_sendstr_chunk(req, "</td><td>");
+        httpd_resp_sendstr_chunk(req, "<form method=\"post\" action=\"/delete");
+        httpd_resp_sendstr_chunk(req, req->uri + strlen("/fileserver"));
+        httpd_resp_sendstr_chunk(req, entry->d_name);
+        httpd_resp_sendstr_chunk(req, "\"><button type=\"submit\">Delete</button></form>");
+        httpd_resp_sendstr_chunk(req, "</td></tr>\n");
+    }
+    closedir(dir);
+
+    /* Finish the file list table */
+    httpd_resp_sendstr_chunk(req, "</tbody></table>");
+
+    /* Send remaining chunk of HTML file to complete it */
+    httpd_resp_sendstr_chunk(req, "</body></html>");
+
+    /* Send empty chunk to signal HTTP response completion */
+    httpd_resp_sendstr_chunk(req, NULL);
+    return ESP_OK;
+}
+
+#define IS_FILE_EXT(filename, ext) \
+    (strcasecmp(&filename[strlen(filename) - sizeof(ext) + 1], ext) == 0)
+
+
+/* Handler to download a file kept on the server */
+static esp_err_t download_get_handler(httpd_req_t *req)
+{
+    LogFile.WriteToFile("download_get_handler");
+    char filepath[FILE_PATH_MAX];
+    FILE *fd = NULL;
+    struct stat file_stat;
+    printf("uri: %s\n", 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));    
+
+    printf("1 uri: %s, filename: %s, filepath: %s\n", req->uri, filename, filepath);
+
+//    filename = get_path_from_uri(filepath, ((struct file_server_data *)req->user_ctx)->base_path,
+//                                             req->uri, sizeof(filepath));
+
+    if (!filename) {
+        ESP_LOGE(TAG, "Filename is too long");
+        /* Respond with 500 Internal Server Error */
+        httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "Filename too long");
+        return ESP_FAIL;
+    }
+
+    /* If name has trailing '/', respond with directory contents */
+    if (filename[strlen(filename) - 1] == '/') {
+        return http_resp_dir_html(req, filepath);
+    }
+
+    if (stat(filepath, &file_stat) == -1) {
+        /* If file not present on SPIFFS check if URI
+         * corresponds to one of the hardcoded paths */
+        ESP_LOGE(TAG, "Failed to stat file : %s", filepath);
+        /* Respond with 404 Not Found */
+        httpd_resp_send_err(req, HTTPD_404_NOT_FOUND, "File does not exist");
+        return ESP_FAIL;
+    }
+
+    fd = fopen(filepath, "r");
+    if (!fd) {
+        ESP_LOGE(TAG, "Failed to read existing file : %s", filepath);
+        /* Respond with 500 Internal Server Error */
+        httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "Failed to read existing file");
+        return ESP_FAIL;
+    }
+
+    ESP_LOGI(TAG, "Sending file : %s (%ld bytes)...", filename, file_stat.st_size);
+    set_content_type_from_file(req, filename);
+
+    /* Retrieve the pointer to scratch buffer for temporary storage */
+    char *chunk = ((struct file_server_data *)req->user_ctx)->scratch;
+    size_t chunksize;
+    do {
+        /* Read file in chunks into the scratch buffer */
+        chunksize = fread(chunk, 1, SCRATCH_BUFSIZE, fd);
+
+        /* Send the buffer contents as HTTP response chunk */
+        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;
+        }
+
+        /* Keep looping till the whole file is sent */
+    } while (chunksize != 0);
+
+    /* Close file after sending complete */
+    fclose(fd);
+    ESP_LOGI(TAG, "File sending complete");
+
+    /* Respond with an empty chunk to signal HTTP response completion */
+    httpd_resp_send_chunk(req, NULL, 0);
+    return ESP_OK;
+}
+
+/* Handler to upload a file onto the server */
+static esp_err_t upload_post_handler(httpd_req_t *req)
+{
+    LogFile.WriteToFile("upload_post_handler");
+    char filepath[FILE_PATH_MAX];
+    FILE *fd = NULL;
+    struct stat file_stat;
+
+    /* Skip leading "/upload" 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("/upload") - 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] == '/') {
+        ESP_LOGE(TAG, "Invalid filename : %s", filename);
+        httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "Invalid filename");
+        return ESP_FAIL;
+    }
+
+    if (stat(filepath, &file_stat) == 0) {
+        ESP_LOGE(TAG, "File already exists : %s", filepath);
+        /* Respond with 400 Bad Request */
+        httpd_resp_send_err(req, HTTPD_400_BAD_REQUEST, "File already exists");
+        return ESP_FAIL;
+    }
+
+    /* File cannot be larger than a limit */
+    if (req->content_len > MAX_FILE_SIZE) {
+        ESP_LOGE(TAG, "File too large : %d bytes", req->content_len);
+        /* Respond with 400 Bad Request */
+        httpd_resp_send_err(req, HTTPD_400_BAD_REQUEST,
+                            "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) {
+        ESP_LOGE(TAG, "Failed to create file : %s", filepath);
+        /* Respond with 500 Internal Server Error */
+        httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "Failed to create file");
+        return ESP_FAIL;
+    }
+
+    ESP_LOGI(TAG, "Receiving file : %s...", filename);
+
+    /* Retrieve the pointer to scratch buffer for temporary storage */
+    char *buf = ((struct file_server_data *)req->user_ctx)->scratch;
+    int received;
+
+    /* Content length of the request gives
+     * the size of the file being uploaded */
+    int remaining = req->content_len;
+
+    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, SCRATCH_BUFSIZE))) <= 0) {
+            if (received == HTTPD_SOCK_ERR_TIMEOUT) {
+                /* Retry if timeout occurred */
+                continue;
+            }
+
+            /* In case of unrecoverable error,
+             * close and delete the unfinished file*/
+            fclose(fd);
+            unlink(filepath);
+
+            ESP_LOGE(TAG, "File reception failed!");
+            /* Respond with 500 Internal Server Error */
+            httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "Failed to receive file");
+            return ESP_FAIL;
+        }
+
+        /* Write buffer content to file on storage */
+        if (received && (received != fwrite(buf, 1, received, fd))) {
+            /* Couldn't write everything to file!
+             * Storage may be full? */
+            fclose(fd);
+            unlink(filepath);
+
+            ESP_LOGE(TAG, "File write failed!");
+            /* Respond with 500 Internal Server Error */
+            httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "Failed to write file to storage");
+            return ESP_FAIL;
+        }
+
+        /* Keep track of remaining size of
+         * the file left to be uploaded */
+        remaining -= received;
+    }
+
+    /* Close file upon upload completion */
+    fclose(fd);
+    ESP_LOGI(TAG, "File reception complete");
+
+    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);  
+		if (zw != std::string::npos)
+			found = zw;
+	}
+
+    int start_fn = strlen(((struct file_server_data *)req->user_ctx)->base_path);
+    printf("Directory: %s, start_fn: %d, found: %d\n", directory.c_str(), start_fn, found);
+	directory = directory.substr(start_fn, found - start_fn + 1);
+    printf("Directory danach: %s\n", directory.c_str());    
+
+    directory = "/fileserver" + directory;
+    printf("Directory danach: %s\n", 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());
+
+    /* 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 uploaded successfully");
+    return ESP_OK;
+}
+
+/* Handler to delete a file from the server */
+static esp_err_t delete_post_handler(httpd_req_t *req)
+{
+    LogFile.WriteToFile("delete_post_handler");
+    char filepath[FILE_PATH_MAX];
+    struct stat file_stat;
+
+
+    /* 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) {
+        /* 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] == '/') {
+        ESP_LOGE(TAG, "Invalid filename : %s", filename);
+        httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "Invalid filename");
+        return ESP_FAIL;
+    }
+
+    if (stat(filepath, &file_stat) == -1) {
+        ESP_LOGE(TAG, "File does not exist : %s", filename);
+        /* Respond with 400 Bad Request */
+        httpd_resp_send_err(req, HTTPD_400_BAD_REQUEST, "File does not exist");
+        return ESP_FAIL;
+    }
+
+    ESP_LOGI(TAG, "Deleting file : %s", filename);
+    /* Delete file */
+    unlink(filepath);
+
+    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);  
+		if (zw != std::string::npos)
+			found = zw;
+	}
+
+    int start_fn = strlen(((struct file_server_data *)req->user_ctx)->base_path);
+    printf("Directory: %s, start_fn: %d, found: %d\n", directory.c_str(), start_fn, found);
+	directory = directory.substr(start_fn, found - start_fn + 1);
+    printf("Directory danach: %s\n", directory.c_str());    
+
+    directory = "/fileserver" + directory;
+    printf("Directory danach: %s\n", 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;
+}
+
+
+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) {
+        ESP_LOGE(TAG, "File server base_path not set");
+//        return ESP_ERR_INVALID_ARG;
+    }
+
+    if (server_data) {
+        ESP_LOGE(TAG, "File server already started");
+//        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) {
+        ESP_LOGE(TAG, "Failed to allocate memory for server data");
+//        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';    
+//    printf("zw: %s\n", zw);
+    httpd_uri_t file_download = {
+        .uri       = "/fileserver*",  // Match all URIs of type /path/to/file
+        .method    = HTTP_GET,
+        .handler   = download_get_handler,
+        .user_ctx  = server_data    // Pass server data as context
+    };
+    httpd_register_uri_handler(server, &file_download);
+
+    /* 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,
+        .handler   = upload_post_handler,
+        .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,
+        .handler   = delete_post_handler,
+        .user_ctx  = server_data    // Pass server data as context
+    };
+    httpd_register_uri_handler(server, &file_delete);
+
+}

code/lib/jomjol_fileserver_ota/server_file.h

@@ -0,0 +1,3 @@
+#include <esp_http_server.h>
+
+void register_server_file_uri(httpd_handle_t server, const char *base_path);

code/lib/jomjol_fileserver_ota/server_ota.cpp

@@ -0,0 +1,408 @@
+#include "server_ota.h"
+
+#include <string>
+#include "string.h"
+
+#include <esp_int_wdt.h>
+#include <esp_task_wdt.h>
+
+
+#include <string.h>
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "esp_system.h"
+#include "esp_event.h"
+#include "esp_event_loop.h"
+#include "esp_log.h"
+#include "esp_ota_ops.h"
+#include "esp_http_client.h"
+#include "esp_flash_partitions.h"
+#include "esp_partition.h"
+#include "nvs.h"
+#include "nvs_flash.h"
+#include "driver/gpio.h"
+#include "protocol_examples_common.h"
+#include "errno.h"
+
+#include <sys/stat.h>
+
+#include "server_tflite.h"
+
+#include "ClassLogFile.h"
+
+
+
+#define BUFFSIZE 1024
+#define HASH_LEN 32 /* SHA-256 digest length */
+
+
+/*an ota data write buffer ready to write to the flash*/
+static char ota_write_data[BUFFSIZE + 1] = { 0 };
+
+
+#define OTA_URL_SIZE 256
+
+
+static void infinite_loop(void)
+{
+    int i = 0;
+    ESP_LOGI(TAGPARTOTA, "When a new firmware is available on the server, press the reset button to download it");
+    while(1) {
+        ESP_LOGI(TAGPARTOTA, "Waiting for a new firmware ... %d", ++i);
+        vTaskDelay(2000 / portTICK_PERIOD_MS);
+    }
+}
+
+
+
+static bool ota_example_task(std::string fn)
+{
+    esp_err_t err;
+    /* update handle : set by esp_ota_begin(), must be freed via esp_ota_end() */
+    esp_ota_handle_t update_handle = 0 ;
+    const esp_partition_t *update_partition = NULL;
+
+    ESP_LOGI(TAGPARTOTA, "Starting OTA example");
+
+    const esp_partition_t *configured = esp_ota_get_boot_partition();
+    const esp_partition_t *running = esp_ota_get_running_partition();
+
+    if (configured != running) {
+        ESP_LOGW(TAGPARTOTA, "Configured OTA boot partition at offset 0x%08x, but running from offset 0x%08x",
+                 configured->address, running->address);
+        ESP_LOGW(TAGPARTOTA, "(This can happen if either the OTA boot data or preferred boot image become corrupted somehow.)");
+    }
+    ESP_LOGI(TAGPARTOTA, "Running partition type %d subtype %d (offset 0x%08x)",
+             running->type, running->subtype, running->address);
+
+
+    update_partition = esp_ota_get_next_update_partition(NULL);
+    ESP_LOGI(TAGPARTOTA, "Writing to partition subtype %d at offset 0x%x",
+             update_partition->subtype, update_partition->address);
+//    assert(update_partition != NULL);
+
+    int binary_file_length = 0;
+
+    // deal with all receive packet 
+    bool image_header_was_checked = false;
+
+    int data_read;     
+
+    FILE* f = fopen(fn.c_str(), "rb");     // vorher  nur "r"
+    data_read = fread(ota_write_data, 1, BUFFSIZE, f);
+
+    while (data_read > 0) {
+        if (data_read < 0) {
+            ESP_LOGE(TAGPARTOTA, "Error: SSL data read error");
+            return false;
+        } else if (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)) {
+                    // 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(TAGPARTOTA, "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) {
+                        ESP_LOGI(TAGPARTOTA, "Running firmware version: %s", running_app_info.version);
+                    }
+
+                    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) {
+                        ESP_LOGI(TAGPARTOTA, "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) {
+                            ESP_LOGW(TAGPARTOTA, "New version is the same as invalid version.");
+                            ESP_LOGW(TAGPARTOTA, "Previously, there was an attempt to launch the firmware with %s version, but it failed.", invalid_app_info.version);
+                            ESP_LOGW(TAGPARTOTA, "The firmware has been rolled back to the previous version.");
+                            infinite_loop();
+                        }
+                    }
+
+/*
+                    if (memcmp(new_app_info.version, running_app_info.version, sizeof(new_app_info.version)) == 0) {
+                        ESP_LOGW(TAGPARTOTA, "Current running version is the same as a new. We will not continue the update.");
+                        infinite_loop();
+                    }
+*/
+                    image_header_was_checked = true;
+
+                    err = esp_ota_begin(update_partition, OTA_SIZE_UNKNOWN, &update_handle);
+                    if (err != ESP_OK) {
+                        ESP_LOGE(TAGPARTOTA, "esp_ota_begin failed (%s)", esp_err_to_name(err));
+                        return false;
+                    }
+                    ESP_LOGI(TAGPARTOTA, "esp_ota_begin succeeded");
+                } else {
+                    ESP_LOGE(TAGPARTOTA, "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) {
+                return false;
+            }
+            binary_file_length += data_read;
+            ESP_LOGD(TAGPARTOTA, "Written image length %d", binary_file_length);
+        } else if (data_read == 0) {
+           //
+           // * As esp_http_client_read never returns negative error code, we rely on
+           // * `errno` to check for underlying transport connectivity closure if any
+           //
+            if (errno == ECONNRESET || errno == ENOTCONN) {
+                ESP_LOGE(TAGPARTOTA, "Connection closed, errno = %d", errno);
+                break;
+            }
+        }
+        data_read = fread(ota_write_data, 1, BUFFSIZE, f);
+    }
+    fclose(f);  
+
+    ESP_LOGI(TAGPARTOTA, "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) {
+            ESP_LOGE(TAGPARTOTA, "Image validation failed, image is corrupted");
+        }
+        ESP_LOGE(TAGPARTOTA, "esp_ota_end failed (%s)!", esp_err_to_name(err));
+        return false;
+    }
+
+    err = esp_ota_set_boot_partition(update_partition);
+    if (err != ESP_OK) {
+        ESP_LOGE(TAGPARTOTA, "esp_ota_set_boot_partition failed (%s)!", esp_err_to_name(err));
+
+    }
+//    ESP_LOGI(TAGPARTOTA, "Prepare to restart system!");
+//    esp_restart();
+
+    return true ;
+}
+
+
+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) {
+        sprintf(&hash_print[i * 2], "%02x", image_hash[i]);
+    }
+    ESP_LOGI(TAGPARTOTA, "%s: %s", label, hash_print);
+}
+
+
+static bool diagnostic(void)
+{
+/*
+    gpio_config_t io_conf;
+    io_conf.intr_type    = (gpio_int_type_t) GPIO_PIN_INTR_DISABLE;
+    io_conf.mode         = GPIO_MODE_INPUT;
+    io_conf.pin_bit_mask = (1ULL << CONFIG_EXAMPLE_GPIO_DIAGNOSTIC);
+    io_conf.pull_down_en = GPIO_PULLDOWN_DISABLE;
+    io_conf.pull_up_en   = GPIO_PULLUP_ENABLE;
+    gpio_config(&io_conf);
+
+    ESP_LOGI(TAGPARTOTA, "Diagnostics (5 sec)...");
+    vTaskDelay(5000 / portTICK_PERIOD_MS);
+
+    bool diagnostic_is_ok = gpio_get_level(CONFIG_EXAMPLE_GPIO_DIAGNOSTIC);
+
+    gpio_reset_pin(CONFIG_EXAMPLE_GPIO_DIAGNOSTIC);
+
+    return diagnostic_is_ok;
+*/
+    return true;
+}
+
+void CheckOTAUpdate(void)
+{
+    ESP_LOGI(TAGPARTOTA, "Start CheckOTAUpdateCheck ...");
+    printf("Start CheckOTAUpdateCheck ...\n");
+
+    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;
+    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;
+    esp_partition_get_sha256(&partition, sha_256);
+    print_sha256(sha_256, "SHA-256 for bootloader: ");
+
+    // get sha256 digest for running partition
+    esp_partition_get_sha256(esp_ota_get_running_partition(), sha_256);
+    print_sha256(sha_256, "SHA-256 for current firmware: ");
+
+    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:
+            printf("CheckOTAUpdate Partition: ESP_OK\n");
+            if (esp_ota_get_state_partition(running, &ota_state) == ESP_OK) {
+                if (ota_state == ESP_OTA_IMG_PENDING_VERIFY) {
+                    // run diagnostic function ...
+                    bool diagnostic_is_ok = diagnostic();
+                    if (diagnostic_is_ok) {
+                        ESP_LOGI(TAGPARTOTA, "Diagnostics completed successfully! Continuing execution ...");
+                        printf("Diagnostics completed successfully! Continuing execution ...\n");
+                        esp_ota_mark_app_valid_cancel_rollback();
+                    } else {
+                        ESP_LOGE(TAGPARTOTA, "Diagnostics failed! Start rollback to the previous version ...");
+                        printf("Diagnostics failed! Start rollback to the previous version ...\n");
+                        esp_ota_mark_app_invalid_rollback_and_reboot();
+                    }
+                }
+            }            
+            break;
+        case ESP_ERR_INVALID_ARG:
+            printf("CheckOTAUpdate Partition: ESP_ERR_INVALID_ARG\n");
+            break;
+        case ESP_ERR_NOT_SUPPORTED:
+            printf("CheckOTAUpdate Partition: ESP_ERR_NOT_SUPPORTED\n");
+            break;
+        case ESP_ERR_NOT_FOUND:
+            printf("CheckOTAUpdate Partition: ESP_ERR_NOT_FOUND\n");
+            break;
+    }
+    if (esp_ota_get_state_partition(running, &ota_state) == ESP_OK) {
+        if (ota_state == ESP_OTA_IMG_PENDING_VERIFY) {
+            // run diagnostic function ...
+            bool diagnostic_is_ok = diagnostic();
+            if (diagnostic_is_ok) {
+                ESP_LOGI(TAGPARTOTA, "Diagnostics completed successfully! Continuing execution ...");
+                printf("Diagnostics completed successfully! Continuing execution ...\n");
+                esp_ota_mark_app_valid_cancel_rollback();
+            } else {
+                ESP_LOGE(TAGPARTOTA, "Diagnostics failed! Start rollback to the previous version ...");
+                printf("Diagnostics failed! Start rollback to the previous version ...\n");
+                esp_ota_mark_app_invalid_rollback_and_reboot();
+            }
+        }
+    }
+}
+
+
+
+esp_err_t handler_ota_update(httpd_req_t *req)
+{
+    LogFile.WriteToFile("handler_ota_update");    
+    char _query[100];
+    char _filename[30];
+    std::string fn = "/sdcard/firmware/";
+    bool _file_del = false;
+
+    if (httpd_req_get_url_query_str(req, _query, 100) == ESP_OK)
+    {
+        printf("Query: "); printf(_query); printf("\n");
+        if (httpd_query_key_value(_query, "file", _filename, 30) == ESP_OK)
+        {
+            fn.append(_filename);
+            printf("File: "); printf(fn.c_str()); printf("\n");            
+        }
+        if (httpd_query_key_value(_query, "delete", _filename, 30) == ESP_OK)
+        {
+            fn.append(_filename);
+            _file_del = true;
+            printf("Delete Default File: "); printf(fn.c_str()); printf("\n");            
+        }
+
+    };
+
+    if (_file_del)
+    {
+        struct stat file_stat;
+        if (stat(fn.c_str(), &file_stat) != -1) {
+            printf("Deleting file : %s", fn.c_str());
+            /* Delete file */
+            unlink(fn.c_str());
+        }
+        /* Respond with an empty chunk to signal HTTP response completion */
+        httpd_resp_send_chunk(req, NULL, 0);
+        return ESP_OK;
+    }
+
+    const char* resp_str;    
+
+    if (ota_example_task(fn))
+    {
+        resp_str = "Firmware Update Successfull!<br><br>You can restart now.";
+    }
+    else
+    {
+        resp_str = "Error during Firmware Update!!!<br><br>Please check output of console.";
+    }
+
+    httpd_resp_send(req, resp_str, strlen(resp_str));  
+    
+    return ESP_OK;
+};
+
+void hard_restart() {
+  esp_task_wdt_init(1,true);
+  esp_task_wdt_add(NULL);
+  while(true);
+}
+
+void task_reboot(void *pvParameter)
+{
+
+
+    while(1)
+    {
+        vTaskDelay(5000 / portTICK_PERIOD_MS);
+        esp_restart();
+        hard_restart();
+    }
+
+    vTaskDelete(NULL); //Delete this task if it exits from the loop above
+}
+
+
+esp_err_t handler_reboot(httpd_req_t *req)
+{
+    LogFile.WriteToFile("handler_reboot");
+    ESP_LOGI(TAGPARTOTA, "!!! System will restart within 5 sec!!!");
+
+    const char* resp_str = "!!! System will restart within 5 sec!!!";
+    httpd_resp_send(req, resp_str, strlen(resp_str)); 
+    
+    KillTFliteTasks();
+
+    xTaskCreate(&task_reboot, "reboot", configMINIMAL_STACK_SIZE * 64, NULL, 10, NULL);
+
+    return ESP_OK;
+}
+
+void register_server_ota_sdcard_uri(httpd_handle_t server)
+{
+    ESP_LOGI(TAGPARTOTA, "server_ota - Registering URI handlers");
+    
+    httpd_uri_t camuri = { };
+    camuri.method    = HTTP_GET;
+    camuri.uri       = "/ota";
+    camuri.handler   = handler_ota_update;
+    camuri.user_ctx  = (void*) "Do OTA";    
+    httpd_register_uri_handler(server, &camuri);
+
+    camuri.method    = HTTP_GET;
+    camuri.uri       = "/reboot";
+    camuri.handler   = handler_reboot;
+    camuri.user_ctx  = (void*) "Reboot";    
+    httpd_register_uri_handler(server, &camuri);
+
+}

code/lib/jomjol_fileserver_ota/server_ota.h

@@ -0,0 +1,10 @@
+#include <esp_log.h>
+
+#include <esp_http_server.h>
+
+//#include "ClassControllCamera.h"
+
+static const char *TAGPARTOTA = "server_ota";
+
+void register_server_ota_sdcard_uri(httpd_handle_t server);
+void CheckOTAUpdate();