Merge remote-tracking branch 'esp8266/master'

Author: Me No Dev

cores/esp8266/Schedule.cpp

@@ -0,0 +1,97 @@
+#include "Schedule.h"
+
+struct scheduled_fn_t
+{
+    scheduled_fn_t* mNext;
+    std::function<void(void)> mFunc;
+};
+
+static scheduled_fn_t* sFirst = 0;
+static scheduled_fn_t* sLast = 0;
+
+static scheduled_fn_t* sFirstUnused = 0;
+static scheduled_fn_t* sLastUnused = 0;
+
+static int sCount = 0;
+
+static void init_lists()
+{
+    if (sCount != 0) {
+        return;
+    }
+    while (sCount < SCHEDULED_FN_INITIAL_COUNT) {
+        scheduled_fn_t* it = new scheduled_fn_t;
+        if (sCount == 0) {
+            sFirstUnused = it;
+        }
+        else {
+            sLastUnused->mNext = it;
+        }
+        sLastUnused = it;
+        ++sCount;
+    }
+    sLastUnused->mNext = NULL;
+}
+
+static scheduled_fn_t* get_fn() {
+    scheduled_fn_t* result = NULL;
+    // try to get an item from unused items list
+    if (sFirstUnused) {
+        result = sFirstUnused;
+        sFirstUnused = result->mNext;
+        if (sFirstUnused == NULL) {
+            sLastUnused = NULL;
+        }
+    }
+    // if no unused items, and count not too high, allocate a new one
+    else if (sCount != SCHEDULED_FN_MAX_COUNT) {
+        result = new scheduled_fn_t;
+        result->mNext = NULL;
+        ++sCount;
+    }
+    return result;
+}
+
+static void recycle_fn(scheduled_fn_t* fn)
+{
+    if (!sLastUnused) {
+        sFirstUnused = fn;
+    }
+    else {
+        sLastUnused->mNext = fn;
+    }
+    fn->mNext = NULL;
+    sLastUnused = fn;
+}
+
+bool schedule_function(std::function<void(void)> fn)
+{
+    scheduled_fn_t* item = get_fn();
+    if (!item) {
+        return false;
+    }
+    item->mFunc = fn;
+    item->mNext = NULL;
+    if (!sFirst) {
+        sFirst = item;
+    }
+    else {
+        sLast->mNext = item;
+    }
+    sLast = item;
+    return true;
+}
+
+void run_scheduled_functions()
+{
+    while (sFirst) {
+        scheduled_fn_t* item = sFirst;
+        sFirst = item->mNext;
+        if (sFirst == NULL) {
+            sLast = NULL;
+        }
+        item->mFunc();
+        item->mFunc = std::function<void(void)>();
+        recycle_fn(item);
+    }
+}

cores/esp8266/Schedule.h

@@ -0,0 +1,27 @@
+#ifndef ESP_SCHEDULE_H
+#define ESP_SCHEDULE_H
+
+#include <functional>
+
+#define SCHEDULED_FN_MAX_COUNT 32
+#define SCHEDULED_FN_INITIAL_COUNT 4
+
+// Warning 
+// This API is not considered stable. 
+// Function signatures will change.
+// You have been warned.
+
+// Run given function next time `loop` function returns, 
+// or `run_scheduled_functions` is called.
+// Use std::bind to pass arguments to a function, or call a class member function.
+// Note: there is no mechanism for cancelling scheduled functions.
+// Keep that in mind when binding functions to objects which may have short lifetime.
+// Returns false if the number of scheduled functions exceeds SCHEDULED_FN_MAX_COUNT.
+bool schedule_function(std::function<void(void)> fn);
+
+// Run all scheduled functions. 
+// Use this function if your are not using `loop`, or `loop` does not return
+// on a regular basis.
+void run_scheduled_functions();
+
+#endif //ESP_SCHEDULE_H

cores/esp8266/core_esp8266_main.cpp

