Adds template libs

esp32/lib/ESP32-sveltekit/UploadFirmwareService.cpp

@@ -0,0 +1,205 @@
+/**
+ *   ESP32 SvelteKit
+ *
+ *   A simple, secure and extensible framework for IoT projects for ESP32 platforms
+ *   with responsive Sveltekit front-end built with TailwindCSS and DaisyUI.
+ *   https://github.com/theelims/ESP32-sveltekit
+ *
+ *   Copyright (C) 2018 - 2023 rjwats
+ *   Copyright (C) 2023 theelims
+ *
+ *   All Rights Reserved. This software may be modified and distributed under
+ *   the terms of the LGPL v3 license. See the LICENSE file for details.
+ **/
+
+#include <UploadFirmwareService.h>
+#include <esp_ota_ops.h>
+#include <esp_app_format.h>
+
+using namespace std::placeholders; // for `_1` etc
+
+static char md5[33] = "\0";
+
+static FileType fileType = ft_none;
+
+UploadFirmwareService::UploadFirmwareService(PsychicHttpServer *server,
+                                             SecurityManager *securityManager) : _server(server),
+                                                                                 _securityManager(securityManager)
+{
+}
+
+void UploadFirmwareService::begin()
+{
+    _server->maxUploadSize = 2300000; // 2.3 MB
+
+    PsychicUploadHandler *uploadHandler = new PsychicUploadHandler();
+
+    uploadHandler->onUpload(std::bind(&UploadFirmwareService::handleUpload, this, _1, _2, _3, _4, _5, _6));
+    uploadHandler->onRequest(std::bind(&UploadFirmwareService::uploadComplete, this, _1));  // gets called after upload has been handled
+    uploadHandler->onClose(std::bind(&UploadFirmwareService::handleEarlyDisconnect, this)); // gets called if client disconnects
+    _server->on(UPLOAD_FIRMWARE_PATH, HTTP_POST, uploadHandler);
+
+    ESP_LOGV("UploadFirmwareService", "Registered POST endpoint: %s", UPLOAD_FIRMWARE_PATH);
+}
+
+esp_err_t UploadFirmwareService::handleUpload(PsychicRequest *request,
+                                              const String &filename,
+                                              uint64_t index,
+                                              uint8_t *data,
+                                              size_t len,
+                                              bool final)
+{
+    // quit if not authorized
+    Authentication authentication = _securityManager->authenticateRequest(request);
+    if (!AuthenticationPredicates::IS_ADMIN(authentication))
+    {
+        return handleError(request, 403); // forbidden
+    }
+
+    // at init
+    if (!index)
+    {
+        // check details of the file, to see if its a valid bin or json file
+        std::string fname(filename.c_str());
+        auto position = fname.find_last_of(".");
+        std::string extension = fname.substr(position + 1);
+        size_t fsize = request->contentLength();
+
+        fileType = ft_none;
+        if ((extension == "bin") && (fsize > 1000000))
+        {
+            fileType = ft_firmware;
+        }
+        else if (extension == "md5")
+        {
+            fileType = ft_md5;
+            if (len == 32)
+            {
+                memcpy(md5, data, 32);
+                md5[32] = '\0';
+            }
+            return ESP_OK;
+        }
+        else
+        {
+            md5[0] = '\0';
+            return handleError(request, 406); // Not Acceptable - unsupported file type
+        }
+
+        if (fileType == ft_firmware)
+        {
+            // Check firmware header, 0xE9 magic offset 0 indicates esp bin, chip offset 12: esp32:0, S2:2, C3:5
+#if CONFIG_IDF_TARGET_ESP32 // ESP32/PICO-D4
+            if (len > 12 && (data[0] != 0xE9 || data[12] != 0))
+            {
+                return handleError(request, 503); // service unavailable
+            }
+#elif CONFIG_IDF_TARGET_ESP32S2
+            if (len > 12 && (data[0] != 0xE9 || data[12] != 2))
+            {
+                return handleError(request, 503); // service unavailable
+            }
+#elif CONFIG_IDF_TARGET_ESP32C3
+            if (len > 12 && (data[0] != 0xE9 || data[12] != 5))
+            {
+                return handleError(request, 503); // service unavailable
+            }
+#elif CONFIG_IDF_TARGET_ESP32S3
+            if (len > 12 && (data[0] != 0xE9 || data[12] != 9))
+            {
+                return handleError(request, 503); // service unavailable
+            }
+#endif
+            // it's firmware - initialize the ArduinoOTA updater
+            if (Update.begin(fsize - sizeof(esp_image_header_t)))
+            {
+                if (strlen(md5) == 32)
+                {
+                    Update.setMD5(md5);
+                    md5[0] = '\0';
+                }
+            }
+            else
+            {
+                return handleError(request, 507); // failed to begin, send an error response Insufficient Storage
+            }
+        }
+    }
+
+    // if we haven't delt with an error, continue with the firmware update
+    if (!request->_tempObject)
+    {
+        if (Update.write(data, len) != len)
+        {
+            handleError(request, 500);
+        }
+        if (final)
+        {
+            if (!Update.end(true))
+            {
+                handleError(request, 500);
+            }
+        }
+    }
+
+    return ESP_OK;
+}
+
+esp_err_t UploadFirmwareService::uploadComplete(PsychicRequest *request)
+{
+    // if we completed uploading a md5 file create a JSON response
+    if (fileType == ft_md5)
+    {
+        if (strlen(md5) == 32)
+        {
+            PsychicJsonResponse response = PsychicJsonResponse(request, false, 256);
+            JsonObject root = response.getRoot();
+            root["md5"] = md5;
+            return response.send();
+        }
+        return ESP_OK;
+    }
+
+    // if no error, send the success response
+    if (!request->_tempObject)
+    {
+        request->reply(200);
+        RestartService::restartNow();
+        return ESP_OK;
+    }
+
+    // if updated has an error send 500 response and log on Serial
+    if (Update.hasError())
+    {
+        Update.printError(Serial);
+        Update.abort();
+        handleError(request, 500);
+    }
+
+    return ESP_OK;
+}
+
+esp_err_t UploadFirmwareService::handleError(PsychicRequest *request, int code)
+{
+    // if we have had an error already, do nothing
+    if (request->_tempObject)
+    {
+        return ESP_OK;
+    }
+
+    // send the error code to the client and record the error code in the temp object
+    request->_tempObject = new int(code);
+    return request->reply(code);
+}
+
+esp_err_t UploadFirmwareService::handleEarlyDisconnect()
+{
+    // if updated has not ended on connection close, abort it
+    if (!Update.end(true))
+    {
+        Update.printError(Serial);
+        Update.abort();
+        return ESP_OK;
+    }
+    return ESP_OK;
+}