@@ -23,6 +23,7 @@
 //This may be used to change user task stack size:
 //#define CONT_STACKSIZE 4096
 #include <Arduino.h>
+#include "Schedule.h"
 extern "C" {
 #include "ets_sys.h"
 #include "os_type.h"
@@ -119,6 +120,7 @@ static void loop_wrapper() {
         setup_done = true;
     }
     loop();
+    run_scheduled_functions();
     esp_schedule();
 }
 

libraries/ESP8266HTTPUpdateServer/examples/SecureWebUpdater/SecureWebUpdater.ino

@@ -0,0 +1,45 @@
+/*
+  To upload through terminal you can use: curl -F "[email protected]" esp8266-webupdate.local/update
+*/
+
+#include <ESP8266WiFi.h>
+#include <WiFiClient.h>
+#include <ESP8266WebServer.h>
+#include <ESP8266mDNS.h>
+#include <ESP8266HTTPUpdateServer.h>
+
+const char* host = "esp8266-webupdate";
+const char* update_path = "/firmware";
+const char* update_username = "admin";
+const char* update_password = "admin";
+const char* ssid = "........";
+const char* password = "........";
+
+ESP8266WebServer httpServer(80);
+ESP8266HTTPUpdateServer httpUpdater;
+
+void setup(void){
+
+  Serial.begin(115200);
+  Serial.println();
+  Serial.println("Booting Sketch...");
+  WiFi.mode(WIFI_AP_STA);
+  WiFi.begin(ssid, password);
+
+  while(WiFi.waitForConnectResult() != WL_CONNECTED){
+    WiFi.begin(ssid, password);
+    Serial.println("WiFi failed, retrying.");
+  }
+
+  MDNS.begin(host);
+
+  httpUpdater.setup(&httpServer, update_path, update_username, update_password);
+  httpServer.begin();
+
+  MDNS.addService("http", "tcp", 80);
+  Serial.printf("HTTPUpdateServer ready! Open http://%s.local%s in your browser and login with username '%s' and password '%s'\n", host, update_path, update_username, update_password);
+}
+
+void loop(void){
+  httpServer.handleClient();
+}

libraries/ESP8266HTTPUpdateServer/examples/WebUpdater/WebUpdater.ino

@@ -39,5 +39,4 @@ void setup(void){
 
 void loop(void){
   httpServer.handleClient();
-  delay(1);
 }

libraries/ESP8266HTTPUpdateServer/src/ESP8266HTTPUpdateServer.cpp

@@ -7,34 +7,41 @@
 
 
 const char* ESP8266HTTPUpdateServer::_serverIndex =
-R"(<html><body><form method='POST' action='/update' enctype='multipart/form-data'>
+R"(<html><body><form method='POST' action='' enctype='multipart/form-data'>
                   <input type='file' name='update'>
                   <input type='submit' value='Update'>
                </form>
          </body></html>)";
+const char* ESP8266HTTPUpdateServer::_failedResponse = R"(Update Failed!)";
+const char* ESP8266HTTPUpdateServer::_successResponse = "<META http-equiv=\"refresh\" content=\"15;URL=\">Update Success! Rebooting...";
 
 ESP8266HTTPUpdateServer::ESP8266HTTPUpdateServer(bool serial_debug)
 {
   _serial_output = serial_debug;
   _server = NULL;
+  _username = NULL;
+  _password = NULL;
+  _authenticated = false;
 }
 
-void ESP8266HTTPUpdateServer::setup(ESP8266WebServer *server)
+void ESP8266HTTPUpdateServer::setup(ESP8266WebServer *server, const char * path, const char * username, const char * password)
 {
     _server = server;
+    _username = (char *)username;
+    _password = (char *)password;
 
     // handler for the /update form page
-    _server->on("/update", HTTP_GET, [&](){
-      _server->sendHeader("Connection", "close");
-      _server->sendHeader("Access-Control-Allow-Origin", "*");
+    _server->on(path, HTTP_GET, [&](){
+      if(_username != NULL && _password != NULL && !_server->authenticate(_username, _password))
+        return _server->requestAuthentication();
       _server->send(200, "text/html", _serverIndex);
     });
 
     // handler for the /update form POST (once file upload finishes)
-    _server->on("/update", HTTP_POST, [&](){
-      _server->sendHeader("Connection", "close");
-      _server->sendHeader("Access-Control-Allow-Origin", "*");
-      _server->send(200, "text/html", (Update.hasError())?"FAIL":"<META http-equiv=\"refresh\" content=\"15;URL=/update\">OK");
+    _server->on(path, HTTP_POST, [&](){
+      if(!_authenticated)
+        return _server->requestAuthentication();
+      _server->send(200, "text/html", Update.hasError() ? _failedResponse : _successResponse);
       ESP.restart();
     },[&](){
       // handler for the file upload, get's the sketch bytes, and writes
@@ -43,27 +50,35 @@ void ESP8266HTTPUpdateServer::setup(ESP8266WebServer *server)
       if(upload.status == UPLOAD_FILE_START){
         if (_serial_output)
           Serial.setDebugOutput(true);
+
+        _authenticated = (_username == NULL || _password == NULL || _server->authenticate(_username, _password));
+        if(!_authenticated){
+          if (_serial_output)
+            Serial.printf("Unauthenticated Update\n");
+          return;
+        }
+
         WiFiUDP::stopAll();
         if (_serial_output)
           Serial.printf("Update: %s\n", upload.filename.c_str());
         uint32_t maxSketchSpace = (ESP.getFreeSketchSpace() - 0x1000) & 0xFFFFF000;
         if(!Update.begin(maxSketchSpace)){//start with max available size
           if (_serial_output) Update.printError(Serial);
         }
-      } else if(upload.status == UPLOAD_FILE_WRITE){
+      } else if(_authenticated && upload.status == UPLOAD_FILE_WRITE){
         if (_serial_output) Serial.printf(".");
         if(Update.write(upload.buf, upload.currentSize) != upload.currentSize){
           if (_serial_output) Update.printError(Serial);
 
         }
-      } else if(upload.status == UPLOAD_FILE_END){
+      } else if(_authenticated && upload.status == UPLOAD_FILE_END){
         if(Update.end(true)){ //true to set the size to the current progress
           if (_serial_output) Serial.printf("Update Success: %u\nRebooting...\n", upload.totalSize);
         } else {
           if (_serial_output) Update.printError(Serial);
         }
         if (_serial_output) Serial.setDebugOutput(false);
-      } else if(upload.status == UPLOAD_FILE_ABORTED){
+      } else if(_authenticated && upload.status == UPLOAD_FILE_ABORTED){
         Update.end();
         if (_serial_output) Serial.println("Update was aborted");
       }

libraries/ESP8266HTTPUpdateServer/src/ESP8266HTTPUpdateServer.h

@@ -9,9 +9,30 @@ class ESP8266HTTPUpdateServer
     bool _serial_output;
     ESP8266WebServer *_server;
     static const char *_serverIndex;
+    static const char *_failedResponse;
+    static const char *_successResponse;
+    char * _username;
+    char * _password;
+    bool _authenticated;
   public:
     ESP8266HTTPUpdateServer(bool serial_debug=false);
-    void setup(ESP8266WebServer *server=NULL);
+
+    void setup(ESP8266WebServer *server)
+    {
+      setup(server, NULL, NULL);
+    }
+
+    void setup(ESP8266WebServer *server, const char * path)
+    {
+      setup(server, path, NULL, NULL);
+    }
+
+    void setup(ESP8266WebServer *server, const char * username, const char * password)
+    {
+      setup(server, "/update", username, password);
+    }
+
+    void setup(ESP8266WebServer *server, const char * path, const char * username, const char * password);
 };