Update IDF to aaf1239 (#1539)

* fix sdmmc config

* Fix warnings in EEPROM

from @Curclamas

* remove leftover TAG in EEPROM

* Initial add of @stickbreaker i2c

* Add log_n

* fix warnings when log is off

* i2c code clean up and reorganization

* add flags to interrupt allocator

* fix sdmmc config

* Fix warnings in EEPROM

from @Curclamas

* remove leftover TAG in EEPROM

* fix errors with latest IDF

* fix debug optimization (#1365)

incorrect optimization for debugging tick markers.

* Fix some missing BT header

* Change BTSerial log calls

* Update BLE lib

* Arduino-ESP32 release management scripted (#1515)

* Calculate an absolute path for a custom partitions table (#1452)

* * Arduino-ESP32 release management scripted
(ready-to-merge)

* * secure env for espressif/arduino-esp32

* * build tests enabled
* gitter webhook enabled

* * gitter room link fixed
* better comment

* * filepaths fixed

* BT Serial adjustments

* * don't run sketch builds & tests for tagged builds

* Return false from WiFi.hostByName() if hostname is not resolved

* Free BT Memory when BT is not used

* WIFI_MODE_NULL is not supported anymore

* Select some key examples to build with PlatformIO to save some time

* Update BLE lib

* Fixed BLE lib

* Major WiFi overhaul

- auto reconnect on connection loss now works
- moved to event groups
- some code clean up and procedure optimizations
- new methods to get a more elaborate system ststus

* Add cmake tests to travis

* Add initial AsyncUDP

* Add NetBIOS lib and fix CMake includes

* Add Initial WebServer

* Fix WebServer and examples

* travis not quiting on build fail

* Try different travis build

* Update IDF to aaf1239

* Fix WPS Example

* fix script permission and add some fail tests to sketch builder

* Add missing space in WiFiClient::write(Stream &stream)

.travis.yml

@@ -7,44 +7,22 @@ python:
 os:
   - linux
 
+env:
+    global:
+        - secure: "l/4Dt+KQ/mACtGAHDUsPr66fUte840PZoQ4xpPikqWZI0uARu4l+Ym7+sHinnT6fBqrj8AJeBYGz4nFa8NK4LutZn9mSD40w+sxl0wSV4oHV8rzKe3Cd8+sMG3+o33yWoikMNjSvqa73Q0rm+SgrlInNdZbuAyixL+a2alaWSnGPm4F2xwUGj+S33TOy5P/Xp77CYtCV5S8vzyk/eEdNhoF0GYePJVdfuzCOUjXMyT5OWxORkzzQ7Hnn/Ka/RDfV8Si4HgujLQBrK5q6iPnNBFqBSqilYBepSMn4opnOBpIm0SCgePz7XQEFC83buA7GUcnCnfg38bf+dCwHaODf1d1PmqVRYt2QmfinexXtM4afAtL0iBUDtvrfnXHzwW9w82VeZhpbJSVh9DUQvB0IlsZeCz9J9PUBAi3N+SMX+9l+BomYwRUlPuKY+Ef2JKk9q6mxtUkky5R0daAlVxEhpVdQks1rT+T+NMoDMemxQ3SKEiqAHh6EgHecruszffmZ71uLX9MpERpew0qN+UFiafws+jkTjx+3yF9yut0Hf9sMbeAYzzkGzRqJTUEBJ6B29Cql8M0yRXCNN/8wuuTHhG8esstozga4ZQoIVrq7mEAgup376PTcNfr1+imbbWVQ7lJdYIuDe6OS5V3OX6np11vgK/DbhfyzvQv9Z1zAGnM="
+        - REMOTE_URL=https://github.com/$TRAVIS_REPO_SLUG/releases/download/$TRAVIS_TAG
+    
 script:
-  #- set -e
-  - echo -e "travis_fold:start:sketch_test_env_prepare"
-  - pip install pyserial
-  - wget -O arduino.tar.xz https://www.arduino.cc/download.php?f=/arduino-nightly-linux64.tar.xz
-  - tar xf arduino.tar.xz
-  - mv arduino-nightly $HOME/arduino_ide
-  - mkdir -p $HOME/Arduino/libraries
-  - cd $HOME/arduino_ide/hardware
-  - mkdir espressif
-  - cd espressif
-  - ln -s $TRAVIS_BUILD_DIR esp32
-  - cd esp32
-  - git submodule update --init --recursive
-  - cd tools
-  - python get.py
-  - export PATH="$HOME/arduino_ide:$TRAVIS_BUILD_DIR/tools/xtensa-esp32-elf/bin:$PATH"
-  - which arduino
-  - cd $TRAVIS_BUILD_DIR
-  - source tools/common.sh
-  - echo -e "travis_fold:end:sketch_test_env_prepare"
-  - echo -e "travis_fold:start:sketch_test"
-  - build_sketches $HOME/arduino_ide $TRAVIS_BUILD_DIR/libraries "-l $HOME/Arduino/libraries"
-  - echo -e "travis_fold:end:sketch_test"
-  - echo -e "travis_fold:start:size_report"
-  - cat size.log
-  - echo -e "travis_fold:end:size_report"
+  - bash $TRAVIS_BUILD_DIR/tools/build.sh
+
+deploy:
+  provider: script
+  skip_cleanup: true
+  script: bash $TRAVIS_BUILD_DIR/tools/deploy.sh -t$TRAVIS_TAG -a$ESP32_GITHUB_TOKEN -s$TRAVIS_REPO_SLUG -drelease
+
+  on:
+    tags: true
 
-  # test library examples with PlatformIO
-  - echo -e "travis_fold:start:platformio_test_env_prepare"
-  - pip install -U https://github.com/platformio/platformio/archive/develop.zip
-  - platformio platform install https://github.com/platformio/platform-espressif32.git#feature/stage
-  - sed -i 's/https:\/\/github\.com\/espressif\/arduino-esp32\.git/*/' ~/.platformio/platforms/espressif32/platform.json
-  - ln -s $TRAVIS_BUILD_DIR ~/.platformio/packages/framework-arduinoespressif32
-  - echo -e "travis_fold:end:platformio_test_env_prepare"
-  - echo -e "travis_fold:start:platformio_test"
-  - "python -c \"import glob,os,subprocess,sys; map(lambda p: (sys.stdout.write('Library example: %s\\n' % p), subprocess.call(['pio', 'ci', p, '--board', 'esp32dev'])), set([os.path.dirname(p) for p in glob.glob('libraries/*/examples/*/*.ino') + glob.glob('libraries/*/examples/*/*/*.ino')]))\""
-  - echo -e "travis_fold:end:platformio_test"
 
 notifications:
   email:
@@ -52,7 +30,7 @@ notifications:
     on_failure: change
   webhooks:
     urls:
-      - https://webhooks.gitter.im/e/cb057279c430d91a47a8
+        - https://webhooks.gitter.im/e/cb057279c430d91a47a8
     on_success: change  # options: [always|never|change] default: always
     on_failure: always  # options: [always|never|change] default: always
-    on_start: false     # default: false
+    on_start: never     # options: [always|never|change] default: always

CMakeLists.txt

@@ -34,6 +34,7 @@ set(CORE_SRCS
 
 set(LIBRARY_SRCS
   libraries/ArduinoOTA/src/ArduinoOTA.cpp
+  libraries/AsyncUDP/src/AsyncUDP.cpp
   libraries/BluetoothSerial/src/BluetoothSerial.cpp
   libraries/DNSServer/src/DNSServer.cpp
   libraries/EEPROM/EEPROM.cpp
@@ -41,6 +42,7 @@ set(LIBRARY_SRCS
   libraries/FS/src/FS.cpp
   libraries/FS/src/vfs_api.cpp
   libraries/HTTPClient/src/HTTPClient.cpp
+  libraries/NetBIOS/src/NetBIOS.cpp
   libraries/Preferences/src/Preferences.cpp
   libraries/SD_MMC/src/SD_MMC.cpp
   libraries/SD/src/SD.cpp
@@ -51,6 +53,9 @@ set(LIBRARY_SRCS
   libraries/SPI/src/SPI.cpp
   libraries/Ticker/src/Ticker.cpp
   libraries/Update/src/Updater.cpp
+  libraries/WebServer/src/WebServer.cpp
+  libraries/WebServer/src/Parsing.cpp
+  libraries/WebServer/src/detail/mimetable.cpp
   libraries/WiFiClientSecure/src/ssl_client.cpp
   libraries/WiFiClientSecure/src/WiFiClientSecure.cpp
   libraries/WiFi/src/ETH.cpp
@@ -162,6 +167,7 @@ set(COMPONENT_ADD_INCLUDEDIRS
   variants/esp32/
   cores/esp32/
   libraries/ArduinoOTA/src
+  libraries/AsyncUDP/src
   libraries/AzureIoT/src
   libraries/BLE/src
   libraries/BluetoothSerial/src
@@ -170,6 +176,7 @@ set(COMPONENT_ADD_INCLUDEDIRS
   libraries/ESPmDNS/src
   libraries/FS/src
   libraries/HTTPClient/src
+  libraries/NetBIOS/src
   libraries/Preferences/src
   libraries/SD_MMC/src
   libraries/SD/src
@@ -178,6 +185,7 @@ set(COMPONENT_ADD_INCLUDEDIRS
   libraries/SPI/src
   libraries/Ticker/src
   libraries/Update/src
+  libraries/WebServer/src
   libraries/WiFiClientSecure/src
   libraries/WiFi/src
   libraries/Wire/src

cores/esp32/Server.h

@@ -25,7 +25,7 @@
 class Server: public Print
 {
 public:
-    virtual void begin() =0;
+    virtual void begin(uint16_t port=0) =0;
 };
 
 #endif

cores/esp32/WString.cpp

@@ -881,3 +881,31 @@ float String::toFloat(void) const
     }
     return 0;
 }
+
+
+unsigned char String::equalsConstantTime(const String &s2) const {
+    // To avoid possible time-based attacks present function
+    // compares given strings in a constant time.
+    if(len != s2.len)
+        return 0;
+    //at this point lengths are the same
+    if(len == 0)
+        return 1;
+    //at this point lenghts are the same and non-zero
+    const char *p1 = buffer;
+    const char *p2 = s2.buffer;
+    unsigned int equalchars = 0;
+    unsigned int diffchars = 0;
+    while(*p1) {
+        if(*p1 == *p2)
+            ++equalchars;
+        else
+            ++diffchars;
+        ++p1;
+        ++p2;
+    }
+    //the following should force a constant time eval of the condition without a compiler "logical shortcut"
+    unsigned char equalcond = (equalchars == len);
+    unsigned char diffcond = (diffchars == 0);
+    return (equalcond & diffcond); //bitwise AND
+}

cores/esp32/WString.h

@@ -212,6 +212,7 @@ public:
     unsigned char operator <=(const String &rhs) const;
     unsigned char operator >=(const String &rhs) const;
     unsigned char equalsIgnoreCase(const String &s) const;
+    unsigned char equalsConstantTime(const String &s) const;
     unsigned char startsWith(const String &prefix) const;
     unsigned char startsWith(const String &prefix, unsigned int offset) const;
     unsigned char endsWith(const String &suffix) const;

cores/esp32/esp32-hal-bt.c

@@ -14,12 +14,18 @@
 
 #include "esp32-hal-bt.h"
 
-#if defined(CONFIG_BT_ENABLED) && defined(CONFIG_BLUEDROID_ENABLED)
+#ifdef CONFIG_BT_ENABLED
 
+bool btInUse(){ return true; }
 
+#ifdef CONFIG_BLUEDROID_ENABLED
 #include "esp_bt.h"
-#include "esp_bt_defs.h"
-#include "esp_bt_main.h"
+
+#ifdef CONFIG_CLASSIC_BT_ENABLED
+#define BT_MODE ESP_BT_MODE_BTDM
+#else
+#define BT_MODE ESP_BT_MODE_BLE
+#endif
 
 bool btStarted(){
     return (esp_bt_controller_get_status() == ESP_BT_CONTROLLER_STATUS_ENABLED);
@@ -35,7 +41,7 @@ bool btStart(){
         while(esp_bt_controller_get_status() == ESP_BT_CONTROLLER_STATUS_IDLE){}
     }
     if(esp_bt_controller_get_status() == ESP_BT_CONTROLLER_STATUS_INITED){
-        if (esp_bt_controller_enable(ESP_BT_MODE_BTDM)) {
+        if (esp_bt_controller_enable(BT_MODE)) {
             log_e("BT Enable failed");
             return false;
         }
@@ -81,4 +87,5 @@ bool btStop()
     return false;
 }
 #endif
+#endif
 

cores/esp32/esp32-hal-i2c.h

@@ -11,6 +11,7 @@
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
+// modified Nov 2017 by Chuck Todd <StickBreaker> to support Interrupt Driven I/O
 
 #ifndef _ESP32_HAL_I2C_H_
 #define _ESP32_HAL_I2C_H_
@@ -21,37 +22,48 @@ extern "C" {
 
 #include <stdint.h>
 #include <stdbool.h>
+#include "freertos/FreeRTOS.h"
+#include "freertos/event_groups.h"
 
+// External Wire.h equivalent error Codes
 typedef enum {
-    I2C_ERROR_OK,
+    I2C_ERROR_OK=0,
     I2C_ERROR_DEV,
     I2C_ERROR_ACK,
     I2C_ERROR_TIMEOUT,
     I2C_ERROR_BUS,
-    I2C_ERROR_BUSY
+    I2C_ERROR_BUSY,
+    I2C_ERROR_MEMORY,
+    I2C_ERROR_CONTINUE,
+    I2C_ERROR_NO_BEGIN
 } i2c_err_t;
 
 struct i2c_struct_t;
 typedef struct i2c_struct_t i2c_t;
 
-i2c_t * i2cInit(uint8_t i2c_num, uint16_t slave_addr, bool addr_10bit_en);
-
-//call this after you setup the bus and pins to send empty packet
-//required because when pins are attached, they emit pulses that lock the bus
-void i2cInitFix(i2c_t * i2c);
-
+i2c_t * i2cInit(uint8_t i2c_num, int8_t sda, int8_t scl, uint32_t clk_speed);
+void i2cRelease(i2c_t *i2c); // free ISR, Free DQ, Power off peripheral clock.  Must call i2cInit() to recover
+i2c_err_t i2cWrite(i2c_t * i2c, uint16_t address, uint8_t* buff, uint16_t size, bool sendStop, uint16_t timeOutMillis);
+i2c_err_t i2cRead(i2c_t * i2c, uint16_t address, uint8_t* buff, uint16_t size, bool sendStop, uint16_t timeOutMillis, uint32_t *readCount);
+i2c_err_t i2cFlush(i2c_t *i2c);
 i2c_err_t i2cSetFrequency(i2c_t * i2c, uint32_t clk_speed);
 uint32_t i2cGetFrequency(i2c_t * i2c);
 
+//Functions below should be used only if well understood
+//Might be deprecated and removed in future
 i2c_err_t i2cAttachSCL(i2c_t * i2c, int8_t scl);
 i2c_err_t i2cDetachSCL(i2c_t * i2c, int8_t scl);
 i2c_err_t i2cAttachSDA(i2c_t * i2c, int8_t sda);
 i2c_err_t i2cDetachSDA(i2c_t * i2c, int8_t sda);
 
-i2c_err_t i2cWrite(i2c_t * i2c, uint16_t address, bool addr_10bit, uint8_t * data, uint16_t len, bool sendStop);
-i2c_err_t i2cRead(i2c_t * i2c, uint16_t address, bool addr_10bit, uint8_t * data, uint16_t len, bool sendStop);
+//Stickbreakers ISR Support
+i2c_err_t i2cProcQueue(i2c_t *i2c, uint32_t *readCount, uint16_t timeOutMillis);
+i2c_err_t i2cAddQueueWrite(i2c_t *i2c, uint16_t i2cDeviceAddr, uint8_t *dataPtr, uint16_t dataLen, bool SendStop, EventGroupHandle_t event);
+i2c_err_t i2cAddQueueRead(i2c_t *i2c, uint16_t i2cDeviceAddr, uint8_t *dataPtr, uint16_t dataLen, bool SendStop, EventGroupHandle_t event);
 
-void i2cReset(i2c_t* i2c);
+//stickbreaker debug support
+void i2cDumpInts(uint8_t num);
+void i2cDumpI2c(i2c_t *i2c);
 
 #ifdef __cplusplus
 }

cores/esp32/esp32-hal-log.h

@@ -107,6 +107,12 @@ int log_printf(const char *fmt, ...);
 #define log_e(format, ...)
 #endif
 
+#if ARDUHAL_LOG_LEVEL >= ARDUHAL_LOG_LEVEL_NONE
+#define log_n(format, ...) log_printf(ARDUHAL_LOG_FORMAT(E, format), ##__VA_ARGS__)
+#else
+#define log_n(format, ...)
+#endif
+
 #include "esp_log.h"
 
 #ifdef CONFIG_ARDUHAL_ESP_LOG

cores/esp32/esp32-hal-misc.c

@@ -22,6 +22,7 @@
 #include "esp_partition.h"
 #include "esp_log.h"
 #include "esp_timer.h"
+#include "esp_bt.h"
 #include <sys/time.h>
 
 //Undocumented!!! Get chip temperature in Farenheit
@@ -75,6 +76,12 @@ void initVariant() {}
 void init() __attribute__((weak));
 void init() {}
 
+#ifdef CONFIG_BT_ENABLED
+//overwritten in esp32-hal-bt.c
+bool btInUse() __attribute__((weak));
+bool btInUse(){ return false; }
+#endif
+
 void initArduino()
 {
     esp_log_level_set("*", CONFIG_LOG_DEFAULT_LEVEL);
@@ -93,6 +100,11 @@ void initArduino()
     if(err) {
         log_e("Failed to initialize NVS! Error: %u", err);
     }
+#ifdef CONFIG_BT_ENABLED
+    if(!btInUse()){
+        esp_bt_controller_mem_release(ESP_BT_MODE_BTDM);
+    }
+#endif
     init();
     initVariant();
 }

libraries/AsyncUDP/examples/AsyncUDPClient/AsyncUDPClient.ino

@@ -0,0 +1,51 @@
+#include "WiFi.h"
+#include "AsyncUDP.h"
+
+const char * ssid = "***********";
+const char * password = "***********";
+
+AsyncUDP udp;
+
+void setup()
+{
+    Serial.begin(115200);
+    WiFi.mode(WIFI_STA);
+    WiFi.begin(ssid, password);
+    if (WiFi.waitForConnectResult() != WL_CONNECTED) {
+        Serial.println("WiFi Failed");
+        while(1) {
+            delay(1000);
+        }
+    }
+    if(udp.connect(IPAddress(192,168,1,100), 1234)) {
+        Serial.println("UDP connected");
+        udp.onPacket([](AsyncUDPPacket packet) {
+            Serial.print("UDP Packet Type: ");
+            Serial.print(packet.isBroadcast()?"Broadcast":packet.isMulticast()?"Multicast":"Unicast");
+            Serial.print(", From: ");
+            Serial.print(packet.remoteIP());
+            Serial.print(":");
+            Serial.print(packet.remotePort());
+            Serial.print(", To: ");
+            Serial.print(packet.localIP());
+            Serial.print(":");
+            Serial.print(packet.localPort());
+            Serial.print(", Length: ");
+            Serial.print(packet.length());
+            Serial.print(", Data: ");
+            Serial.write(packet.data(), packet.length());
+            Serial.println();
+            //reply to the client
+            packet.printf("Got %u bytes of data", packet.length());
+        });
+        //Send unicast
+        udp.print("Hello Server!");
+    }
+}
+
+void loop()
+{
+    delay(1000);
+    //Send broadcast on port 1234
+    udp.broadcastTo("Anyone here?", 1234);
+}

libraries/AsyncUDP/examples/AsyncUDPMulticastServer/AsyncUDPMulticastServer.ino

@@ -0,0 +1,52 @@
+#include "WiFi.h"
+#include "AsyncUDP.h"
+
+const char * ssid = "***********";
+const char * password = "***********";
+
+AsyncUDP udp;
+
+void setup()
+{
+    Serial.begin(115200);
+    WiFi.mode(WIFI_STA);
+    WiFi.begin(ssid, password);
+    if (WiFi.waitForConnectResult() != WL_CONNECTED) {
+        Serial.println("WiFi Failed");
+        while(1) {
+            delay(1000);
+        }
+    }
+    if(udp.listenMulticast(IPAddress(239,1,2,3), 1234)) {
+        Serial.print("UDP Listening on IP: ");
+        Serial.println(WiFi.localIP());
+        udp.onPacket([](AsyncUDPPacket packet) {
+            Serial.print("UDP Packet Type: ");
+            Serial.print(packet.isBroadcast()?"Broadcast":packet.isMulticast()?"Multicast":"Unicast");
+            Serial.print(", From: ");
+            Serial.print(packet.remoteIP());
+            Serial.print(":");
+            Serial.print(packet.remotePort());
+            Serial.print(", To: ");
+            Serial.print(packet.localIP());
+            Serial.print(":");
+            Serial.print(packet.localPort());
+            Serial.print(", Length: ");
+            Serial.print(packet.length());
+            Serial.print(", Data: ");
+            Serial.write(packet.data(), packet.length());
+            Serial.println();
+            //reply to the client
+            packet.printf("Got %u bytes of data", packet.length());
+        });
+        //Send multicast
+        udp.print("Hello!");
+    }
+}
+
+void loop()
+{
+    delay(1000);
+    //Send multicast
+    udp.print("Anyone here?");
+}

libraries/AsyncUDP/examples/AsyncUDPServer/AsyncUDPServer.ino

@@ -0,0 +1,50 @@
+#include "WiFi.h"
+#include "AsyncUDP.h"
+
+const char * ssid = "***********";
+const char * password = "***********";
+
+AsyncUDP udp;
+
+void setup()
+{
+    Serial.begin(115200);
+    WiFi.mode(WIFI_STA);
+    WiFi.begin(ssid, password);
+    if (WiFi.waitForConnectResult() != WL_CONNECTED) {
+        Serial.println("WiFi Failed");
+        while(1) {
+            delay(1000);
+        }
+    }
+    if(udp.listen(1234)) {
+        Serial.print("UDP Listening on IP: ");
+        Serial.println(WiFi.localIP());
+        udp.onPacket([](AsyncUDPPacket packet) {
+            Serial.print("UDP Packet Type: ");
+            Serial.print(packet.isBroadcast()?"Broadcast":packet.isMulticast()?"Multicast":"Unicast");
+            Serial.print(", From: ");
+            Serial.print(packet.remoteIP());
+            Serial.print(":");
+            Serial.print(packet.remotePort());
+            Serial.print(", To: ");
+            Serial.print(packet.localIP());
+            Serial.print(":");
+            Serial.print(packet.localPort());
+            Serial.print(", Length: ");
+            Serial.print(packet.length());
+            Serial.print(", Data: ");
+            Serial.write(packet.data(), packet.length());
+            Serial.println();
+            //reply to the client
+            packet.printf("Got %u bytes of data", packet.length());
+        });
+    }
+}
+
+void loop()
+{
+    delay(1000);
+    //Send broadcast
+    udp.broadcast("Anyone here?");
+}

libraries/AsyncUDP/keywords.txt

@@ -0,0 +1,33 @@
+#######################################
+# Syntax Coloring Map For Ultrasound
+#######################################
+
+#######################################
+# Datatypes (KEYWORD1)
+#######################################
+
+AsyncUDP	KEYWORD1
+AsyncUDPPacket	KEYWORD1
+
+#######################################
+# Methods and Functions (KEYWORD2)
+#######################################
+
+connect	KEYWORD2
+connected	KEYWORD2
+listen	KEYWORD2
+listenMulticast	KEYWORD2
+close	KEYWORD2
+write	KEYWORD2
+broadcast	KEYWORD2
+onPacket	KEYWORD2
+data	KEYWORD2
+length	KEYWORD2
+localIP	KEYWORD2
+localPort	KEYWORD2
+remoteIP	KEYWORD2
+remotePort	KEYWORD2
+
+#######################################
+# Constants (LITERAL1)
+#######################################

libraries/AsyncUDP/library.json

@@ -0,0 +1,17 @@
+{
+  "name":"AsyncUDP",
+  "description":"Asynchronous UDP Library for ESP32",
+  "keywords":"async,udp,server,client,multicast,broadcast",
+  "authors":
+  {
+    "name": "Hristo Gochkov",
+    "maintainer": true
+  },
+  "repository":
+  {
+    "type": "git",
+    "url": "https://github.com/me-no-dev/ESPAsyncUDP.git"
+  },
+  "frameworks": "arduino",
+  "platforms":"espressif"
+}

libraries/AsyncUDP/library.properties

@@ -0,0 +1,9 @@
+name=ESP32 Async UDP
+version=1.0.0
+author=Me-No-Dev
+maintainer=Me-No-Dev
+sentence=Async UDP Library for ESP32
+paragraph=Async UDP Library for ESP32
+category=Other
+url=https://github.com/me-no-dev/ESPAsyncUDP
+architectures=*

libraries/AsyncUDP/src/AsyncUDP.cpp

@@ -0,0 +1,846 @@
+#include "Arduino.h"
+#include "AsyncUDP.h"
+
+extern "C" {
+#include "lwip/opt.h"
+#include "lwip/inet.h"
+#include "lwip/udp.h"
+#include "lwip/igmp.h"
+#include "lwip/ip_addr.h"
+#include "lwip/mld6.h"
+#include <esp_err.h>
+#include <esp_wifi.h>
+}
+
+#include "lwip/priv/tcpip_priv.h"
+
+typedef struct {
+    struct tcpip_api_call call;
+    udp_pcb * pcb;
+    const ip_addr_t *addr;
+    uint16_t port;
+    struct pbuf *pb;
+    struct netif *netif;
+    err_t err;
+} udp_api_call_t;
+
+static err_t _udp_connect_api(struct tcpip_api_call *api_call_msg){
+    udp_api_call_t * msg = (udp_api_call_t *)api_call_msg;
+    msg->err = udp_connect(msg->pcb, msg->addr, msg->port);
+    return msg->err;
+}
+
+static err_t _udp_connect(struct udp_pcb *pcb, const ip_addr_t *addr, u16_t port){
+    udp_api_call_t msg;
+    msg.pcb = pcb;
+    msg.addr = addr;
+    msg.port = port;
+    tcpip_api_call(_udp_connect_api, (struct tcpip_api_call*)&msg);
+    return msg.err;
+}
+
+static err_t _udp_disconnect_api(struct tcpip_api_call *api_call_msg){
+    udp_api_call_t * msg = (udp_api_call_t *)api_call_msg;
+    msg->err = 0;
+    udp_disconnect(msg->pcb);
+    return msg->err;
+}
+
+static void  _udp_disconnect(struct udp_pcb *pcb){
+    udp_api_call_t msg;
+    msg.pcb = pcb;
+    tcpip_api_call(_udp_disconnect_api, (struct tcpip_api_call*)&msg);
+}
+
+static err_t _udp_remove_api(struct tcpip_api_call *api_call_msg){
+    udp_api_call_t * msg = (udp_api_call_t *)api_call_msg;
+    msg->err = 0;
+    udp_remove(msg->pcb);
+    return msg->err;
+}
+
+static void  _udp_remove(struct udp_pcb *pcb){
+    udp_api_call_t msg;
+    msg.pcb = pcb;
+    tcpip_api_call(_udp_remove_api, (struct tcpip_api_call*)&msg);
+}
+
+static err_t _udp_bind_api(struct tcpip_api_call *api_call_msg){
+    udp_api_call_t * msg = (udp_api_call_t *)api_call_msg;
+    msg->err = udp_bind(msg->pcb, msg->addr, msg->port);
+    return msg->err;
+}
+
+static err_t _udp_bind(struct udp_pcb *pcb, const ip_addr_t *addr, u16_t port){
+    udp_api_call_t msg;
+    msg.pcb = pcb;
+    msg.addr = addr;
+    msg.port = port;
+    tcpip_api_call(_udp_bind_api, (struct tcpip_api_call*)&msg);
+    return msg.err;
+}
+
+static err_t _udp_sendto_api(struct tcpip_api_call *api_call_msg){
+    udp_api_call_t * msg = (udp_api_call_t *)api_call_msg;
+    msg->err = udp_sendto(msg->pcb, msg->pb, msg->addr, msg->port);
+    return msg->err;
+}
+
+static err_t _udp_sendto(struct udp_pcb *pcb, struct pbuf *pb, const ip_addr_t *addr, u16_t port){
+    udp_api_call_t msg;
+    msg.pcb = pcb;
+    msg.addr = addr;
+    msg.port = port;
+    msg.pb = pb;
+    tcpip_api_call(_udp_sendto_api, (struct tcpip_api_call*)&msg);
+    return msg.err;
+}
+
+static err_t _udp_sendto_if_api(struct tcpip_api_call *api_call_msg){
+    udp_api_call_t * msg = (udp_api_call_t *)api_call_msg;
+    msg->err = udp_sendto_if(msg->pcb, msg->pb, msg->addr, msg->port, msg->netif);
+    return msg->err;
+}
+
+static err_t _udp_sendto_if(struct udp_pcb *pcb, struct pbuf *pb, const ip_addr_t *addr, u16_t port, struct netif *netif){
+    udp_api_call_t msg;
+    msg.pcb = pcb;
+    msg.addr = addr;
+    msg.port = port;
+    msg.pb = pb;
+    msg.netif = netif;
+    tcpip_api_call(_udp_sendto_if_api, (struct tcpip_api_call*)&msg);
+    return msg.err;
+}
+
+typedef struct {
+        void *arg;
+        udp_pcb *pcb;
+        pbuf *pb;
+        const ip_addr_t *addr;
+        uint16_t port;
+        struct netif * netif;
+} lwip_event_packet_t;
+
+static xQueueHandle _udp_queue;
+static volatile TaskHandle_t _udp_task_handle = NULL;
+
+static void _udp_task(void *pvParameters){
+    lwip_event_packet_t * e = NULL;
+    for (;;) {
+        if(xQueueReceive(_udp_queue, &e, portMAX_DELAY) == pdTRUE){
+            if(!e->pb){
+                free((void*)(e));
+                break;
+            }
+            AsyncUDP::_s_recv(e->arg, e->pcb, e->pb, e->addr, e->port, e->netif);
+            free((void*)(e));
+        }
+    }
+    _udp_task_handle = NULL;
+    vTaskDelete(NULL);
+}
+
+static bool _udp_task_start(){
+    if(!_udp_queue){
+        _udp_queue = xQueueCreate(32, sizeof(lwip_event_packet_t *));
+        if(!_udp_queue){
+            return false;
+        }
+    }
+    if(!_udp_task_handle){
+        xTaskCreate(_udp_task, "async_udp", 4096, NULL, 3, (TaskHandle_t*)&_udp_task_handle);
+        if(!_udp_task_handle){
+            return false;
+        }
+    }
+    return true;
+}
+
+static bool _udp_task_post(void *arg, udp_pcb *pcb, pbuf *pb, const ip_addr_t *addr, uint16_t port, struct netif *netif)
+{
+    if(!_udp_task_handle || !_udp_queue){
+        return false;
+    }
+    lwip_event_packet_t * e = (lwip_event_packet_t *)malloc(sizeof(lwip_event_packet_t));
+    if(!e){
+        return false;
+    }
+    e->arg = arg;
+    e->pcb = pcb;
+    e->pb = pb;
+    e->addr = addr;
+    e->port = port;
+    e->netif = netif;
+    if (xQueueSend(_udp_queue, &e, portMAX_DELAY) != pdPASS) {
+        free((void*)(e));
+        return false;
+    }
+    return true;
+}
+
+static void _udp_recv(void *arg, udp_pcb *pcb, pbuf *pb, const ip_addr_t *addr, uint16_t port)
+{
+    while(pb != NULL) {
+        pbuf * this_pb = pb;
+        pb = pb->next;
+        this_pb->next = NULL;
+        if(!_udp_task_post(arg, pcb, this_pb, addr, port, ip_current_input_netif())){
+            pbuf_free(this_pb);
+        }
+    }
+}
+/*
+static bool _udp_task_stop(){
+    if(!_udp_task_post(NULL, NULL, NULL, NULL, 0, NULL)){
+        return false;
+    }
+    while(_udp_task_handle){
+        vTaskDelay(10);
+    }
+
+    lwip_event_packet_t * e;
+    while (xQueueReceive(_udp_queue, &e, 0) == pdTRUE) {
+        if(e->pb){
+            pbuf_free(e->pb);
+        }
+        free((void*)(e));
+    }
+    vQueueDelete(_udp_queue);
+    _udp_queue = NULL;
+}
+*/
+
+
+
+#define UDP_MUTEX_LOCK()    //xSemaphoreTake(_lock, portMAX_DELAY)
+#define UDP_MUTEX_UNLOCK()  //xSemaphoreGive(_lock)
+
+
+AsyncUDPMessage::AsyncUDPMessage(size_t size)
+{
+    _index = 0;
+    if(size > CONFIG_TCP_MSS) {
+        size = CONFIG_TCP_MSS;
+    }
+    _size = size;
+    _buffer = (uint8_t *)malloc(size);
+}
+
+AsyncUDPMessage::~AsyncUDPMessage()
+{
+    if(_buffer) {
+        free(_buffer);
+    }
+}
+
+size_t AsyncUDPMessage::write(const uint8_t *data, size_t len)
+{
+    if(_buffer == NULL) {
+        return 0;
+    }
+    size_t s = space();
+    if(len > s) {
+        len = s;
+    }
+    memcpy(_buffer + _index, data, len);
+    _index += len;
+    return len;
+}
+
+size_t AsyncUDPMessage::write(uint8_t data)
+{
+    return write(&data, 1);
+}
+
+size_t AsyncUDPMessage::space()
+{
+    if(_buffer == NULL) {
+        return 0;
+    }
+    return _size - _index;
+}
+
+uint8_t * AsyncUDPMessage::data()
+{
+    return _buffer;
+}
+
+size_t AsyncUDPMessage::length()
+{
+    return _index;
+}
+
+void AsyncUDPMessage::flush()
+{
+    _index = 0;
+}
+
+
+AsyncUDPPacket::AsyncUDPPacket(AsyncUDP *udp, pbuf *pb, const ip_addr_t *raddr, uint16_t rport, struct netif * ntif)
+{
+    _udp = udp;
+    _pb = pb;
+    _if = TCPIP_ADAPTER_IF_MAX;
+    _data = (uint8_t*)(pb->payload);
+    _len = pb->len;
+    _index = 0;
+
+    //memcpy(&_remoteIp, raddr, sizeof(ip_addr_t));
+    _remoteIp.type = raddr->type;
+    _localIp.type = _remoteIp.type;
+
+    udp_hdr* udphdr = reinterpret_cast<udp_hdr*>(_data - UDP_HLEN);
+    _localPort = ntohs(udphdr->dest);
+    _remotePort = ntohs(udphdr->src);
+	
+    if (_remoteIp.type == IPADDR_TYPE_V4) {
+        struct ip_hdr * iphdr = (struct ip_hdr *)(((uint8_t *)(pb->payload)) - UDP_HLEN - IP_HLEN);
+        _localIp.u_addr.ip4.addr = iphdr->dest.addr;
+        _remoteIp.u_addr.ip4.addr = iphdr->src.addr;
+    } else {
+        struct ip6_hdr * ip6hdr = (struct ip6_hdr *)(((uint8_t *)(pb->payload)) - UDP_HLEN - IP6_HLEN);
+        memcpy(&_localIp.u_addr.ip6.addr, (uint8_t *)ip6hdr->dest.addr, 16);
+        memcpy(&_remoteIp.u_addr.ip6.addr, (uint8_t *)ip6hdr->src.addr, 16);
+    }
+
+    struct netif * netif = NULL;
+    void * nif = NULL;
+    int i;
+    for (i=0; i<TCPIP_ADAPTER_IF_MAX; i++) {
+        tcpip_adapter_get_netif ((tcpip_adapter_if_t)i, &nif);
+        netif = (struct netif *)nif;
+        if (netif && netif == ntif) {
+            _if = (tcpip_adapter_if_t)i;
+            break;
+        }
+    }
+}
+
+AsyncUDPPacket::~AsyncUDPPacket()
+{
+    pbuf_free(_pb);
+}
+
+uint8_t * AsyncUDPPacket::data()
+{
+    return _data;
+}
+
+size_t AsyncUDPPacket::length()
+{
+    return _len;
+}
+
+int AsyncUDPPacket::available(){
+    return _len - _index;
+}
+
+size_t AsyncUDPPacket::read(uint8_t *data, size_t len){
+    size_t i;
+    size_t a = _len - _index;
+    if(len > a){
+        len = a;
+    }
+    for(i=0;i<len;i++){
+        data[i] = read();
+    }
+    return len;
+}
+
+int AsyncUDPPacket::read(){
+    if(_index < _len){
+        return _data[_index++];
+    }
+    return -1;
+}
+
+int AsyncUDPPacket::peek(){
+    if(_index < _len){
+        return _data[_index];
+    }
+    return -1;
+}
+
+void AsyncUDPPacket::flush(){
+    _index = _len;
+}
+
+tcpip_adapter_if_t AsyncUDPPacket::interface()
+{
+    return _if;
+}
+
+IPAddress AsyncUDPPacket::localIP()
+{
+    if(_localIp.type != IPADDR_TYPE_V4){
+        return IPAddress();
+    }
+    return IPAddress(_localIp.u_addr.ip4.addr);
+}
+
+IPv6Address AsyncUDPPacket::localIPv6()
+{
+    if(_localIp.type != IPADDR_TYPE_V6){
+        return IPv6Address();
+    }
+    return IPv6Address(_localIp.u_addr.ip6.addr);
+}
+
+uint16_t AsyncUDPPacket::localPort()
+{
+    return _localPort;
+}
+
+IPAddress AsyncUDPPacket::remoteIP()
+{
+    if(_remoteIp.type != IPADDR_TYPE_V4){
+        return IPAddress();
+    }
+    return IPAddress(_remoteIp.u_addr.ip4.addr);
+}
+
+IPv6Address AsyncUDPPacket::remoteIPv6()
+{
+    if(_remoteIp.type != IPADDR_TYPE_V6){
+        return IPv6Address();
+    }
+    return IPv6Address(_remoteIp.u_addr.ip6.addr);
+}
+
+uint16_t AsyncUDPPacket::remotePort()
+{
+    return _remotePort;
+}
+
+bool AsyncUDPPacket::isIPv6()
+{
+    return _localIp.type == IPADDR_TYPE_V6;
+}
+
+bool AsyncUDPPacket::isBroadcast()
+{
+    if(_localIp.type == IPADDR_TYPE_V6){
+        return false;
+    }
+    uint32_t ip = _localIp.u_addr.ip4.addr;
+    return ip == 0xFFFFFFFF || ip == 0 || (ip & 0xFF000000) == 0xFF000000;
+}
+
+bool AsyncUDPPacket::isMulticast()
+{
+    return ip_addr_ismulticast(&(_localIp));
+}
+
+size_t AsyncUDPPacket::write(const uint8_t *data, size_t len)
+{
+    if(!data){
+        return 0;
+    }
+    return _udp->writeTo(data, len, &_remoteIp, _remotePort, _if);
+}
+
+size_t AsyncUDPPacket::write(uint8_t data)
+{
+    return write(&data, 1);
+}
+
+size_t AsyncUDPPacket::send(AsyncUDPMessage &message)
+{
+    return write(message.data(), message.length());
+}
+
+AsyncUDP::AsyncUDP()
+{
+    _pcb = udp_new();
+    _connected = false;
+    _handler = NULL;
+    if(!_pcb){
+        return;
+    }
+    //_lock = xSemaphoreCreateMutex();
+    udp_recv(_pcb, &_udp_recv, (void *) this);
+}
+
+AsyncUDP::~AsyncUDP()
+{
+    close();
+    UDP_MUTEX_LOCK();
+    udp_recv(_pcb, NULL, NULL);
+    _udp_remove(_pcb);
+    _pcb = NULL;
+    UDP_MUTEX_UNLOCK();
+    //vSemaphoreDelete(_lock);
+}
+
+void AsyncUDP::close()
+{
+    UDP_MUTEX_LOCK();
+    if(_pcb != NULL) {
+        if(_connected) {
+            _udp_disconnect(_pcb);
+        }
+        _connected = false;
+        _pcb->multicast_ip.type = IPADDR_TYPE_V4;
+        _pcb->multicast_ip.u_addr.ip4.addr = 0;
+    }
+    UDP_MUTEX_UNLOCK();
+}
+
+bool AsyncUDP::connect(const ip_addr_t *addr, uint16_t port)
+{
+    if(!_udp_task_start()){
+        log_e("failed to start task");
+        return false;
+    }
+    if(_pcb == NULL) {
+        return false;
+    }
+    close();
+    UDP_MUTEX_LOCK();
+    err_t err = _udp_connect(_pcb, addr, port);
+    if(err != ERR_OK) {
+        UDP_MUTEX_UNLOCK();
+        return false;
+    }
+    _connected = true;
+    UDP_MUTEX_UNLOCK();
+    return true;
+}
+
+bool AsyncUDP::listen(const ip_addr_t *addr, uint16_t port)
+{
+    if(!_udp_task_start()){
+        log_e("failed to start task");
+        return false;
+    }
+    if(_pcb == NULL) {
+        return false;
+    }
+    close();
+    if(addr){
+        IP_SET_TYPE_VAL(_pcb->local_ip,  addr->type);
+        IP_SET_TYPE_VAL(_pcb->remote_ip, addr->type);
+    }
+    UDP_MUTEX_LOCK();
+    if(_udp_bind(_pcb, addr, port) != ERR_OK) {
+        UDP_MUTEX_UNLOCK();
+        return false;
+    }
+    _connected = true;
+    UDP_MUTEX_UNLOCK();
+    return true;
+}
+
+bool AsyncUDP::listenMulticast(const ip_addr_t *addr, uint16_t port, uint8_t ttl, tcpip_adapter_if_t tcpip_if)
+{
+    if(!ip_addr_ismulticast(addr)) {
+        return false;
+    }
+    ip_addr_t multicast_if_addr;
+    uint8_t mode;
+    if(esp_wifi_get_mode((wifi_mode_t*)&mode)){
+        mode = WIFI_MODE_NULL;
+    }
+
+    if(addr->type == IPADDR_TYPE_V6){
+        multicast_if_addr.type = IPADDR_TYPE_V6;
+
+        if((tcpip_if == TCPIP_ADAPTER_IF_STA && (mode & WIFI_MODE_STA))
+            || (tcpip_if == TCPIP_ADAPTER_IF_AP && (mode & WIFI_MODE_AP))
+            || (tcpip_if == TCPIP_ADAPTER_IF_ETH)) {
+            if(tcpip_adapter_get_ip6_linklocal(tcpip_if, &multicast_if_addr.u_addr.ip6)){
+                return false;
+            }
+        } else {
+            return false;
+        }
+
+        if (mld6_joingroup(&(multicast_if_addr.u_addr.ip6), &(addr->u_addr.ip6))) {
+            return false;
+        }
+    } else if(addr->type == IPADDR_TYPE_V4){
+        tcpip_adapter_ip_info_t ifIpInfo;
+
+        if((tcpip_if == TCPIP_ADAPTER_IF_STA && (mode & WIFI_MODE_STA))
+            || (tcpip_if == TCPIP_ADAPTER_IF_AP && (mode & WIFI_MODE_AP))
+            || (tcpip_if == TCPIP_ADAPTER_IF_ETH)) {
+            if(tcpip_adapter_get_ip_info(tcpip_if, &ifIpInfo)){
+                return false;
+            }
+        } else {
+            return false;
+        }
+
+        multicast_if_addr.type = IPADDR_TYPE_V4;
+        multicast_if_addr.u_addr.ip4.addr = ifIpInfo.ip.addr;
+
+        if (igmp_joingroup((const ip4_addr *)&multicast_if_addr.u_addr.ip4, (const ip4_addr *)&addr->u_addr.ip4)!= ERR_OK) {
+            return false;
+        }
+    } else {
+        return false;
+    }
+
+    if(!listen(&multicast_if_addr, port)) {
+        return false;
+    }
+
+    UDP_MUTEX_LOCK();
+    _pcb->mcast_ttl = ttl;
+    _pcb->remote_port = port;
+    ip_addr_copy(_pcb->remote_ip, *addr);
+    if(addr->type == IPADDR_TYPE_V4){
+        ip_addr_copy(_pcb->multicast_ip, multicast_if_addr);
+    }
+    UDP_MUTEX_UNLOCK();
+
+    return true;
+}
+
+size_t AsyncUDP::writeTo(const uint8_t * data, size_t len, const ip_addr_t * addr, uint16_t port, tcpip_adapter_if_t tcpip_if)
+{
+    if(!_pcb) {
+        UDP_MUTEX_LOCK();
+        _pcb = udp_new_ip_type(addr->type);
+        UDP_MUTEX_UNLOCK();
+        if(_pcb == NULL) {
+            return 0;
+        }
+    }
+    if(len > CONFIG_TCP_MSS) {
+        len = CONFIG_TCP_MSS;
+    }
+    err_t err = ERR_OK;
+    pbuf* pbt = pbuf_alloc(PBUF_TRANSPORT, len, PBUF_RAM);
+    if(pbt != NULL) {
+        uint8_t* dst = reinterpret_cast<uint8_t*>(pbt->payload);
+        memcpy(dst, data, len);
+        UDP_MUTEX_LOCK();
+        if(tcpip_if != TCPIP_ADAPTER_IF_MAX){
+            void * nif = NULL;
+            tcpip_adapter_get_netif((tcpip_adapter_if_t)tcpip_if, &nif);
+            if(!nif){
+                err = _udp_sendto(_pcb, pbt, addr, port);
+            } else {
+                err = _udp_sendto_if(_pcb, pbt, addr, port, (struct netif *)nif);
+            }
+        } else {
+            err = _udp_sendto(_pcb, pbt, addr, port);
+        }
+        UDP_MUTEX_UNLOCK();
+        pbuf_free(pbt);
+        if(err < ERR_OK) {
+            return 0;
+        }
+        return len;
+    }
+    return 0;
+}
+
+void AsyncUDP::_recv(udp_pcb *upcb, pbuf *pb, const ip_addr_t *addr, uint16_t port, struct netif * netif)
+{
+    while(pb != NULL) {
+        pbuf * this_pb = pb;
+        pb = pb->next;
+        this_pb->next = NULL;
+        if(_handler) {
+            AsyncUDPPacket packet(this, this_pb, addr, port, netif);
+            _handler(packet);
+        } else {
+            pbuf_free(this_pb);
+        }
+    }
+}
+
+void AsyncUDP::_s_recv(void *arg, udp_pcb *upcb, pbuf *p, const ip_addr_t *addr, uint16_t port, struct netif * netif)
+{
+    reinterpret_cast<AsyncUDP*>(arg)->_recv(upcb, p, addr, port, netif);
+}
+
+bool AsyncUDP::listen(uint16_t port)
+{
+    return listen(IP_ANY_TYPE, port);
+}
+
+bool AsyncUDP::listen(const IPAddress addr, uint16_t port)
+{
+    ip_addr_t laddr;
+    laddr.type = IPADDR_TYPE_V4;
+    laddr.u_addr.ip4.addr = addr;
+    return listen(&laddr, port);
+}
+
+bool AsyncUDP::listenMulticast(const IPAddress addr, uint16_t port, uint8_t ttl, tcpip_adapter_if_t tcpip_if)
+{
+    ip_addr_t laddr;
+    laddr.type = IPADDR_TYPE_V4;
+    laddr.u_addr.ip4.addr = addr;
+    return listenMulticast(&laddr, port, ttl, tcpip_if);
+}
+
+bool AsyncUDP::connect(const IPAddress addr, uint16_t port)
+{
+    ip_addr_t daddr;
+    daddr.type = IPADDR_TYPE_V4;
+    daddr.u_addr.ip4.addr = addr;
+    return connect(&daddr, port);
+}
+
+size_t AsyncUDP::writeTo(const uint8_t *data, size_t len, const IPAddress addr, uint16_t port, tcpip_adapter_if_t tcpip_if)
+{
+    ip_addr_t daddr;
+    daddr.type = IPADDR_TYPE_V4;
+    daddr.u_addr.ip4.addr = addr;
+    return writeTo(data, len, &daddr, port, tcpip_if);
+}
+
+IPAddress AsyncUDP::listenIP()
+{
+    if(!_pcb || _pcb->remote_ip.type != IPADDR_TYPE_V4){
+        return IPAddress();
+    }
+    return IPAddress(_pcb->remote_ip.u_addr.ip4.addr);
+}
+
+bool AsyncUDP::listen(const IPv6Address addr, uint16_t port)
+{
+    ip_addr_t laddr;
+    laddr.type = IPADDR_TYPE_V6;
+    memcpy((uint8_t*)(laddr.u_addr.ip6.addr), (const uint8_t*)addr, 16);
+    return listen(&laddr, port);
+}
+
+bool AsyncUDP::listenMulticast(const IPv6Address addr, uint16_t port, uint8_t ttl, tcpip_adapter_if_t tcpip_if)
+{
+    ip_addr_t laddr;
+    laddr.type = IPADDR_TYPE_V6;
+    memcpy((uint8_t*)(laddr.u_addr.ip6.addr), (const uint8_t*)addr, 16);
+    return listenMulticast(&laddr, port, ttl, tcpip_if);
+}
+
+bool AsyncUDP::connect(const IPv6Address addr, uint16_t port)
+{
+    ip_addr_t daddr;
+    daddr.type = IPADDR_TYPE_V6;
+    memcpy((uint8_t*)(daddr.u_addr.ip6.addr), (const uint8_t*)addr, 16);
+    return connect(&daddr, port);
+}
+
+size_t AsyncUDP::writeTo(const uint8_t *data, size_t len, const IPv6Address addr, uint16_t port, tcpip_adapter_if_t tcpip_if)
+{
+    ip_addr_t daddr;
+    daddr.type = IPADDR_TYPE_V6;
+    memcpy((uint8_t*)(daddr.u_addr.ip6.addr), (const uint8_t*)addr, 16);
+    return writeTo(data, len, &daddr, port, tcpip_if);
+}
+
+IPv6Address AsyncUDP::listenIPv6()
+{
+    if(!_pcb || _pcb->remote_ip.type != IPADDR_TYPE_V6){
+        return IPv6Address();
+    }
+    return IPv6Address(_pcb->remote_ip.u_addr.ip6.addr);
+}
+
+size_t AsyncUDP::write(const uint8_t *data, size_t len)
+{
+    return writeTo(data, len, &(_pcb->remote_ip), _pcb->remote_port);
+}
+
+size_t AsyncUDP::write(uint8_t data)
+{
+    return write(&data, 1);
+}
+
+size_t AsyncUDP::broadcastTo(uint8_t *data, size_t len, uint16_t port, tcpip_adapter_if_t tcpip_if)
+{
+    return writeTo(data, len, IP_ADDR_BROADCAST, port, tcpip_if);
+}
+
+size_t AsyncUDP::broadcastTo(const char * data, uint16_t port, tcpip_adapter_if_t tcpip_if)
+{
+    return broadcastTo((uint8_t *)data, strlen(data), port, tcpip_if);
+}
+
+size_t AsyncUDP::broadcast(uint8_t *data, size_t len)
+{
+    if(_pcb->local_port != 0) {
+        return broadcastTo(data, len, _pcb->local_port);
+    }
+    return 0;
+}
+
+size_t AsyncUDP::broadcast(const char * data)
+{
+    return broadcast((uint8_t *)data, strlen(data));
+}
+
+
+size_t AsyncUDP::sendTo(AsyncUDPMessage &message, const ip_addr_t *addr, uint16_t port, tcpip_adapter_if_t tcpip_if)
+{
+    if(!message) {
+        return 0;
+    }
+    return writeTo(message.data(), message.length(), addr, port, tcpip_if);
+}
+
+size_t AsyncUDP::sendTo(AsyncUDPMessage &message, const IPAddress addr, uint16_t port, tcpip_adapter_if_t tcpip_if)
+{
+    if(!message) {
+        return 0;
+    }
+    return writeTo(message.data(), message.length(), addr, port, tcpip_if);
+}
+
+size_t AsyncUDP::sendTo(AsyncUDPMessage &message, const IPv6Address addr, uint16_t port, tcpip_adapter_if_t tcpip_if)
+{
+    if(!message) {
+        return 0;
+    }
+    return writeTo(message.data(), message.length(), addr, port, tcpip_if);
+}
+
+size_t AsyncUDP::send(AsyncUDPMessage &message)
+{
+    if(!message) {
+        return 0;
+    }
+    return writeTo(message.data(), message.length(), &(_pcb->remote_ip), _pcb->remote_port);
+}
+
+size_t AsyncUDP::broadcastTo(AsyncUDPMessage &message, uint16_t port, tcpip_adapter_if_t tcpip_if)
+{
+    if(!message) {
+        return 0;
+    }
+    return broadcastTo(message.data(), message.length(), port, tcpip_if);
+}
+
+size_t AsyncUDP::broadcast(AsyncUDPMessage &message)
+{
+    if(!message) {
+        return 0;
+    }
+    return broadcast(message.data(), message.length());
+}
+
+AsyncUDP::operator bool()
+{
+    return _connected;
+}
+
+bool AsyncUDP::connected()
+{
+    return _connected;
+}
+
+void AsyncUDP::onPacket(AuPacketHandlerFunctionWithArg cb, void * arg)
+{
+    onPacket(std::bind(cb, arg, std::placeholders::_1));
+}
+
+void AsyncUDP::onPacket(AuPacketHandlerFunction cb)
+{
+    _handler = cb;
+}

libraries/AsyncUDP/src/AsyncUDP.h

@@ -0,0 +1,149 @@
+#ifndef ESPASYNCUDP_H
+#define ESPASYNCUDP_H
+
+#include "IPAddress.h"
+#include "IPv6Address.h"
+#include "Print.h"
+#include <functional>
+extern "C" {
+#include "lwip/ip_addr.h"
+#include <tcpip_adapter.h>
+#include "freertos/queue.h"
+#include "freertos/semphr.h"
+}
+
+class AsyncUDP;
+class AsyncUDPPacket;
+class AsyncUDPMessage;
+struct udp_pcb;
+struct pbuf;
+struct netif;
+
+typedef std::function<void(AsyncUDPPacket& packet)> AuPacketHandlerFunction;
+typedef std::function<void(void * arg, AsyncUDPPacket& packet)> AuPacketHandlerFunctionWithArg;
+
+class AsyncUDPMessage : public Print
+{
+protected:
+    uint8_t *_buffer;
+    size_t _index;
+    size_t _size;
+public:
+    AsyncUDPMessage(size_t size=CONFIG_TCP_MSS);
+    virtual ~AsyncUDPMessage();
+    size_t write(const uint8_t *data, size_t len);
+    size_t write(uint8_t data);
+    size_t space();
+    uint8_t * data();
+    size_t length();
+    void flush();
+    operator bool()
+    {
+        return _buffer != NULL;
+    }
+};
+
+class AsyncUDPPacket : public Stream
+{
+protected:
+    AsyncUDP *_udp;
+    pbuf *_pb;
+    tcpip_adapter_if_t _if;
+    ip_addr_t _localIp;
+    uint16_t _localPort;
+    ip_addr_t _remoteIp;
+    uint16_t _remotePort;
+    uint8_t *_data;
+    size_t _len;
+    size_t _index;
+public:
+    AsyncUDPPacket(AsyncUDP *udp, pbuf *pb, const ip_addr_t *addr, uint16_t port, struct netif * netif);
+    virtual ~AsyncUDPPacket();
+
+    uint8_t * data();
+    size_t length();
+    bool isBroadcast();
+    bool isMulticast();
+    bool isIPv6();
+
+    tcpip_adapter_if_t interface();
+
+    IPAddress localIP();
+    IPv6Address localIPv6();
+    uint16_t localPort();
+    IPAddress remoteIP();
+    IPv6Address remoteIPv6();
+    uint16_t remotePort();
+
+    size_t send(AsyncUDPMessage &message);
+
+    int available();
+    size_t read(uint8_t *data, size_t len);
+    int read();
+    int peek();
+    void flush();
+
+    size_t write(const uint8_t *data, size_t len);
+    size_t write(uint8_t data);
+};
+
+class AsyncUDP : public Print
+{
+protected:
+    udp_pcb *_pcb;
+    //xSemaphoreHandle _lock;
+    bool _connected;
+    AuPacketHandlerFunction _handler;
+
+    void _recv(udp_pcb *upcb, pbuf *pb, const ip_addr_t *addr, uint16_t port, struct netif * netif);
+
+public:
+    AsyncUDP();
+    virtual ~AsyncUDP();
+
+    void onPacket(AuPacketHandlerFunctionWithArg cb, void * arg=NULL);
+    void onPacket(AuPacketHandlerFunction cb);
+
+    bool listen(const ip_addr_t *addr, uint16_t port);
+    bool listen(const IPAddress addr, uint16_t port);
+    bool listen(const IPv6Address addr, uint16_t port);
+    bool listen(uint16_t port);
+
+    bool listenMulticast(const ip_addr_t *addr, uint16_t port, uint8_t ttl=1, tcpip_adapter_if_t tcpip_if=TCPIP_ADAPTER_IF_STA);
+    bool listenMulticast(const IPAddress addr, uint16_t port, uint8_t ttl=1, tcpip_adapter_if_t tcpip_if=TCPIP_ADAPTER_IF_STA);
+    bool listenMulticast(const IPv6Address addr, uint16_t port, uint8_t ttl=1, tcpip_adapter_if_t tcpip_if=TCPIP_ADAPTER_IF_STA);
+
+    bool connect(const ip_addr_t *addr, uint16_t port);
+    bool connect(const IPAddress addr, uint16_t port);
+    bool connect(const IPv6Address addr, uint16_t port);
+
+    void close();
+
+    size_t writeTo(const uint8_t *data, size_t len, const ip_addr_t *addr, uint16_t port, tcpip_adapter_if_t tcpip_if=TCPIP_ADAPTER_IF_MAX);
+    size_t writeTo(const uint8_t *data, size_t len, const IPAddress addr, uint16_t port, tcpip_adapter_if_t tcpip_if=TCPIP_ADAPTER_IF_MAX);
+    size_t writeTo(const uint8_t *data, size_t len, const IPv6Address addr, uint16_t port, tcpip_adapter_if_t tcpip_if=TCPIP_ADAPTER_IF_MAX);
+    size_t write(const uint8_t *data, size_t len);
+    size_t write(uint8_t data);
+
+    size_t broadcastTo(uint8_t *data, size_t len, uint16_t port, tcpip_adapter_if_t tcpip_if=TCPIP_ADAPTER_IF_MAX);
+    size_t broadcastTo(const char * data, uint16_t port, tcpip_adapter_if_t tcpip_if=TCPIP_ADAPTER_IF_MAX);
+    size_t broadcast(uint8_t *data, size_t len);
+    size_t broadcast(const char * data);
+
+    size_t sendTo(AsyncUDPMessage &message, const ip_addr_t *addr, uint16_t port, tcpip_adapter_if_t tcpip_if=TCPIP_ADAPTER_IF_MAX);
+    size_t sendTo(AsyncUDPMessage &message, const IPAddress addr, uint16_t port, tcpip_adapter_if_t tcpip_if=TCPIP_ADAPTER_IF_MAX);
+    size_t sendTo(AsyncUDPMessage &message, const IPv6Address addr, uint16_t port, tcpip_adapter_if_t tcpip_if=TCPIP_ADAPTER_IF_MAX);
+    size_t send(AsyncUDPMessage &message);
+
+    size_t broadcastTo(AsyncUDPMessage &message, uint16_t port, tcpip_adapter_if_t tcpip_if=TCPIP_ADAPTER_IF_MAX);
+    size_t broadcast(AsyncUDPMessage &message);
+
+    IPAddress listenIP();
+    IPv6Address listenIPv6();
+    bool connected();
+    operator bool();
+
+    static void _s_recv(void *arg, udp_pcb *upcb, pbuf *p, const ip_addr_t *addr, uint16_t port, struct netif * netif);
+};
+
+#endif

libraries/BLE

@@ -1 +1 @@
-Subproject commit af865a916795289c8e7e09b091ff2140c33fc3fe
+Subproject commit 7951347ed68313d75c367e1f2cce763cb56d1eb2

libraries/BluetoothSerial/src/BluetoothSerial.cpp

@@ -40,63 +40,57 @@
 #include "esp32-hal-log.h"
 #endif
 
-#define SPP_SERVER_NAME "ESP32_SPP_SERVER"
-#define SPP_TAG "BluetoothSerial"
+const char * _spp_server_name = "ESP32_SPP_SERVER";
 
 #define QUEUE_SIZE 256
-uint32_t client;
-xQueueHandle SerialQueueBT;
-
-static const esp_spp_mode_t esp_spp_mode = ESP_SPP_MODE_CB;
-static const esp_spp_sec_t sec_mask = ESP_SPP_SEC_NONE;
-static const esp_spp_role_t role_slave = ESP_SPP_ROLE_SLAVE;
+static uint32_t _spp_client = 0;
+static xQueueHandle _spp_queue = NULL;
 
 static void esp_spp_cb(esp_spp_cb_event_t event, esp_spp_cb_param_t *param)
 {
     switch (event)
     {
     case ESP_SPP_INIT_EVT:
-        ESP_LOGI(SPP_TAG, "ESP_SPP_INIT_EVT");
+        log_i("ESP_SPP_INIT_EVT");
         esp_bt_gap_set_scan_mode(ESP_BT_SCAN_MODE_CONNECTABLE_DISCOVERABLE);
-        esp_spp_start_srv(sec_mask, role_slave, 0, SPP_SERVER_NAME);
+        esp_spp_start_srv(ESP_SPP_SEC_NONE, ESP_SPP_ROLE_SLAVE, 0, _spp_server_name);
         break;
-    case ESP_SPP_DISCOVERY_COMP_EVT:
-        ESP_LOGI(SPP_TAG, "ESP_SPP_DISCOVERY_COMP_EVT");
+    case ESP_SPP_DISCOVERY_COMP_EVT://discovery complete
+        log_i("ESP_SPP_DISCOVERY_COMP_EVT");
         break;
-    case ESP_SPP_OPEN_EVT:
-        ESP_LOGI(SPP_TAG, "ESP_SPP_OPEN_EVT");
+    case ESP_SPP_OPEN_EVT://Client connection open
+        log_i("ESP_SPP_OPEN_EVT");
         break;
-    case ESP_SPP_CLOSE_EVT:
-        client = 0;
-        ESP_LOGI(SPP_TAG, "ESP_SPP_CLOSE_EVT");
+    case ESP_SPP_CLOSE_EVT://Client connection closed
+        _spp_client = 0;
+        log_i("ESP_SPP_CLOSE_EVT");
         break;
-    case ESP_SPP_START_EVT:
-        ESP_LOGI(SPP_TAG, "ESP_SPP_START_EVT");
+    case ESP_SPP_START_EVT://server started
+        log_i("ESP_SPP_START_EVT");
         break;
-    case ESP_SPP_CL_INIT_EVT:
-        ESP_LOGI(SPP_TAG, "ESP_SPP_CL_INIT_EVT");
+    case ESP_SPP_CL_INIT_EVT://client initiated a connection
+        log_i("ESP_SPP_CL_INIT_EVT");
         break;
-    case ESP_SPP_DATA_IND_EVT:
-        ESP_LOGV(SPP_TAG, "ESP_SPP_DATA_IND_EVT len=%d handle=%d", param->data_ind.len, param->data_ind.handle);
+    case ESP_SPP_DATA_IND_EVT://connection received data
+        log_v("ESP_SPP_DATA_IND_EVT len=%d handle=%d", param->data_ind.len, param->data_ind.handle);
         //esp_log_buffer_hex("",param->data_ind.data,param->data_ind.len); //for low level debug
 
-        if (SerialQueueBT != 0){
+        if (_spp_queue != NULL){
             for (int i = 0; i < param->data_ind.len; i++)
-                xQueueSend(SerialQueueBT, param->data_ind.data + i, (TickType_t)0);
-        }
-        else {
-            ESP_LOGE(SPP_TAG, "SerialQueueBT ERROR");
+                xQueueSend(_spp_queue, param->data_ind.data + i, (TickType_t)0);
+        } else {
+            log_e("SerialQueueBT ERROR");
         }
         break;
-    case ESP_SPP_CONG_EVT:
-        ESP_LOGI(SPP_TAG, "ESP_SPP_CONG_EVT");
+    case ESP_SPP_CONG_EVT://connection congestion status changed
+        log_i("ESP_SPP_CONG_EVT");
         break;
-    case ESP_SPP_WRITE_EVT:
-        ESP_LOGV(SPP_TAG, "ESP_SPP_WRITE_EVT");
+    case ESP_SPP_WRITE_EVT://write operation completed
+        log_v("ESP_SPP_WRITE_EVT");
         break;
-    case ESP_SPP_SRV_OPEN_EVT:
-        client = param->open.handle;
-        ESP_LOGI(SPP_TAG, "ESP_SPP_SRV_OPEN_EVT");
+    case ESP_SPP_SRV_OPEN_EVT://Server connection open
+        _spp_client = param->open.handle;
+        log_i("ESP_SPP_SRV_OPEN_EVT");
         break;
     default:
         break;
@@ -106,38 +100,38 @@ static void esp_spp_cb(esp_spp_cb_event_t event, esp_spp_cb_param_t *param)
 static bool _init_bt(const char *deviceName)
 {
     if (!btStarted() && !btStart()){
-        ESP_LOGE(SPP_TAG, "%s initialize controller failed\n", __func__);
+        log_e("%s initialize controller failed\n", __func__);
         return false;
     }
     
     esp_bluedroid_status_t bt_state = esp_bluedroid_get_status();
     if (bt_state == ESP_BLUEDROID_STATUS_UNINITIALIZED){
         if (esp_bluedroid_init()) {
-            ESP_LOGE(SPP_TAG, "%s initialize bluedroid failed\n", __func__);
+            log_e("%s initialize bluedroid failed\n", __func__);
             return false;
         }
     }
     
     if (bt_state != ESP_BLUEDROID_STATUS_ENABLED){
         if (esp_bluedroid_enable()) {
-            ESP_LOGE(SPP_TAG, "%s enable bluedroid failed\n", __func__);
+            log_e("%s enable bluedroid failed\n", __func__);
             return false;
         }
     }
 
     if (esp_spp_register_callback(esp_spp_cb) != ESP_OK){
-        ESP_LOGE(SPP_TAG, "%s spp register failed\n", __func__);
+        log_e("%s spp register failed\n", __func__);
         return false;
     }
 
-    if (esp_spp_init(esp_spp_mode) != ESP_OK){
-        ESP_LOGE(SPP_TAG, "%s spp init failed\n", __func__);
+    if (esp_spp_init(ESP_SPP_MODE_CB) != ESP_OK){
+        log_e("%s spp init failed\n", __func__);
         return false;
     }
 
-    SerialQueueBT = xQueueCreate(QUEUE_SIZE, sizeof(uint8_t)); //initialize the queue
-    if (SerialQueueBT == NULL){
-        ESP_LOGE(SPP_TAG, "%s Queue creation error\n", __func__);
+    _spp_queue = xQueueCreate(QUEUE_SIZE, sizeof(uint8_t)); //initialize the queue
+    if (_spp_queue == NULL){
+        log_e("%s Queue creation error\n", __func__);
         return false;
     }
     esp_bt_dev_set_device_name(deviceName);
@@ -180,21 +174,21 @@ bool BluetoothSerial::begin(String localName)
 
 int BluetoothSerial::available(void)
 {
-    if (!client || SerialQueueBT == NULL){
+    if (!_spp_client || _spp_queue == NULL){
         return 0;
     }
-    return uxQueueMessagesWaiting(SerialQueueBT);
+    return uxQueueMessagesWaiting(_spp_queue);
 }
 
 int BluetoothSerial::peek(void)
 {
     if (available()){
-        if (!client || SerialQueueBT == NULL){
+        if (!_spp_client || _spp_queue == NULL){
             return 0;
         }
 
         uint8_t c;
-        if (xQueuePeek(SerialQueueBT, &c, 0)){
+        if (xQueuePeek(_spp_queue, &c, 0)){
             return c;
         }
     }
@@ -203,7 +197,7 @@ int BluetoothSerial::peek(void)
 
 bool BluetoothSerial::hasClient(void)
 {
-    if (client)
+    if (_spp_client)
         return true;
 	
     return false;
@@ -212,12 +206,12 @@ bool BluetoothSerial::hasClient(void)
 int BluetoothSerial::read(void)
 {
     if (available()){
-        if (!client || SerialQueueBT == NULL){
+        if (!_spp_client || _spp_queue == NULL){
             return 0;
         }
 
         uint8_t c;
-        if (xQueueReceive(SerialQueueBT, &c, 0)){
+        if (xQueueReceive(_spp_queue, &c, 0)){
             return c;
         }
     }
@@ -226,10 +220,10 @@ int BluetoothSerial::read(void)
 
 size_t BluetoothSerial::write(uint8_t c)
 {
-    if (client){
+    if (_spp_client){
         uint8_t buffer[1];
         buffer[0] = c;
-        esp_spp_write(client, 1, buffer);
+        esp_spp_write(_spp_client, 1, buffer);
         return 1;
     }
     return -1;
@@ -237,18 +231,18 @@ size_t BluetoothSerial::write(uint8_t c)
 
 size_t BluetoothSerial::write(const uint8_t *buffer, size_t size)
 {
-    if (client){
-        esp_spp_write(client, size, (uint8_t *)buffer);
+    if (_spp_client){
+        esp_spp_write(_spp_client, size, (uint8_t *)buffer);
     }
     return size;
 }
 
 void BluetoothSerial::flush()
 {
-    if (client){
+    if (_spp_client){
         int qsize = available();
         uint8_t buffer[qsize];
-        esp_spp_write(client, qsize, buffer);
+        esp_spp_write(_spp_client, qsize, buffer);
     }
 }
 

libraries/EEPROM/EEPROM.cpp

@@ -29,14 +29,14 @@
 
 #include <esp_log.h>
 
-static const char* TAG = "eeprom";
-
 EEPROMClass::EEPROMClass(uint32_t sector)
   : _sector(sector)
   , _data(0)
   , _size(0)
   , _dirty(false)
+  , _mypart(NULL)
   , _name("eeprom")
+  , _user_defined_size(0)
 {
 }
 
@@ -45,6 +45,7 @@ EEPROMClass::EEPROMClass(const char* name, uint32_t user_defined_size)
   , _data(0)
   , _size(0)
   , _dirty(false)
+  , _mypart(NULL)
   , _name(name)
   , _user_defined_size(user_defined_size)
 {
@@ -55,7 +56,9 @@ EEPROMClass::EEPROMClass(void)
   , _data(0)
   , _size(0)
   , _dirty(false)
+  , _mypart(NULL)
   , _name("eeprom")
+  , _user_defined_size(0)
 {
 }
 
@@ -178,85 +181,85 @@ uint16_t EEPROMClass::length ()
 */
 uint8_t EEPROMClass::readByte (int address)
 {
-  uint8_t value;
+  uint8_t value = 0;
   return EEPROMClass::readAll (address, value);
 }
 
 int8_t EEPROMClass::readChar (int address)
 {
-  int8_t value;
+  int8_t value = 0;
   return EEPROMClass::readAll (address, value);
 }
 
 uint8_t EEPROMClass::readUChar (int address)
 {
-  uint8_t value;
+  uint8_t value = 0;
   return EEPROMClass::readAll (address, value);
 }
 
 int16_t EEPROMClass::readShort (int address)
 {
-  int16_t value;
+  int16_t value = 0;
   return EEPROMClass::readAll (address, value);
 }
 
 uint16_t EEPROMClass::readUShort (int address)
 {
-  uint16_t value;
+  uint16_t value = 0;
   return EEPROMClass::readAll (address, value);
 }
 
 int32_t EEPROMClass::readInt (int address)
 {
-  int32_t value;
+  int32_t value = 0;
   return EEPROMClass::readAll (address, value);
 }
 
 uint32_t EEPROMClass::readUInt (int address)
 {
-  uint32_t value;
+  uint32_t value = 0;
   return EEPROMClass::readAll (address, value);
 }
 
 int32_t EEPROMClass::readLong (int address)
 {
-  int32_t value;
+  int32_t value = 0;
   return EEPROMClass::readAll (address, value);
 }
 
 uint32_t EEPROMClass::readULong (int address)
 {
-  uint32_t value;
+  uint32_t value = 0;
   return EEPROMClass::readAll (address, value);
 }
 
 int64_t EEPROMClass::readLong64 (int address)
 {
-  int64_t value;
+  int64_t value = 0;
   return EEPROMClass::readAll (address, value);
 }
 
 uint64_t EEPROMClass::readULong64 (int address)
 {
-  uint64_t value;
+  uint64_t value = 0;
   return EEPROMClass::readAll (address, value);
 }
 
 float_t EEPROMClass::readFloat (int address)
 {
-  float_t value;
+  float_t value = 0;
   return EEPROMClass::readAll (address, value);
 }
 
 double_t EEPROMClass::readDouble (int address)
 {
-  double_t value;
+  double_t value = 0;
   return EEPROMClass::readAll (address, value);
 }
 
 bool EEPROMClass::readBool (int address)
 {
-  int8_t value;
+  int8_t value = 0;
   return EEPROMClass::readAll (address, value) ? 1 : 0;
 }
 

libraries/NetBIOS/examples/ESP_NBNST/ESP_NBNST.ino

@@ -0,0 +1,31 @@
+#include <WiFi.h>
+#include <NetBIOS.h>
+
+const char* ssid = "............";
+const char* password = "..............";
+
+void setup() {
+  Serial.begin(115200);
+
+  // Connect to WiFi network
+  WiFi.mode(WIFI_STA);
+  WiFi.begin(ssid, password);
+  Serial.println("");
+
+  // Wait for connection
+  while (WiFi.status() != WL_CONNECTED) {
+    delay(500);
+    Serial.print(".");
+  }
+  Serial.println("");
+  Serial.print("Connected to ");
+  Serial.println(ssid);
+  Serial.print("IP address: ");
+  Serial.println(WiFi.localIP());
+
+  NBNS.begin("ESP");
+}
+
+void loop() {
+  
+}

libraries/NetBIOS/keywords.txt

@@ -0,0 +1,25 @@
+#######################################
+# Syntax Coloring Map For ESPNBNS
+#######################################
+
+#######################################
+# Datatypes (KEYWORD1)
+#######################################
+
+NetBIOS	KEYWORD1
+
+#######################################
+# Methods and Functions (KEYWORD2)
+#######################################
+
+begin	KEYWORD2
+
+#######################################
+# Instances (KEYWORD2)
+#######################################
+
+NBNS	KEYWORD2
+
+#######################################
+# Constants (LITERAL1)
+#######################################

libraries/NetBIOS/library.properties

@@ -0,0 +1,9 @@
+name=NetBIOS
+version=1.0
+author=Pablo@xpablo.cz
+maintainer=Hristo Gochkov<hristo@espressif.com>
+sentence=Enables NBNS (NetBIOS) name resolution.
+paragraph=With this library you can connect to your ESP from Windows using a short name
+category=Communication
+url=http://www.xpablo.cz/?p=751#more-751
+architectures=esp32

libraries/NetBIOS/src/NetBIOS.cpp

@@ -0,0 +1,131 @@
+#include "NetBIOS.h"
+
+#include <functional>
+
+#define NBNS_PORT 137
+#define NBNS_MAX_HOSTNAME_LEN 32
+
+typedef struct {
+    uint16_t id;
+    uint8_t flags1;
+    uint8_t flags2;
+    uint16_t qcount;
+    uint16_t acount;
+    uint16_t nscount;
+    uint16_t adcount;
+    uint8_t name_len;
+    char name[NBNS_MAX_HOSTNAME_LEN + 1];
+    uint16_t type;
+    uint16_t clas;
+} __attribute__((packed)) nbns_question_t;
+
+typedef struct {
+    uint16_t id;
+    uint8_t flags1;
+    uint8_t flags2;
+    uint16_t qcount;
+    uint16_t acount;
+    uint16_t nscount;
+    uint16_t adcount;
+    uint8_t name_len;
+    char name[NBNS_MAX_HOSTNAME_LEN + 1];
+    uint16_t type;
+    uint16_t clas;
+    uint32_t ttl;
+    uint16_t data_len;
+    uint16_t flags;
+    uint32_t addr;
+} __attribute__((packed)) nbns_answer_t;
+
+static void _getnbname(const char *nbname, char *name, uint8_t maxlen){
+    uint8_t b;
+    uint8_t c = 0;
+
+    while ((*nbname) && (c < maxlen)) {
+        b = (*nbname++ - 'A') << 4;
+        c++;
+        if (*nbname) {
+            b |= *nbname++ - 'A';
+            c++;
+        }
+        if(!b || b == ' '){
+            break;
+        }
+        *name++ = b;
+    }
+    *name = 0;
+}
+
+static void append_16(void * dst, uint16_t value){
+    uint8_t * d = (uint8_t *)dst;
+    *d++ = (value >> 8) & 0xFF;
+    *d++ = value & 0xFF;
+}
+
+static void append_32(void * dst, uint32_t value){
+    uint8_t * d = (uint8_t *)dst;
+    *d++ = (value >> 24) & 0xFF;
+    *d++ = (value >> 16) & 0xFF;
+    *d++ = (value >> 8) & 0xFF;
+    *d++ = value & 0xFF;
+}
+
+void NetBIOS::_onPacket(AsyncUDPPacket& packet){
+    if (packet.length() >= sizeof(nbns_question_t)) {
+        nbns_question_t * question = (nbns_question_t *)packet.data();
+        if (0 == (question->flags1 & 0x80)) {
+            char name[ NBNS_MAX_HOSTNAME_LEN + 1 ];
+            _getnbname(&question->name[0], (char *)&name, question->name_len);
+            if (_name.equals(name)) {
+                nbns_answer_t nbnsa;
+                nbnsa.id = question->id;
+                nbnsa.flags1 = 0x85;
+                nbnsa.flags2 = 0;
+                append_16((void *)&nbnsa.qcount, 0);
+                append_16((void *)&nbnsa.acount, 1);
+                append_16((void *)&nbnsa.nscount, 0);
+                append_16((void *)&nbnsa.adcount, 0);
+                nbnsa.name_len = question->name_len;
+                memcpy(&nbnsa.name[0], &question->name[0], question->name_len + 1);
+                append_16((void *)&nbnsa.type, 0x20);
+                append_16((void *)&nbnsa.clas, 1);
+                append_32((void *)&nbnsa.ttl, 300000);
+                append_16((void *)&nbnsa.data_len, 6);
+                append_16((void *)&nbnsa.flags, 0);
+                nbnsa.addr = WiFi.localIP();
+                _udp.writeTo((uint8_t *)&nbnsa, sizeof(nbnsa), packet.remoteIP(), NBNS_PORT);
+            }
+        }
+    }
+}
+
+NetBIOS::NetBIOS(){
+
+}
+NetBIOS::~NetBIOS(){
+    end();
+}
+
+bool NetBIOS::begin(const char *name){
+    _name = name;
+    _name.toUpperCase();
+
+    if(_udp.connected()){
+        return true;
+    }
+
+    _udp.onPacket([](void * arg, AsyncUDPPacket& packet){ ((NetBIOS*)(arg))->_onPacket(packet); }, this);
+    return _udp.listen(NBNS_PORT);
+}
+
+void NetBIOS::end(){
+    if(_udp.connected()){
+        _udp.close();
+    }
+}
+
+#if !defined(NO_GLOBAL_INSTANCES) && !defined(NO_GLOBAL_NETBIOS)
+NetBIOS NBNS;
+#endif
+
+// EOF

libraries/NetBIOS/src/NetBIOS.h

@@ -0,0 +1,26 @@
+//
+#ifndef __ESPNBNS_h__
+#define __ESPNBNS_h__
+
+#include <WiFi.h>
+#include "AsyncUDP.h"
+
+class NetBIOS
+{
+protected:
+    AsyncUDP _udp;
+    String _name;
+    void _onPacket(AsyncUDPPacket& packet);
+
+public:
+    NetBIOS();
+    ~NetBIOS();
+    bool begin(const char *name);
+    void end();
+};
+
+#if !defined(NO_GLOBAL_INSTANCES) && !defined(NO_GLOBAL_NETBIOS)
+extern NetBIOS NBNS;
+#endif
+
+#endif

libraries/SD_MMC/src/SD_MMC.cpp

@@ -42,7 +42,21 @@ bool SDMMCFS::begin(const char * mountpoint, bool mode1bit)
     }
     //mount
     sdmmc_slot_config_t slot_config = SDMMC_SLOT_CONFIG_DEFAULT();
-    sdmmc_host_t host = SDMMC_HOST_DEFAULT();
+    sdmmc_host_t host = {
+        .flags = SDMMC_HOST_FLAG_4BIT,
+        .slot = SDMMC_HOST_SLOT_1,
+        .max_freq_khz = SDMMC_FREQ_DEFAULT,
+        .io_voltage = 3.3f,
+        .init = &sdmmc_host_init,
+        .set_bus_width = &sdmmc_host_set_bus_width,
+        .get_bus_width = &sdmmc_host_get_slot_width,
+        .set_card_clk = &sdmmc_host_set_card_clk,
+        .do_transaction = &sdmmc_host_do_transaction,
+        .deinit = &sdmmc_host_deinit,
+        .io_int_enable = sdmmc_host_io_int_enable,
+        .io_int_wait = sdmmc_host_io_int_wait,
+        .command_timeout_ms = 0,
+    };
     host.max_freq_khz = SDMMC_FREQ_HIGHSPEED;
 #ifdef BOARD_HAS_1BIT_SDMMC
     mode1bit = true;
@@ -53,7 +67,8 @@ bool SDMMCFS::begin(const char * mountpoint, bool mode1bit)
 
     esp_vfs_fat_sdmmc_mount_config_t mount_config = {
         .format_if_mount_failed = false,
-        .max_files = 5
+        .max_files = 5,
+        .allocation_unit_size = 0
     };
 
     esp_err_t ret = esp_vfs_fat_sdmmc_mount(mountpoint, &host, &slot_config, &mount_config, &_card);

libraries/SimpleBLE/src/SimpleBLE.cpp

@@ -19,8 +19,7 @@
 #include "SimpleBLE.h"
 #include "esp32-hal-log.h"
 
-#include "bt.h"
-#include "bta_api.h"
+#include "esp_bt.h"
 #include "esp_gap_ble_api.h"
 #include "esp_gatts_api.h"
 #include "esp_bt_defs.h"

libraries/SimpleBLE/src/SimpleBLE.h

@@ -25,7 +25,7 @@
 #include <cstring>
 #include "freertos/FreeRTOS.h"
 #include "freertos/task.h"
-#include "bt.h"
+#include "esp_bt.h"
 
 #include "Arduino.h"
 

libraries/WebServer/examples/AdvancedWebServer/AdvancedWebServer.ino

@@ -0,0 +1,146 @@
+/*
+   Copyright (c) 2015, Majenko Technologies
+   All rights reserved.
+
+   Redistribution and use in source and binary forms, with or without modification,
+   are permitted provided that the following conditions are met:
+
+ * * Redistributions of source code must retain the above copyright notice, this
+     list of conditions and the following disclaimer.
+
+ * * Redistributions in binary form must reproduce the above copyright notice, this
+     list of conditions and the following disclaimer in the documentation and/or
+     other materials provided with the distribution.
+
+ * * Neither the name of Majenko Technologies nor the names of its
+     contributors may be used to endorse or promote products derived from
+     this software without specific prior written permission.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+   ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+   WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+   DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+   ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+   (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+   LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+   ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#include <WiFi.h>
+#include <WiFiClient.h>
+#include <WebServer.h>
+#include <ESPmDNS.h>
+
+const char *ssid = "YourSSIDHere";
+const char *password = "YourPSKHere";
+
+WebServer server(80);
+
+const int led = 13;
+
+void handleRoot() {
+  digitalWrite(led, 1);
+  char temp[400];
+  int sec = millis() / 1000;
+  int min = sec / 60;
+  int hr = min / 60;
+
+  snprintf(temp, 400,
+
+           "<html>\
+  <head>\
+    <meta http-equiv='refresh' content='5'/>\
+    <title>ESP32 Demo</title>\
+    <style>\
+      body { background-color: #cccccc; font-family: Arial, Helvetica, Sans-Serif; Color: #000088; }\
+    </style>\
+  </head>\
+  <body>\
+    <h1>Hello from ESP32!</h1>\
+    <p>Uptime: %02d:%02d:%02d</p>\
+    <img src=\"/test.svg\" />\
+  </body>\
+</html>",
+
+           hr, min % 60, sec % 60
+          );
+  server.send(200, "text/html", temp);
+  digitalWrite(led, 0);
+}
+
+void handleNotFound() {
+  digitalWrite(led, 1);
+  String message = "File Not Found\n\n";
+  message += "URI: ";
+  message += server.uri();
+  message += "\nMethod: ";
+  message += (server.method() == HTTP_GET) ? "GET" : "POST";
+  message += "\nArguments: ";
+  message += server.args();
+  message += "\n";
+
+  for (uint8_t i = 0; i < server.args(); i++) {
+    message += " " + server.argName(i) + ": " + server.arg(i) + "\n";
+  }
+
+  server.send(404, "text/plain", message);
+  digitalWrite(led, 0);
+}
+
+void setup(void) {
+  pinMode(led, OUTPUT);
+  digitalWrite(led, 0);
+  Serial.begin(115200);
+  WiFi.mode(WIFI_STA);
+  WiFi.begin(ssid, password);
+  Serial.println("");
+
+  // Wait for connection
+  while (WiFi.status() != WL_CONNECTED) {
+    delay(500);
+    Serial.print(".");
+  }
+
+  Serial.println("");
+  Serial.print("Connected to ");
+  Serial.println(ssid);
+  Serial.print("IP address: ");
+  Serial.println(WiFi.localIP());
+
+  if (MDNS.begin("esp32")) {
+    Serial.println("MDNS responder started");
+  }
+
+  server.on("/", handleRoot);
+  server.on("/test.svg", drawGraph);
+  server.on("/inline", []() {
+    server.send(200, "text/plain", "this works as well");
+  });
+  server.onNotFound(handleNotFound);
+  server.begin();
+  Serial.println("HTTP server started");
+}
+
+void loop(void) {
+  server.handleClient();
+}
+
+void drawGraph() {
+  String out = "";
+  char temp[100];
+  out += "<svg xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\" width=\"400\" height=\"150\">\n";
+  out += "<rect width=\"400\" height=\"150\" fill=\"rgb(250, 230, 210)\" stroke-width=\"1\" stroke=\"rgb(0, 0, 0)\" />\n";
+  out += "<g stroke=\"black\">\n";
+  int y = rand() % 130;
+  for (int x = 10; x < 390; x += 10) {
+    int y2 = rand() % 130;
+    sprintf(temp, "<line x1=\"%d\" y1=\"%d\" x2=\"%d\" y2=\"%d\" stroke-width=\"1\" />\n", x, 140 - y, x + 10, 140 - y2);
+    out += temp;
+    y = y2;
+  }
+  out += "</g>\n</svg>\n";
+
+  server.send(200, "image/svg+xml", out);
+}

libraries/WebServer/examples/FSBrowser/FSBrowser.ino

@@ -0,0 +1,294 @@
+/*
+  FSWebServer - Example WebServer with SPIFFS backend for esp8266
+  Copyright (c) 2015 Hristo Gochkov. All rights reserved.
+  This file is part of the WebServer library for Arduino environment.
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+  upload the contents of the data folder with MkSPIFFS Tool ("ESP32 Sketch Data Upload" in Tools menu in Arduino IDE)
+  or you can upload the contents of a folder if you CD in that folder and run the following command:
+  for file in `ls -A1`; do curl -F "file=@$PWD/$file" esp32fs.local/edit; done
+
+  access the sample web page at http://esp32fs.local
+  edit the page by going to http://esp32fs.local/edit
+*/
+#include <WiFi.h>
+#include <WiFiClient.h>
+#include <WebServer.h>
+#include <ESPmDNS.h>
+#include <SPIFFS.h>
+
+#define DBG_OUTPUT_PORT Serial
+
+const char* ssid = "wifi-ssid";
+const char* password = "wifi-password";
+const char* host = "esp32fs";
+
+WebServer server(80);
+//holds the current upload
+File fsUploadFile;
+
+//format bytes
+String formatBytes(size_t bytes) {
+  if (bytes < 1024) {
+    return String(bytes) + "B";
+  } else if (bytes < (1024 * 1024)) {
+    return String(bytes / 1024.0) + "KB";
+  } else if (bytes < (1024 * 1024 * 1024)) {
+    return String(bytes / 1024.0 / 1024.0) + "MB";
+  } else {
+    return String(bytes / 1024.0 / 1024.0 / 1024.0) + "GB";
+  }
+}
+
+String getContentType(String filename) {
+  if (server.hasArg("download")) {
+    return "application/octet-stream";
+  } else if (filename.endsWith(".htm")) {
+    return "text/html";
+  } else if (filename.endsWith(".html")) {
+    return "text/html";
+  } else if (filename.endsWith(".css")) {
+    return "text/css";
+  } else if (filename.endsWith(".js")) {
+    return "application/javascript";
+  } else if (filename.endsWith(".png")) {
+    return "image/png";
+  } else if (filename.endsWith(".gif")) {
+    return "image/gif";
+  } else if (filename.endsWith(".jpg")) {
+    return "image/jpeg";
+  } else if (filename.endsWith(".ico")) {
+    return "image/x-icon";
+  } else if (filename.endsWith(".xml")) {
+    return "text/xml";
+  } else if (filename.endsWith(".pdf")) {
+    return "application/x-pdf";
+  } else if (filename.endsWith(".zip")) {
+    return "application/x-zip";
+  } else if (filename.endsWith(".gz")) {
+    return "application/x-gzip";
+  }
+  return "text/plain";
+}
+
+bool exists(String path){
+  bool yes = false;
+  File file = SPIFFS.open(path, "r");
+  if(!file.isDirectory()){
+    yes = true;
+  }
+  file.close();
+  return yes;
+}
+
+bool handleFileRead(String path) {
+  DBG_OUTPUT_PORT.println("handleFileRead: " + path);
+  if (path.endsWith("/")) {
+    path += "index.htm";
+  }
+  String contentType = getContentType(path);
+  String pathWithGz = path + ".gz";
+  if (exists(pathWithGz) || exists(path)) {
+    if (exists(pathWithGz)) {
+      path += ".gz";
+    }
+    File file = SPIFFS.open(path, "r");
+    server.streamFile(file, contentType);
+    file.close();
+    return true;
+  }
+  return false;
+}
+
+void handleFileUpload() {
+  if (server.uri() != "/edit") {
+    return;
+  }
+  HTTPUpload& upload = server.upload();
+  if (upload.status == UPLOAD_FILE_START) {
+    String filename = upload.filename;
+    if (!filename.startsWith("/")) {
+      filename = "/" + filename;
+    }
+    DBG_OUTPUT_PORT.print("handleFileUpload Name: "); DBG_OUTPUT_PORT.println(filename);
+    fsUploadFile = SPIFFS.open(filename, "w");
+    filename = String();
+  } else if (upload.status == UPLOAD_FILE_WRITE) {
+    //DBG_OUTPUT_PORT.print("handleFileUpload Data: "); DBG_OUTPUT_PORT.println(upload.currentSize);
+    if (fsUploadFile) {
+      fsUploadFile.write(upload.buf, upload.currentSize);
+    }
+  } else if (upload.status == UPLOAD_FILE_END) {
+    if (fsUploadFile) {
+      fsUploadFile.close();
+    }
+    DBG_OUTPUT_PORT.print("handleFileUpload Size: "); DBG_OUTPUT_PORT.println(upload.totalSize);
+  }
+}
+
+void handleFileDelete() {
+  if (server.args() == 0) {
+    return server.send(500, "text/plain", "BAD ARGS");
+  }
+  String path = server.arg(0);
+  DBG_OUTPUT_PORT.println("handleFileDelete: " + path);
+  if (path == "/") {
+    return server.send(500, "text/plain", "BAD PATH");
+  }
+  if (!exists(path)) {
+    return server.send(404, "text/plain", "FileNotFound");
+  }
+  SPIFFS.remove(path);
+  server.send(200, "text/plain", "");
+  path = String();
+}
+
+void handleFileCreate() {
+  if (server.args() == 0) {
+    return server.send(500, "text/plain", "BAD ARGS");
+  }
+  String path = server.arg(0);
+  DBG_OUTPUT_PORT.println("handleFileCreate: " + path);
+  if (path == "/") {
+    return server.send(500, "text/plain", "BAD PATH");
+  }
+  if (exists(path)) {
+    return server.send(500, "text/plain", "FILE EXISTS");
+  }
+  File file = SPIFFS.open(path, "w");
+  if (file) {
+    file.close();
+  } else {
+    return server.send(500, "text/plain", "CREATE FAILED");
+  }
+  server.send(200, "text/plain", "");
+  path = String();
+}
+
+void handleFileList() {
+  if (!server.hasArg("dir")) {
+    server.send(500, "text/plain", "BAD ARGS");
+    return;
+  }
+
+  String path = server.arg("dir");
+  DBG_OUTPUT_PORT.println("handleFileList: " + path);
+
+
+  File root = SPIFFS.open(path);
+  path = String();
+
+  String output = "[";
+  if(root.isDirectory()){
+      File file = root.openNextFile();
+      while(file){
+          if (output != "[") {
+            output += ',';
+          }
+          output += "{\"type\":\"";
+          output += (file.isDirectory()) ? "dir" : "file";
+          output += "\",\"name\":\"";
+          output += String(file.name()).substring(1);
+          output += "\"}";
+          file = root.openNextFile();
+      }
+  }
+  output += "]";
+  server.send(200, "text/json", output);
+}
+
+void setup(void) {
+  DBG_OUTPUT_PORT.begin(115200);
+  DBG_OUTPUT_PORT.print("\n");
+  DBG_OUTPUT_PORT.setDebugOutput(true);
+  SPIFFS.begin();
+  {
+      File root = SPIFFS.open("/");
+      File file = root.openNextFile();
+      while(file){
+          String fileName = file.name();
+          size_t fileSize = file.size();
+          DBG_OUTPUT_PORT.printf("FS File: %s, size: %s\n", fileName.c_str(), formatBytes(fileSize).c_str());
+          file = root.openNextFile();
+      }
+      DBG_OUTPUT_PORT.printf("\n");
+  }
+
+
+  //WIFI INIT
+  DBG_OUTPUT_PORT.printf("Connecting to %s\n", ssid);
+  if (String(WiFi.SSID()) != String(ssid)) {
+    WiFi.mode(WIFI_STA);
+    WiFi.begin(ssid, password);
+  }
+
+  while (WiFi.status() != WL_CONNECTED) {
+    delay(500);
+    DBG_OUTPUT_PORT.print(".");
+  }
+  DBG_OUTPUT_PORT.println("");
+  DBG_OUTPUT_PORT.print("Connected! IP address: ");
+  DBG_OUTPUT_PORT.println(WiFi.localIP());
+
+  MDNS.begin(host);
+  DBG_OUTPUT_PORT.print("Open http://");
+  DBG_OUTPUT_PORT.print(host);
+  DBG_OUTPUT_PORT.println(".local/edit to see the file browser");
+
+
+  //SERVER INIT
+  //list directory
+  server.on("/list", HTTP_GET, handleFileList);
+  //load editor
+  server.on("/edit", HTTP_GET, []() {
+    if (!handleFileRead("/edit.htm")) {
+      server.send(404, "text/plain", "FileNotFound");
+    }
+  });
+  //create file
+  server.on("/edit", HTTP_PUT, handleFileCreate);
+  //delete file
+  server.on("/edit", HTTP_DELETE, handleFileDelete);
+  //first callback is called after the request has ended with all parsed arguments
+  //second callback handles file uploads at that location
+  server.on("/edit", HTTP_POST, []() {
+    server.send(200, "text/plain", "");
+  }, handleFileUpload);
+
+  //called when the url is not defined here
+  //use it to load content from SPIFFS
+  server.onNotFound([]() {
+    if (!handleFileRead(server.uri())) {
+      server.send(404, "text/plain", "FileNotFound");
+    }
+  });
+
+  //get heap status, analog input value and all GPIO statuses in one json call
+  server.on("/all", HTTP_GET, []() {
+    String json = "{";
+    json += "\"heap\":" + String(ESP.getFreeHeap());
+    json += ", \"analog\":" + String(analogRead(A0));
+    json += ", \"gpio\":" + String((uint32_t)(0));
+    json += "}";
+    server.send(200, "text/json", json);
+    json = String();
+  });
+  server.begin();
+  DBG_OUTPUT_PORT.println("HTTP server started");
+
+}
+
+void loop(void) {
+  server.handleClient();
+}

libraries/WebServer/examples/FSBrowser/data/index.htm

@@ -0,0 +1,97 @@
+<!-- 
+  FSWebServer - Example Index Page
+  Copyright (c) 2015 Hristo Gochkov. All rights reserved.
+  This file is part of the WebServer library for Arduino environment.
+ 
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+-->
+<!DOCTYPE html>
+<html>
+<head>
+  <meta http-equiv="Content-type" content="text/html; charset=utf-8">
+  <title>ESP Monitor</title>
+  <script type="text/javascript" src="graphs.js"></script>
+  <script type="text/javascript">
+    var heap,temp,digi;
+    var reloadPeriod = 1000;
+    var running = false;
+    
+    function loadValues(){
+      if(!running) return;
+      var xh = new XMLHttpRequest();
+      xh.onreadystatechange = function(){
+        if (xh.readyState == 4){
+          if(xh.status == 200) {
+            var res = JSON.parse(xh.responseText);
+            heap.add(res.heap);
+            temp.add(res.analog);
+            digi.add(res.gpio);
+            if(running) setTimeout(loadValues, reloadPeriod);
+          } else running = false;
+        }
+      };
+      xh.open("GET", "/all", true);
+      xh.send(null);
+    };
+    
+    function run(){
+      if(!running){
+        running = true;
+        loadValues();
+      }
+    }
+    
+    function onBodyLoad(){
+      var refreshInput = document.getElementById("refresh-rate");
+      refreshInput.value = reloadPeriod;
+      refreshInput.onchange = function(e){
+        var value = parseInt(e.target.value);
+        reloadPeriod = (value > 0)?value:0;
+        e.target.value = reloadPeriod;
+      }
+      var stopButton = document.getElementById("stop-button");
+      stopButton.onclick = function(e){
+        running = false;
+      }
+      var startButton = document.getElementById("start-button");
+      startButton.onclick = function(e){
+        run();
+      }
+      
+      // Example with 10K thermistor
+      //function calcThermistor(v) {
+      //  var t = Math.log(((10230000 / v) - 10000));
+      //  t = (1/(0.001129148+(0.000234125*t)+(0.0000000876741*t*t*t)))-273.15;
+      //  return (t>120)?0:Math.round(t*10)/10;
+      //}
+      //temp = createGraph(document.getElementById("analog"), "Temperature", 100, 128, 10, 40, false, "cyan", calcThermistor);
+      
+      temp = createGraph(document.getElementById("analog"), "Analog Input", 100, 128, 0, 1023, false, "cyan");
+      heap = createGraph(document.getElementById("heap"), "Current Heap", 100, 125, 0, 30000, true, "orange");
+      digi = createDigiGraph(document.getElementById("digital"), "GPIO", 100, 146, [0, 4, 5, 16], "gold");
+      run();
+    }
+  </script>
+</head>
+<body id="index" style="margin:0; padding:0;" onload="onBodyLoad()">
+  <div id="controls" style="display: block; border: 1px solid rgb(68, 68, 68); padding: 5px; margin: 5px; width: 362px; background-color: rgb(238, 238, 238);">
+    <label>Period (ms):</label>
+    <input type="number" id="refresh-rate"/>
+    <input type="button" id="start-button" value="Start"/>
+    <input type="button" id="stop-button" value="Stop"/>
+  </div>
+  <div id="heap"></div>
+  <div id="analog"></div>
+  <div id="digital"></div>
+</body>
+</html>

libraries/WebServer/examples/HelloServer/HelloServer.ino

@@ -0,0 +1,73 @@
+#include <WiFi.h>
+#include <WiFiClient.h>
+#include <WebServer.h>
+#include <ESPmDNS.h>
+
+const char* ssid = "........";
+const char* password = "........";
+
+WebServer server(80);
+
+const int led = 13;
+
+void handleRoot() {
+  digitalWrite(led, 1);
+  server.send(200, "text/plain", "hello from esp8266!");
+  digitalWrite(led, 0);
+}
+
+void handleNotFound() {
+  digitalWrite(led, 1);
+  String message = "File Not Found\n\n";
+  message += "URI: ";
+  message += server.uri();
+  message += "\nMethod: ";
+  message += (server.method() == HTTP_GET) ? "GET" : "POST";
+  message += "\nArguments: ";
+  message += server.args();
+  message += "\n";
+  for (uint8_t i = 0; i < server.args(); i++) {
+    message += " " + server.argName(i) + ": " + server.arg(i) + "\n";
+  }
+  server.send(404, "text/plain", message);
+  digitalWrite(led, 0);
+}
+
+void setup(void) {
+  pinMode(led, OUTPUT);
+  digitalWrite(led, 0);
+  Serial.begin(115200);
+  WiFi.mode(WIFI_STA);
+  WiFi.begin(ssid, password);
+  Serial.println("");
+
+  // Wait for connection
+  while (WiFi.status() != WL_CONNECTED) {
+    delay(500);
+    Serial.print(".");
+  }
+  Serial.println("");
+  Serial.print("Connected to ");
+  Serial.println(ssid);
+  Serial.print("IP address: ");
+  Serial.println(WiFi.localIP());
+
+  if (MDNS.begin("esp32")) {
+    Serial.println("MDNS responder started");
+  }
+
+  server.on("/", handleRoot);
+
+  server.on("/inline", []() {
+    server.send(200, "text/plain", "this works as well");
+  });
+
+  server.onNotFound(handleNotFound);
+
+  server.begin();
+  Serial.println("HTTP server started");
+}
+
+void loop(void) {
+  server.handleClient();
+}

libraries/WebServer/examples/HttpAdvancedAuth/HttpAdvancedAuth.ino

@@ -0,0 +1,59 @@
+/*
+  HTTP Advanced Authentication example
+  Created Mar 16, 2017 by Ahmed El-Sharnoby.
+  This example code is in the public domain.
+*/
+
+#include <WiFi.h>
+#include <ESPmDNS.h>
+#include <ArduinoOTA.h>
+#include <WebServer.h>
+
+const char* ssid = "........";
+const char* password = "........";
+
+WebServer server(80);
+
+const char* www_username = "admin";
+const char* www_password = "esp32";
+// allows you to set the realm of authentication Default:"Login Required"
+const char* www_realm = "Custom Auth Realm";
+// the Content of the HTML response in case of Unautherized Access Default:empty
+String authFailResponse = "Authentication Failed";
+
+void setup() {
+  Serial.begin(115200);
+  WiFi.mode(WIFI_STA);
+  WiFi.begin(ssid, password);
+  if (WiFi.waitForConnectResult() != WL_CONNECTED) {
+    Serial.println("WiFi Connect Failed! Rebooting...");
+    delay(1000);
+    ESP.restart();
+  }
+  ArduinoOTA.begin();
+
+  server.on("/", []() {
+    if (!server.authenticate(www_username, www_password))
+      //Basic Auth Method with Custom realm and Failure Response
+      //return server.requestAuthentication(BASIC_AUTH, www_realm, authFailResponse);
+      //Digest Auth Method with realm="Login Required" and empty Failure Response
+      //return server.requestAuthentication(DIGEST_AUTH);
+      //Digest Auth Method with Custom realm and empty Failure Response
+      //return server.requestAuthentication(DIGEST_AUTH, www_realm);
+      //Digest Auth Method with Custom realm and Failure Response
+    {
+      return server.requestAuthentication(DIGEST_AUTH, www_realm, authFailResponse);
+    }
+    server.send(200, "text/plain", "Login OK");
+  });
+  server.begin();
+
+  Serial.print("Open http://");
+  Serial.print(WiFi.localIP());
+  Serial.println("/ in your browser to see it working");
+}
+
+void loop() {
+  ArduinoOTA.handle();
+  server.handleClient();
+}

libraries/WebServer/examples/HttpBasicAuth/HttpBasicAuth.ino

@@ -0,0 +1,41 @@
+#include <WiFi.h>
+#include <ESPmDNS.h>
+#include <ArduinoOTA.h>
+#include <WebServer.h>
+
+const char* ssid = "........";
+const char* password = "........";
+
+WebServer server(80);
+
+const char* www_username = "admin";
+const char* www_password = "esp32";
+
+void setup() {
+  Serial.begin(115200);
+  WiFi.mode(WIFI_STA);
+  WiFi.begin(ssid, password);
+  if (WiFi.waitForConnectResult() != WL_CONNECTED) {
+    Serial.println("WiFi Connect Failed! Rebooting...");
+    delay(1000);
+    ESP.restart();
+  }
+  ArduinoOTA.begin();
+
+  server.on("/", []() {
+    if (!server.authenticate(www_username, www_password)) {
+      return server.requestAuthentication();
+    }
+    server.send(200, "text/plain", "Login OK");
+  });
+  server.begin();
+
+  Serial.print("Open http://");
+  Serial.print(WiFi.localIP());
+  Serial.println("/ in your browser to see it working");
+}
+
+void loop() {
+  ArduinoOTA.handle();
+  server.handleClient();
+}

libraries/WebServer/examples/SDWebServer/SDWebServer.ino

@@ -0,0 +1,313 @@
+/*
+  SDWebServer - Example WebServer with SD Card backend for esp8266
+
+  Copyright (c) 2015 Hristo Gochkov. All rights reserved.
+  This file is part of the WebServer library for Arduino environment.
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+
+  Have a FAT Formatted SD Card connected to the SPI port of the ESP8266
+  The web root is the SD Card root folder
+  File extensions with more than 3 charecters are not supported by the SD Library
+  File Names longer than 8 charecters will be truncated by the SD library, so keep filenames shorter
+  index.htm is the default index (works on subfolders as well)
+
+  upload the contents of SdRoot to the root of the SDcard and access the editor by going to http://esp8266sd.local/edit
+
+*/
+#include <WiFi.h>
+#include <WiFiClient.h>
+#include <WebServer.h>
+#include <ESPmDNS.h>
+#include <SPI.h>
+#include <SD.h>
+
+#define DBG_OUTPUT_PORT Serial
+
+const char* ssid = "**********";
+const char* password = "**********";
+const char* host = "esp32sd";
+
+WebServer server(80);
+
+static bool hasSD = false;
+File uploadFile;
+
+
+void returnOK() {
+  server.send(200, "text/plain", "");
+}
+
+void returnFail(String msg) {
+  server.send(500, "text/plain", msg + "\r\n");
+}
+
+bool loadFromSdCard(String path) {
+  String dataType = "text/plain";
+  if (path.endsWith("/")) {
+    path += "index.htm";
+  }
+
+  if (path.endsWith(".src")) {
+    path = path.substring(0, path.lastIndexOf("."));
+  } else if (path.endsWith(".htm")) {
+    dataType = "text/html";
+  } else if (path.endsWith(".css")) {
+    dataType = "text/css";
+  } else if (path.endsWith(".js")) {
+    dataType = "application/javascript";
+  } else if (path.endsWith(".png")) {
+    dataType = "image/png";
+  } else if (path.endsWith(".gif")) {
+    dataType = "image/gif";
+  } else if (path.endsWith(".jpg")) {
+    dataType = "image/jpeg";
+  } else if (path.endsWith(".ico")) {
+    dataType = "image/x-icon";
+  } else if (path.endsWith(".xml")) {
+    dataType = "text/xml";
+  } else if (path.endsWith(".pdf")) {
+    dataType = "application/pdf";
+  } else if (path.endsWith(".zip")) {
+    dataType = "application/zip";
+  }
+
+  File dataFile = SD.open(path.c_str());
+  if (dataFile.isDirectory()) {
+    path += "/index.htm";
+    dataType = "text/html";
+    dataFile = SD.open(path.c_str());
+  }
+
+  if (!dataFile) {
+    return false;
+  }
+
+  if (server.hasArg("download")) {
+    dataType = "application/octet-stream";
+  }
+
+  if (server.streamFile(dataFile, dataType) != dataFile.size()) {
+    DBG_OUTPUT_PORT.println("Sent less data than expected!");
+  }
+
+  dataFile.close();
+  return true;
+}
+
+void handleFileUpload() {
+  if (server.uri() != "/edit") {
+    return;
+  }
+  HTTPUpload& upload = server.upload();
+  if (upload.status == UPLOAD_FILE_START) {
+    if (SD.exists((char *)upload.filename.c_str())) {
+      SD.remove((char *)upload.filename.c_str());
+    }
+    uploadFile = SD.open(upload.filename.c_str(), FILE_WRITE);
+    DBG_OUTPUT_PORT.print("Upload: START, filename: "); DBG_OUTPUT_PORT.println(upload.filename);
+  } else if (upload.status == UPLOAD_FILE_WRITE) {
+    if (uploadFile) {
+      uploadFile.write(upload.buf, upload.currentSize);
+    }
+    DBG_OUTPUT_PORT.print("Upload: WRITE, Bytes: "); DBG_OUTPUT_PORT.println(upload.currentSize);
+  } else if (upload.status == UPLOAD_FILE_END) {
+    if (uploadFile) {
+      uploadFile.close();
+    }
+    DBG_OUTPUT_PORT.print("Upload: END, Size: "); DBG_OUTPUT_PORT.println(upload.totalSize);
+  }
+}
+
+void deleteRecursive(String path) {
+  File file = SD.open((char *)path.c_str());
+  if (!file.isDirectory()) {
+    file.close();
+    SD.remove((char *)path.c_str());
+    return;
+  }
+
+  file.rewindDirectory();
+  while (true) {
+    File entry = file.openNextFile();
+    if (!entry) {
+      break;
+    }
+    String entryPath = path + "/" + entry.name();
+    if (entry.isDirectory()) {
+      entry.close();
+      deleteRecursive(entryPath);
+    } else {
+      entry.close();
+      SD.remove((char *)entryPath.c_str());
+    }
+    yield();
+  }
+
+  SD.rmdir((char *)path.c_str());
+  file.close();
+}
+
+void handleDelete() {
+  if (server.args() == 0) {
+    return returnFail("BAD ARGS");
+  }
+  String path = server.arg(0);
+  if (path == "/" || !SD.exists((char *)path.c_str())) {
+    returnFail("BAD PATH");
+    return;
+  }
+  deleteRecursive(path);
+  returnOK();
+}
+
+void handleCreate() {
+  if (server.args() == 0) {
+    return returnFail("BAD ARGS");
+  }
+  String path = server.arg(0);
+  if (path == "/" || SD.exists((char *)path.c_str())) {
+    returnFail("BAD PATH");
+    return;
+  }
+
+  if (path.indexOf('.') > 0) {
+    File file = SD.open((char *)path.c_str(), FILE_WRITE);
+    if (file) {
+      file.write(0);
+      file.close();
+    }
+  } else {
+    SD.mkdir((char *)path.c_str());
+  }
+  returnOK();
+}
+
+void printDirectory() {
+  if (!server.hasArg("dir")) {
+    return returnFail("BAD ARGS");
+  }
+  String path = server.arg("dir");
+  if (path != "/" && !SD.exists((char *)path.c_str())) {
+    return returnFail("BAD PATH");
+  }
+  File dir = SD.open((char *)path.c_str());
+  path = String();
+  if (!dir.isDirectory()) {
+    dir.close();
+    return returnFail("NOT DIR");
+  }
+  dir.rewindDirectory();
+  server.setContentLength(CONTENT_LENGTH_UNKNOWN);
+  server.send(200, "text/json", "");
+  WiFiClient client = server.client();
+
+  server.sendContent("[");
+  for (int cnt = 0; true; ++cnt) {
+    File entry = dir.openNextFile();
+    if (!entry) {
+      break;
+    }
+
+    String output;
+    if (cnt > 0) {
+      output = ',';
+    }
+
+    output += "{\"type\":\"";
+    output += (entry.isDirectory()) ? "dir" : "file";
+    output += "\",\"name\":\"";
+    output += entry.name();
+    output += "\"";
+    output += "}";
+    server.sendContent(output);
+    entry.close();
+  }
+  server.sendContent("]");
+  dir.close();
+}
+
+void handleNotFound() {
+  if (hasSD && loadFromSdCard(server.uri())) {
+    return;
+  }
+  String message = "SDCARD Not Detected\n\n";
+  message += "URI: ";
+  message += server.uri();
+  message += "\nMethod: ";
+  message += (server.method() == HTTP_GET) ? "GET" : "POST";
+  message += "\nArguments: ";
+  message += server.args();
+  message += "\n";
+  for (uint8_t i = 0; i < server.args(); i++) {
+    message += " NAME:" + server.argName(i) + "\n VALUE:" + server.arg(i) + "\n";
+  }
+  server.send(404, "text/plain", message);
+  DBG_OUTPUT_PORT.print(message);
+}
+
+void setup(void) {
+  DBG_OUTPUT_PORT.begin(115200);
+  DBG_OUTPUT_PORT.setDebugOutput(true);
+  DBG_OUTPUT_PORT.print("\n");
+  WiFi.mode(WIFI_STA);
+  WiFi.begin(ssid, password);
+  DBG_OUTPUT_PORT.print("Connecting to ");
+  DBG_OUTPUT_PORT.println(ssid);
+
+  // Wait for connection
+  uint8_t i = 0;
+  while (WiFi.status() != WL_CONNECTED && i++ < 20) {//wait 10 seconds
+    delay(500);
+  }
+  if (i == 21) {
+    DBG_OUTPUT_PORT.print("Could not connect to");
+    DBG_OUTPUT_PORT.println(ssid);
+    while (1) {
+      delay(500);
+    }
+  }
+  DBG_OUTPUT_PORT.print("Connected! IP address: ");
+  DBG_OUTPUT_PORT.println(WiFi.localIP());
+
+  if (MDNS.begin(host)) {
+    MDNS.addService("http", "tcp", 80);
+    DBG_OUTPUT_PORT.println("MDNS responder started");
+    DBG_OUTPUT_PORT.print("You can now connect to http://");
+    DBG_OUTPUT_PORT.print(host);
+    DBG_OUTPUT_PORT.println(".local");
+  }
+
+
+  server.on("/list", HTTP_GET, printDirectory);
+  server.on("/edit", HTTP_DELETE, handleDelete);
+  server.on("/edit", HTTP_PUT, handleCreate);
+  server.on("/edit", HTTP_POST, []() {
+    returnOK();
+  }, handleFileUpload);
+  server.onNotFound(handleNotFound);
+
+  server.begin();
+  DBG_OUTPUT_PORT.println("HTTP server started");
+
+  if (SD.begin(SS)) {
+    DBG_OUTPUT_PORT.println("SD Card initialized.");
+    hasSD = true;
+  }
+}
+
+void loop(void) {
+  server.handleClient();
+}

libraries/WebServer/examples/SDWebServer/SdRoot/edit/index.htm

@@ -0,0 +1,674 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <title>SD Editor</title>
+    <style type="text/css" media="screen">
+      .contextMenu {
+        z-index: 300;
+        position: absolute;
+        left: 5px;
+        border: 1px solid #444;
+        background-color: #F5F5F5;
+        display: none;
+        box-shadow: 0 0 10px rgba( 0, 0, 0, .4 );
+        font-size: 12px;
+        font-family: sans-serif;
+        font-weight:bold;
+      }
+      .contextMenu ul {
+        list-style: none;
+        top: 0;
+        left: 0;
+        margin: 0;
+        padding: 0;
+      }
+      .contextMenu li {
+        position: relative;
+        min-width: 60px;
+        cursor: pointer;
+      }
+      .contextMenu span {
+        color: #444;
+        display: inline-block;
+        padding: 6px;
+      }
+      .contextMenu li:hover { background: #444; }
+      .contextMenu li:hover span { color: #EEE; }
+    
+      .css-treeview ul, .css-treeview li {
+        padding: 0;
+        margin: 0;
+        list-style: none;
+      }
+
+      .css-treeview input {
+        position: absolute;
+        opacity: 0;
+      }
+
+      .css-treeview {
+        font: normal 11px Verdana, Arial, Sans-serif;
+        -moz-user-select: none;
+        -webkit-user-select: none;
+        user-select: none;
+      }
+
+      .css-treeview span {
+        color: #00f;
+        cursor: pointer;
+      }
+
+      .css-treeview span:hover {
+        text-decoration: underline;
+      }
+
+      .css-treeview input + label + ul {
+        margin: 0 0 0 22px;
+      }
+
+      .css-treeview input ~ ul {
+        display: none;
+      }
+
+      .css-treeview label, .css-treeview label::before {
+        cursor: pointer;
+      }
+
+      .css-treeview input:disabled + label {
+        cursor: default;
+        opacity: .6;
+      }
+
+      .css-treeview input:checked:not(:disabled) ~ ul {
+        display: block;
+      }
+
+      .css-treeview label, .css-treeview label::before {
+        background: url("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAACgCAYAAAAFOewUAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAApxJREFUeNrslM1u00AQgGdthyalFFOK+ClIIKQKyqUVQvTEE3DmAhLwAhU8QZoH4A2Q2gMSFace4MCtJ8SPBFwAkRuiHKpA6sRN/Lu7zG5i14kctaUqRGhGXnu9O/Pt7MzsMiklvF+9t2kWTDvyIrAsA0aKRRi1T0C/hJ4LUbt5/8rNpWVlp8RSr9J40b48fxFaTQ9+ft8EZ6MJYb0Ok+dnYGpmPgXwKIAvLx8vYXc5GdMAQJgQEkpjRTh36TS2U+DWW/D17WuYgm8pwJyY1npZsZKOxImOV1I/h4+O6vEg5GCZBpgmA6hX8wHKUHDRBXQYicQ4rlc3Tf0VMs8DHBS864F2YFspjgUYjKX/Az3gsdQd2eeBHwmdGWXHcgBGSkZXOXohcEXebRoQcAgjqediNY+AVyu3Z3sAKqfKoGMsewBeEIOPgQxxPJIjcGH6qtL/0AdADzKGnuuD+2tLK7Q8DhHHbOBW+KEzcHLuYc82MkEUekLiwuvVH+guQBQzOG4XdAb8EOcRcqQvDkY2iCLuxECJ43JobMXoutqGgDa2T7UqLKwt9KRyuxKVByqVXXqIoCCUCAqhUOioTWC7G4TQEOD0APy2/7G2Xpu1J4+lxeQ4TXBbITDpoVelRN/BVFbwu5oMMJUBhoXy5tmdRcMwymP2OLQaLjx9/vnBo6V3K6izATmSnMa0Dq7ferIohJhr1p01zrlz49rZF4OMs8JkX23vVQzYp+wbYGV/KpXKjvspl8tsIKCrMNAYFxj2GKS5ZWxg4ewKsJfaGMIY5KXqPz8LBBj6+yDvVP79+yDp/9F9oIx3OisHWwe7Oal0HxCAAAQgAAEIQAACEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAAAQgwD8E/BZgAP0qhKj3rXO7AAAAAElFTkSuQmCC") no-repeat;
+      }
+
+      .css-treeview label, .css-treeview span, .css-treeview label::before {
+        display: inline-block;
+        height: 16px;
+        line-height: 16px;
+        vertical-align: middle;
+      }
+
+      .css-treeview label {
+        background-position: 18px 0;
+      }
+
+      .css-treeview label::before {
+        content: "";
+        width: 16px;
+        margin: 0 22px 0 0;
+        vertical-align: middle;
+        background-position: 0 -32px;
+      }
+
+      .css-treeview input:checked + label::before {
+        background-position: 0 -16px;
+      }
+
+      /* webkit adjacent element selector bugfix */
+      @media screen and (-webkit-min-device-pixel-ratio:0)
+      {
+        .css-treeview{
+          -webkit-animation: webkit-adjacent-element-selector-bugfix infinite 1s;
+        }
+
+        @-webkit-keyframes webkit-adjacent-element-selector-bugfix 
+        {
+          from  { 
+            padding: 0;
+          } 
+          to  { 
+            padding: 0;
+          }
+        }
+      }
+
+      #uploader { 
+        position: absolute;
+        top: 0;
+        right: 0;
+        left: 0;
+        height:28px;
+        line-height: 24px;
+        padding-left: 10px;
+        background-color: #444;
+        color:#EEE;
+      }
+      #tree { 
+        position: absolute;
+        top: 28px;
+        bottom: 0;
+        left: 0;
+        width:200px;
+        padding: 8px;
+      }
+      #editor, #preview { 
+        position: absolute;
+        top: 28px;
+        right: 0;
+        bottom: 0;
+        left: 200px;
+      }
+      #preview {
+        background-color: #EEE;
+        padding:5px;
+      }
+    </style>
+    <script>
+      function createFileUploader(element, tree, editor){
+        var xmlHttp;
+        var input = document.createElement("input");
+        input.type = "file";
+        input.multiple = false;
+        input.name = "data";
+        document.getElementById(element).appendChild(input);
+        var path = document.createElement("input");
+        path.id = "upload-path";
+        path.type = "text";
+        path.name = "path";
+        path.defaultValue = "/";
+        document.getElementById(element).appendChild(path);
+        var button = document.createElement("button");
+        button.innerHTML = 'Upload';
+        document.getElementById(element).appendChild(button);
+        var mkdir = document.createElement("button");
+        mkdir.innerHTML = 'MkDir';
+        document.getElementById(element).appendChild(mkdir);
+        var mkfile = document.createElement("button");
+        mkfile.innerHTML = 'MkFile';
+        document.getElementById(element).appendChild(mkfile);
+  
+        function httpPostProcessRequest(){
+          if (xmlHttp.readyState == 4){
+            if(xmlHttp.status != 200) alert("ERROR["+xmlHttp.status+"]: "+xmlHttp.responseText);
+            else {
+              tree.refreshPath(path.value);
+            }
+          }
+        }
+        function createPath(p){
+          xmlHttp = new XMLHttpRequest();
+          xmlHttp.onreadystatechange = httpPostProcessRequest;
+          var formData = new FormData();
+          formData.append("path", p);
+          xmlHttp.open("PUT", "/edit");
+          xmlHttp.send(formData);
+        }
+        
+        mkfile.onclick = function(e){
+          if(path.value.indexOf(".") === -1) return;
+          createPath(path.value);
+          editor.loadUrl(path.value);
+        };
+        mkdir.onclick = function(e){
+          if(path.value.length < 2) return;
+          var dir = path.value
+          if(dir.indexOf(".") !== -1){
+            if(dir.lastIndexOf("/") === 0) return;
+            dir = dir.substring(0, dir.lastIndexOf("/"));
+          }
+          createPath(dir);
+        };
+        button.onclick = function(e){
+          if(input.files.length === 0){
+            return;
+          }
+          xmlHttp = new XMLHttpRequest();
+          xmlHttp.onreadystatechange = httpPostProcessRequest;
+          var formData = new FormData();
+          formData.append("data", input.files[0], path.value);
+          xmlHttp.open("POST", "/edit");
+          xmlHttp.send(formData);
+        }
+        input.onchange = function(e){
+          if(input.files.length === 0) return;
+          var filename = input.files[0].name;
+          var ext = /(?:\.([^.]+))?$/.exec(filename)[1];
+          var name = /(.*)\.[^.]+$/.exec(filename)[1];
+          if(typeof name !== undefined){
+            if(name.length > 8) name = name.substring(0, 8);
+            filename = name;
+          }
+          if(typeof ext !== undefined){
+            if(ext === "html") ext = "htm";
+            else if(ext === "jpeg") ext = "jpg";
+            filename = filename + "." + ext;
+          }
+          if(path.value === "/" || path.value.lastIndexOf("/") === 0){
+            path.value = "/"+filename;
+          } else {
+            path.value = path.value.substring(0, path.value.lastIndexOf("/")+1)+filename;
+          }
+        }
+      }
+
+      function createTree(element, editor){
+        var preview = document.getElementById("preview");
+        var treeRoot = document.createElement("div");
+        treeRoot.className = "css-treeview";
+        document.getElementById(element).appendChild(treeRoot);
+  
+        function loadDownload(path){
+          document.getElementById('download-frame').src = path+"?download=true";
+        }
+  
+        function loadPreview(path){
+          document.getElementById("editor").style.display = "none";
+          preview.style.display = "block";
+          preview.innerHTML = '<img src="'+path+'" style="max-width:100%; max-height:100%; margin:auto; display:block;" />';
+        }
+  
+        function fillFolderMenu(el, path){
+          var list = document.createElement("ul");
+          el.appendChild(list);
+          var action = document.createElement("li");
+          list.appendChild(action);
+          var isChecked = document.getElementById(path).checked;
+          var expnd = document.createElement("li");
+          list.appendChild(expnd);
+          if(isChecked){
+            expnd.innerHTML = "<span>Collapse</span>";
+            expnd.onclick = function(e){
+              document.getElementById(path).checked = false;
+              if(document.body.getElementsByClassName('contextMenu').length > 0) document.body.removeChild(el);
+            };
+            var refrsh = document.createElement("li");
+            list.appendChild(refrsh);
+            refrsh.innerHTML = "<span>Refresh</span>";
+            refrsh.onclick = function(e){
+              var leaf = document.getElementById(path).parentNode;
+              if(leaf.childNodes.length == 3) leaf.removeChild(leaf.childNodes[2]);
+              httpGet(leaf, path);
+              if(document.body.getElementsByClassName('contextMenu').length > 0) document.body.removeChild(el);
+            };
+          } else {
+            expnd.innerHTML = "<span>Expand</span>";
+            expnd.onclick = function(e){
+              document.getElementById(path).checked = true;
+              var leaf = document.getElementById(path).parentNode;
+              if(leaf.childNodes.length == 3) leaf.removeChild(leaf.childNodes[2]);
+              httpGet(leaf, path);
+              if(document.body.getElementsByClassName('contextMenu').length > 0) document.body.removeChild(el);
+            };
+          }
+          var upload = document.createElement("li");
+          list.appendChild(upload);
+          upload.innerHTML = "<span>Upload</span>";
+          upload.onclick = function(e){
+            var pathEl = document.getElementById("upload-path");
+            if(pathEl){
+              var subPath = pathEl.value;
+              if(subPath.lastIndexOf("/") < 1) pathEl.value = path+subPath;
+              else pathEl.value = path.substring(subPath.lastIndexOf("/"))+subPath;
+            }
+            if(document.body.getElementsByClassName('contextMenu').length > 0) document.body.removeChild(el);
+          };
+          var delFile = document.createElement("li");
+          list.appendChild(delFile);
+          delFile.innerHTML = "<span>Delete</span>";
+          delFile.onclick = function(e){
+            httpDelete(path);
+            if(document.body.getElementsByClassName('contextMenu').length > 0) document.body.removeChild(el);
+          };
+        }
+  
+        function fillFileMenu(el, path){
+          var list = document.createElement("ul");
+          el.appendChild(list);
+          var action = document.createElement("li");
+          list.appendChild(action);
+          if(isTextFile(path)){
+            action.innerHTML = "<span>Edit</span>";
+            action.onclick = function(e){
+              editor.loadUrl(path);
+              if(document.body.getElementsByClassName('contextMenu').length > 0) document.body.removeChild(el);
+            };
+          } else if(isImageFile(path)){
+            action.innerHTML = "<span>Preview</span>";
+            action.onclick = function(e){
+              loadPreview(path);
+              if(document.body.getElementsByClassName('contextMenu').length > 0) document.body.removeChild(el);
+            };
+          }
+          var download = document.createElement("li");
+          list.appendChild(download);
+          download.innerHTML = "<span>Download</span>";
+          download.onclick = function(e){
+            loadDownload(path);
+            if(document.body.getElementsByClassName('contextMenu').length > 0) document.body.removeChild(el);
+          };
+          var delFile = document.createElement("li");
+          list.appendChild(delFile);
+          delFile.innerHTML = "<span>Delete</span>";
+          delFile.onclick = function(e){
+            httpDelete(path);
+            if(document.body.getElementsByClassName('contextMenu').length > 0) document.body.removeChild(el);
+          };
+        }
+  
+        function showContextMenu(e, path, isfile){
+          var divContext = document.createElement("div");
+          var scrollTop = document.body.scrollTop ? document.body.scrollTop : document.documentElement.scrollTop;
+          var scrollLeft = document.body.scrollLeft ? document.body.scrollLeft : document.documentElement.scrollLeft;
+          var left = e.clientX + scrollLeft;
+          var top = e.clientY + scrollTop;
+          divContext.className = 'contextMenu';
+          divContext.style.display = 'block';
+          divContext.style.left = left + 'px';
+          divContext.style.top = top + 'px';
+          if(isfile) fillFileMenu(divContext, path);
+          else fillFolderMenu(divContext, path);
+          document.body.appendChild(divContext);
+          var width = divContext.offsetWidth;
+          var height = divContext.offsetHeight;
+          divContext.onmouseout = function(e){
+            if(e.clientX < left || e.clientX > (left + width) || e.clientY < top || e.clientY > (top + height)){
+              if(document.body.getElementsByClassName('contextMenu').length > 0) document.body.removeChild(divContext);
+            }
+          };
+        }
+  
+        function createTreeLeaf(path, name, size){
+          var leaf = document.createElement("li");
+          leaf.id = (((path == "/")?"":path)+"/"+name).toLowerCase();
+          var label = document.createElement("span");
+          label.textContent = name.toLowerCase();
+          leaf.appendChild(label);
+          leaf.onclick = function(e){
+            if(isTextFile(leaf.id)){
+              editor.loadUrl(leaf.id);
+            } else if(isImageFile(leaf.id)){
+              loadPreview(leaf.id);
+            }
+          };
+          leaf.oncontextmenu = function(e){
+            e.preventDefault();
+            e.stopPropagation();
+            showContextMenu(e, leaf.id, true);
+          };
+          return leaf;
+        }
+  
+        function createTreeBranch(path, name, disabled){
+          var leaf = document.createElement("li");
+          var check = document.createElement("input");
+          check.type = "checkbox";
+          check.id = (((path == "/")?"":path)+"/"+name).toLowerCase();
+          if(typeof disabled !== "undefined" && disabled) check.disabled = "disabled";
+          leaf.appendChild(check);
+          var label = document.createElement("label");
+          label.for = check.id;
+          label.textContent = name.toLowerCase();
+          leaf.appendChild(label);
+          check.onchange = function(e){
+            if(check.checked){
+              if(leaf.childNodes.length == 3) leaf.removeChild(leaf.childNodes[2]);
+              httpGet(leaf, check.id);
+            }
+          };
+          label.onclick = function(e){
+            if(!check.checked){
+              check.checked = true;
+              if(leaf.childNodes.length == 3) leaf.removeChild(leaf.childNodes[2]);
+              httpGet(leaf, check.id);
+            } else {
+              check.checked = false;
+            }
+          };
+          leaf.oncontextmenu = function(e){
+            e.preventDefault();
+            e.stopPropagation();
+            showContextMenu(e, check.id, false);
+          }
+          return leaf;
+        }
+  
+        function addList(parent, path, items){
+          var list = document.createElement("ul");
+          parent.appendChild(list);
+          var ll = items.length;
+          for(var i = 0; i < ll; i++){
+            var item = items[i];
+            var itemEl;
+            if(item.type === "file"){
+              itemEl = createTreeLeaf(path, item.name, item.size);
+            } else {
+              itemEl = createTreeBranch(path, item.name);
+            }
+            list.appendChild(itemEl);
+          }
+    
+        }
+  
+        function isTextFile(path){
+          var ext = /(?:\.([^.]+))?$/.exec(path)[1];
+          if(typeof ext !== undefined){
+            switch(ext){
+              case "txt":
+              case "htm":
+              case "html":
+              case "js":
+              case "json":
+              case "c":
+              case "h":
+              case "cpp":
+              case "css":
+              case "xml":
+                return true;
+            }
+          }
+          return false;
+        }
+  
+        function isImageFile(path){
+          var ext = /(?:\.([^.]+))?$/.exec(path)[1];
+          if(typeof ext !== undefined){
+            switch(ext){
+              case "png":
+              case "jpg":
+              case "gif":
+              case "ico":
+                return true;
+            }
+          }
+          return false;
+        }
+  
+        this.refreshPath = function(path){
+          if(path.lastIndexOf('/') < 1){
+            path = '/';
+            treeRoot.removeChild(treeRoot.childNodes[0]);
+            httpGet(treeRoot, "/");
+          } else {
+            path = path.substring(0, path.lastIndexOf('/'));
+            var leaf = document.getElementById(path).parentNode;
+            if(leaf.childNodes.length == 3) leaf.removeChild(leaf.childNodes[2]);
+            httpGet(leaf, path);
+          }
+        };
+  
+        function delCb(path){
+          return function(){
+            if (xmlHttp.readyState == 4){
+              if(xmlHttp.status != 200){
+                alert("ERROR["+xmlHttp.status+"]: "+xmlHttp.responseText);
+              } else {
+                if(path.lastIndexOf('/') < 1){
+                  path = '/';
+                  treeRoot.removeChild(treeRoot.childNodes[0]);
+                  httpGet(treeRoot, "/");
+                } else {
+                  path = path.substring(0, path.lastIndexOf('/'));
+                  var leaf = document.getElementById(path).parentNode;
+                  if(leaf.childNodes.length == 3) leaf.removeChild(leaf.childNodes[2]);
+                  httpGet(leaf, path);
+                }
+              }
+            }
+          }
+        }
+  
+        function httpDelete(filename){
+          xmlHttp = new XMLHttpRequest();
+          xmlHttp.onreadystatechange = delCb(filename);
+          var formData = new FormData();
+          formData.append("path", filename);
+          xmlHttp.open("DELETE", "/edit");
+          xmlHttp.send(formData);
+        }
+  
+        function getCb(parent, path){
+          return function(){
+            if (xmlHttp.readyState == 4){
+              //clear loading
+              if(xmlHttp.status == 200) addList(parent, path, JSON.parse(xmlHttp.responseText));
+            }
+          }
+        }
+  
+        function httpGet(parent, path){
+          xmlHttp = new XMLHttpRequest(parent, path);
+          xmlHttp.onreadystatechange = getCb(parent, path);
+          xmlHttp.open("GET", "/list?dir="+path, true);
+          xmlHttp.send(null);
+          //start loading
+        }
+  
+        httpGet(treeRoot, "/");
+        return this;
+      }
+
+      function createEditor(element, file, lang, theme, type){
+        function getLangFromFilename(filename){
+          var lang = "plain";
+          var ext = /(?:\.([^.]+))?$/.exec(filename)[1];
+          if(typeof ext !== undefined){
+            switch(ext){
+              case "txt": lang = "plain"; break;
+              case "htm": lang = "html"; break;
+              case "js": lang = "javascript"; break;
+              case "c": lang = "c_cpp"; break;
+              case "cpp": lang = "c_cpp"; break;
+              case "css":
+              case "scss":
+              case "php":
+              case "html":
+              case "json":
+              case "xml":
+                lang = ext;
+            }
+          }
+          return lang;
+        }
+  
+        if(typeof file === "undefined") file = "/index.htm";
+  
+        if(typeof lang === "undefined"){
+          lang = getLangFromFilename(file);
+        }
+  
+        if(typeof theme === "undefined") theme = "textmate";
+  
+        if(typeof type === "undefined"){
+          type = "text/"+lang;
+          if(lang === "c_cpp") type = "text/plain";
+        }
+  
+        var xmlHttp = null;
+        var editor = ace.edit(element);
+  
+        //post
+        function httpPostProcessRequest(){
+          if (xmlHttp.readyState == 4){
+            if(xmlHttp.status != 200) alert("ERROR["+xmlHttp.status+"]: "+xmlHttp.responseText);
+          }
+        }
+        function httpPost(filename, data, type){
+          xmlHttp = new XMLHttpRequest();
+          xmlHttp.onreadystatechange = httpPostProcessRequest;
+          var formData = new FormData();
+          formData.append("data", new Blob([data], { type: type }), filename);
+          xmlHttp.open("POST", "/edit");
+          xmlHttp.send(formData);
+        }
+        //get
+        function httpGetProcessRequest(){
+          if (xmlHttp.readyState == 4){
+            document.getElementById("preview").style.display = "none";
+            document.getElementById("editor").style.display = "block";
+            if(xmlHttp.status == 200) editor.setValue(xmlHttp.responseText);
+            else editor.setValue("");
+            editor.clearSelection();
+          }
+        }
+        function httpGet(theUrl){
+            xmlHttp = new XMLHttpRequest();
+            xmlHttp.onreadystatechange = httpGetProcessRequest;
+            xmlHttp.open("GET", theUrl, true);
+            xmlHttp.send(null);
+        }
+  
+        if(lang !== "plain") editor.getSession().setMode("ace/mode/"+lang);
+        editor.setTheme("ace/theme/"+theme);
+        editor.$blockScrolling = Infinity;
+        editor.getSession().setUseSoftTabs(true);
+        editor.getSession().setTabSize(2);
+        editor.setHighlightActiveLine(true);
+        editor.setShowPrintMargin(false);
+        editor.commands.addCommand({
+            name: 'saveCommand',
+            bindKey: {win: 'Ctrl-S',  mac: 'Command-S'},
+            exec: function(editor) {
+              httpPost(file, editor.getValue()+"", type);
+            },
+            readOnly: false
+        });
+        editor.commands.addCommand({
+            name: 'undoCommand',
+            bindKey: {win: 'Ctrl-Z',  mac: 'Command-Z'},
+            exec: function(editor) {
+              editor.getSession().getUndoManager().undo(false);
+            },
+            readOnly: false
+        });
+        editor.commands.addCommand({
+            name: 'redoCommand',
+            bindKey: {win: 'Ctrl-Shift-Z',  mac: 'Command-Shift-Z'},
+            exec: function(editor) {
+              editor.getSession().getUndoManager().redo(false);
+            },
+            readOnly: false
+        });
+        httpGet(file);
+        editor.loadUrl = function(filename){
+          file = filename;
+          lang = getLangFromFilename(file);
+          type = "text/"+lang;
+          if(lang !== "plain") editor.getSession().setMode("ace/mode/"+lang);
+          httpGet(file);
+        }
+        return editor;
+      }
+      function onBodyLoad(){
+        var vars = {};
+        var parts = window.location.href.replace(/[?&]+([^=&]+)=([^&]*)/gi, function(m,key,value) { vars[key] = value; });
+        var editor = createEditor("editor", vars.file, vars.lang, vars.theme);
+        var tree = createTree("tree", editor);
+        createFileUploader("uploader", tree, editor);
+      };
+    </script>
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/ace/1.1.9/ace.js" type="text/javascript" charset="utf-8"></script>
+  </head>
+  <body onload="onBodyLoad();">
+    <div id="uploader"></div>
+    <div id="tree"></div>
+    <div id="editor"></div>
+    <div id="preview" style="display:none;"></div>
+    <iframe id=download-frame style='display:none;'></iframe>
+  </body>
+</html>

libraries/WebServer/examples/SDWebServer/SdRoot/index.htm

@@ -0,0 +1,22 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <meta http-equiv="Content-type" content="text/html; charset=utf-8">
+  <title>ESP Index</title>
+  <style>
+    body {
+      background-color:black;
+      color:white;
+    }
+  </style>
+  <script type="text/javascript">
+    function onBodyLoad(){
+      console.log("we are loaded!!");
+    }
+  </script>
+</head>
+<body id="index" onload="onBodyLoad()">
+  <h1>ESP8266 Pin Functions</h1>
+<img src="pins.png" />
+</body>
+</html>

libraries/WebServer/examples/SimpleAuthentification/SimpleAuthentification.ino

@@ -0,0 +1,132 @@
+#include <WiFi.h>
+#include <WiFiClient.h>
+#include <WebServer.h>
+
+const char* ssid = "........";
+const char* password = "........";
+
+WebServer server(80);
+
+//Check if header is present and correct
+bool is_authentified() {
+  Serial.println("Enter is_authentified");
+  if (server.hasHeader("Cookie")) {
+    Serial.print("Found cookie: ");
+    String cookie = server.header("Cookie");
+    Serial.println(cookie);
+    if (cookie.indexOf("ESPSESSIONID=1") != -1) {
+      Serial.println("Authentification Successful");
+      return true;
+    }
+  }
+  Serial.println("Authentification Failed");
+  return false;
+}
+
+//login page, also called for disconnect
+void handleLogin() {
+  String msg;
+  if (server.hasHeader("Cookie")) {
+    Serial.print("Found cookie: ");
+    String cookie = server.header("Cookie");
+    Serial.println(cookie);
+  }
+  if (server.hasArg("DISCONNECT")) {
+    Serial.println("Disconnection");
+    server.sendHeader("Location", "/login");
+    server.sendHeader("Cache-Control", "no-cache");
+    server.sendHeader("Set-Cookie", "ESPSESSIONID=0");
+    server.send(301);
+    return;
+  }
+  if (server.hasArg("USERNAME") && server.hasArg("PASSWORD")) {
+    if (server.arg("USERNAME") == "admin" &&  server.arg("PASSWORD") == "admin") {
+      server.sendHeader("Location", "/");
+      server.sendHeader("Cache-Control", "no-cache");
+      server.sendHeader("Set-Cookie", "ESPSESSIONID=1");
+      server.send(301);
+      Serial.println("Log in Successful");
+      return;
+    }
+    msg = "Wrong username/password! try again.";
+    Serial.println("Log in Failed");
+  }
+  String content = "<html><body><form action='/login' method='POST'>To log in, please use : admin/admin<br>";
+  content += "User:<input type='text' name='USERNAME' placeholder='user name'><br>";
+  content += "Password:<input type='password' name='PASSWORD' placeholder='password'><br>";
+  content += "<input type='submit' name='SUBMIT' value='Submit'></form>" + msg + "<br>";
+  content += "You also can go <a href='/inline'>here</a></body></html>";
+  server.send(200, "text/html", content);
+}
+
+//root page can be accessed only if authentification is ok
+void handleRoot() {
+  Serial.println("Enter handleRoot");
+  String header;
+  if (!is_authentified()) {
+    server.sendHeader("Location", "/login");
+    server.sendHeader("Cache-Control", "no-cache");
+    server.send(301);
+    return;
+  }
+  String content = "<html><body><H2>hello, you successfully connected to esp8266!</H2><br>";
+  if (server.hasHeader("User-Agent")) {
+    content += "the user agent used is : " + server.header("User-Agent") + "<br><br>";
+  }
+  content += "You can access this page until you <a href=\"/login?DISCONNECT=YES\">disconnect</a></body></html>";
+  server.send(200, "text/html", content);
+}
+
+//no need authentification
+void handleNotFound() {
+  String message = "File Not Found\n\n";
+  message += "URI: ";
+  message += server.uri();
+  message += "\nMethod: ";
+  message += (server.method() == HTTP_GET) ? "GET" : "POST";
+  message += "\nArguments: ";
+  message += server.args();
+  message += "\n";
+  for (uint8_t i = 0; i < server.args(); i++) {
+    message += " " + server.argName(i) + ": " + server.arg(i) + "\n";
+  }
+  server.send(404, "text/plain", message);
+}
+
+void setup(void) {
+  Serial.begin(115200);
+  WiFi.mode(WIFI_STA);
+  WiFi.begin(ssid, password);
+  Serial.println("");
+
+  // Wait for connection
+  while (WiFi.status() != WL_CONNECTED) {
+    delay(500);
+    Serial.print(".");
+  }
+  Serial.println("");
+  Serial.print("Connected to ");
+  Serial.println(ssid);
+  Serial.print("IP address: ");
+  Serial.println(WiFi.localIP());
+
+
+  server.on("/", handleRoot);
+  server.on("/login", handleLogin);
+  server.on("/inline", []() {
+    server.send(200, "text/plain", "this works without need of authentification");
+  });
+
+  server.onNotFound(handleNotFound);
+  //here the list of headers to be recorded
+  const char * headerkeys[] = {"User-Agent", "Cookie"} ;
+  size_t headerkeyssize = sizeof(headerkeys) / sizeof(char*);
+  //ask server to track these headers
+  server.collectHeaders(headerkeys, headerkeyssize);
+  server.begin();
+  Serial.println("HTTP server started");
+}
+
+void loop(void) {
+  server.handleClient();
+}

libraries/WebServer/examples/WebUpdate/WebUpdate.ino

@@ -0,0 +1,67 @@
+/*
+  To upload through terminal you can use: curl -F "image=@firmware.bin" esp8266-webupdate.local/update
+*/
+
+#include <WiFi.h>
+#include <WiFiClient.h>
+#include <WebServer.h>
+#include <ESPmDNS.h>
+#include <Update.h>
+
+const char* host = "esp32-webupdate";
+const char* ssid = "........";
+const char* password = "........";
+
+WebServer server(80);
+const char* serverIndex = "<form method='POST' action='/update' enctype='multipart/form-data'><input type='file' name='update'><input type='submit' value='Update'></form>";
+
+void setup(void) {
+  Serial.begin(115200);
+  Serial.println();
+  Serial.println("Booting Sketch...");
+  WiFi.mode(WIFI_AP_STA);
+  WiFi.begin(ssid, password);
+  if (WiFi.waitForConnectResult() == WL_CONNECTED) {
+    MDNS.begin(host);
+    server.on("/", HTTP_GET, []() {
+      server.sendHeader("Connection", "close");
+      server.send(200, "text/html", serverIndex);
+    });
+    server.on("/update", HTTP_POST, []() {
+      server.sendHeader("Connection", "close");
+      server.send(200, "text/plain", (Update.hasError()) ? "FAIL" : "OK");
+      ESP.restart();
+    }, []() {
+      HTTPUpload& upload = server.upload();
+      if (upload.status == UPLOAD_FILE_START) {
+        Serial.setDebugOutput(true);
+        Serial.printf("Update: %s\n", upload.filename.c_str());
+        if (!Update.begin()) { //start with max available size
+          Update.printError(Serial);
+        }
+      } else if (upload.status == UPLOAD_FILE_WRITE) {
+        if (Update.write(upload.buf, upload.currentSize) != upload.currentSize) {
+          Update.printError(Serial);
+        }
+      } else if (upload.status == UPLOAD_FILE_END) {
+        if (Update.end(true)) { //true to set the size to the current progress
+          Serial.printf("Update Success: %u\nRebooting...\n", upload.totalSize);
+        } else {
+          Update.printError(Serial);
+        }
+        Serial.setDebugOutput(false);
+      }
+    });
+    server.begin();
+    MDNS.addService("http", "tcp", 80);
+
+    Serial.printf("Ready! Open http://%s.local in your browser\n", host);
+  } else {
+    Serial.println("WiFi Failed");
+  }
+}
+
+void loop(void) {
+  server.handleClient();
+  delay(1);
+}

libraries/WebServer/keywords.txt

@@ -0,0 +1,38 @@
+#######################################
+# Syntax Coloring Map For Ultrasound
+#######################################
+
+#######################################
+# Datatypes (KEYWORD1)
+#######################################
+
+WebServer	KEYWORD1
+WebServerSecure	KEYWORD1
+HTTPMethod	KEYWORD1
+
+#######################################
+# Methods and Functions (KEYWORD2)
+#######################################
+
+begin	KEYWORD2
+handleClient	KEYWORD2
+on	KEYWORD2
+addHandler	KEYWORD2
+uri	KEYWORD2
+method	KEYWORD2
+client	KEYWORD2
+send	KEYWORD2
+arg	KEYWORD2
+argName	KEYWORD2
+args	KEYWORD2
+hasArg	KEYWORD2
+onNotFound	KEYWORD2
+
+#######################################
+# Constants (LITERAL1)
+#######################################
+
+HTTP_GET	LITERAL1
+HTTP_POST	LITERAL1
+HTTP_ANY	LITERAL1
+CONTENT_LENGTH_UNKNOWN	LITERAL1

libraries/WebServer/library.properties

@@ -0,0 +1,9 @@
+name=WebServer
+version=1.0
+author=Ivan Grokhotkov
+maintainer=Ivan Grokhtkov <ivan@esp8266.com>
+sentence=Simple web server library
+paragraph=The library supports HTTP GET and POST requests, provides argument parsing, handles one client at a time.
+category=Communication
+url=
+architectures=esp32

libraries/WebServer/src/Parsing.cpp

@@ -0,0 +1,616 @@
+/*
+  Parsing.cpp - HTTP request parsing.
+
+  Copyright (c) 2015 Ivan Grokhotkov. All rights reserved.
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+  Modified 8 May 2015 by Hristo Gochkov (proper post and file upload handling)
+*/
+
+#include <Arduino.h>
+#include "WiFiServer.h"
+#include "WiFiClient.h"
+#include "WebServer.h"
+#include "detail/mimetable.h"
+
+//#define DEBUG_ESP_HTTP_SERVER
+#ifdef DEBUG_ESP_PORT
+#define DEBUG_OUTPUT DEBUG_ESP_PORT
+#else
+#define DEBUG_OUTPUT Serial
+#endif
+
+static const char Content_Type[] PROGMEM = "Content-Type";
+static const char filename[] PROGMEM = "filename";
+
+static char* readBytesWithTimeout(WiFiClient& client, size_t maxLength, size_t& dataLength, int timeout_ms)
+{
+  char *buf = nullptr;
+  dataLength = 0;
+  while (dataLength < maxLength) {
+    int tries = timeout_ms;
+    size_t newLength;
+    while (!(newLength = client.available()) && tries--) delay(1);
+    if (!newLength) {
+      break;
+    }
+    if (!buf) {
+      buf = (char *) malloc(newLength + 1);
+      if (!buf) {
+        return nullptr;
+      }
+    }
+    else {
+      char* newBuf = (char *) realloc(buf, dataLength + newLength + 1);
+      if (!newBuf) {
+        free(buf);
+        return nullptr;
+      }
+      buf = newBuf;
+    }
+    client.readBytes(buf + dataLength, newLength);
+    dataLength += newLength;
+    buf[dataLength] = '\0';
+  }
+  return buf;
+}
+
+bool WebServer::_parseRequest(WiFiClient& client) {
+  // Read the first line of HTTP request
+  String req = client.readStringUntil('\r');
+  client.readStringUntil('\n');
+  //reset header value
+  for (int i = 0; i < _headerKeysCount; ++i) {
+    _currentHeaders[i].value =String();
+   }
+
+  // First line of HTTP request looks like "GET /path HTTP/1.1"
+  // Retrieve the "/path" part by finding the spaces
+  int addr_start = req.indexOf(' ');
+  int addr_end = req.indexOf(' ', addr_start + 1);
+  if (addr_start == -1 || addr_end == -1) {
+#ifdef DEBUG_ESP_HTTP_SERVER
+    DEBUG_OUTPUT.print("Invalid request: ");
+    DEBUG_OUTPUT.println(req);
+#endif
+    return false;
+  }
+
+  String methodStr = req.substring(0, addr_start);
+  String url = req.substring(addr_start + 1, addr_end);
+  String versionEnd = req.substring(addr_end + 8);
+  _currentVersion = atoi(versionEnd.c_str());
+  String searchStr = "";
+  int hasSearch = url.indexOf('?');
+  if (hasSearch != -1){
+    searchStr = url.substring(hasSearch + 1);
+    url = url.substring(0, hasSearch);
+  }
+  _currentUri = url;
+  _chunked = false;
+
+  HTTPMethod method = HTTP_GET;
+  if (methodStr == F("POST")) {
+    method = HTTP_POST;
+  } else if (methodStr == F("DELETE")) {
+    method = HTTP_DELETE;
+  } else if (methodStr == F("OPTIONS")) {
+    method = HTTP_OPTIONS;
+  } else if (methodStr == F("PUT")) {
+    method = HTTP_PUT;
+  } else if (methodStr == F("PATCH")) {
+    method = HTTP_PATCH;
+  }
+  _currentMethod = method;
+
+#ifdef DEBUG_ESP_HTTP_SERVER
+  DEBUG_OUTPUT.print("method: ");
+  DEBUG_OUTPUT.print(methodStr);
+  DEBUG_OUTPUT.print(" url: ");
+  DEBUG_OUTPUT.print(url);
+  DEBUG_OUTPUT.print(" search: ");
+  DEBUG_OUTPUT.println(searchStr);
+#endif
+
+  //attach handler
+  RequestHandler* handler;
+  for (handler = _firstHandler; handler; handler = handler->next()) {
+    if (handler->canHandle(_currentMethod, _currentUri))
+      break;
+  }
+  _currentHandler = handler;
+
+  String formData;
+  // below is needed only when POST type request
+  if (method == HTTP_POST || method == HTTP_PUT || method == HTTP_PATCH || method == HTTP_DELETE){
+    String boundaryStr;
+    String headerName;
+    String headerValue;
+    bool isForm = false;
+    bool isEncoded = false;
+    uint32_t contentLength = 0;
+    //parse headers
+    while(1){
+      req = client.readStringUntil('\r');
+      client.readStringUntil('\n');
+      if (req == "") break;//no moar headers
+      int headerDiv = req.indexOf(':');
+      if (headerDiv == -1){
+        break;
+      }
+      headerName = req.substring(0, headerDiv);
+      headerValue = req.substring(headerDiv + 1);
+      headerValue.trim();
+       _collectHeader(headerName.c_str(),headerValue.c_str());
+
+      #ifdef DEBUG_ESP_HTTP_SERVER
+      DEBUG_OUTPUT.print("headerName: ");
+      DEBUG_OUTPUT.println(headerName);
+      DEBUG_OUTPUT.print("headerValue: ");
+      DEBUG_OUTPUT.println(headerValue);
+      #endif
+
+      if (headerName.equalsIgnoreCase(FPSTR(Content_Type))){
+        using namespace mime;
+        if (headerValue.startsWith(FPSTR(mimeTable[txt].mimeType))){
+          isForm = false;
+        } else if (headerValue.startsWith(F("application/x-www-form-urlencoded"))){
+          isForm = false;
+          isEncoded = true;
+        } else if (headerValue.startsWith(F("multipart/"))){
+          boundaryStr = headerValue.substring(headerValue.indexOf('=') + 1);
+          boundaryStr.replace("\"","");
+          isForm = true;
+        }
+      } else if (headerName.equalsIgnoreCase(F("Content-Length"))){
+        contentLength = headerValue.toInt();
+      } else if (headerName.equalsIgnoreCase(F("Host"))){
+        _hostHeader = headerValue;
+      }
+    }
+
+    if (!isForm){
+      size_t plainLength;
+      char* plainBuf = readBytesWithTimeout(client, contentLength, plainLength, HTTP_MAX_POST_WAIT);
+      if (plainLength < contentLength) {
+      	free(plainBuf);
+      	return false;
+      }
+      if (contentLength > 0) {
+        if(isEncoded){
+          //url encoded form
+          if (searchStr != "") searchStr += '&';
+          searchStr += plainBuf;
+        }
+        _parseArguments(searchStr);
+        if(!isEncoded){
+          //plain post json or other data
+          RequestArgument& arg = _currentArgs[_currentArgCount++];
+          arg.key = F("plain");
+          arg.value = String(plainBuf);
+        }
+
+  #ifdef DEBUG_ESP_HTTP_SERVER
+        DEBUG_OUTPUT.print("Plain: ");
+        DEBUG_OUTPUT.println(plainBuf);
+  #endif
+        free(plainBuf);
+      } else {
+        // No content - but we can still have arguments in the URL.
+        _parseArguments(searchStr);
+      }
+    }
+
+    if (isForm){
+      _parseArguments(searchStr);
+      if (!_parseForm(client, boundaryStr, contentLength)) {
+        return false;
+      }
+    }
+  } else {
+    String headerName;
+    String headerValue;
+    //parse headers
+    while(1){
+      req = client.readStringUntil('\r');
+      client.readStringUntil('\n');
+      if (req == "") break;//no moar headers
+      int headerDiv = req.indexOf(':');
+      if (headerDiv == -1){
+        break;
+      }
+      headerName = req.substring(0, headerDiv);
+      headerValue = req.substring(headerDiv + 2);
+      _collectHeader(headerName.c_str(),headerValue.c_str());
+
+	  #ifdef DEBUG_ESP_HTTP_SERVER
+	  DEBUG_OUTPUT.print("headerName: ");
+	  DEBUG_OUTPUT.println(headerName);
+	  DEBUG_OUTPUT.print("headerValue: ");
+	  DEBUG_OUTPUT.println(headerValue);
+	  #endif
+
+	  if (headerName.equalsIgnoreCase("Host")){
+        _hostHeader = headerValue;
+      }
+    }
+    _parseArguments(searchStr);
+  }
+  client.flush();
+
+#ifdef DEBUG_ESP_HTTP_SERVER
+  DEBUG_OUTPUT.print("Request: ");
+  DEBUG_OUTPUT.println(url);
+  DEBUG_OUTPUT.print(" Arguments: ");
+  DEBUG_OUTPUT.println(searchStr);
+#endif
+
+  return true;
+}
+
+bool WebServer::_collectHeader(const char* headerName, const char* headerValue) {
+  for (int i = 0; i < _headerKeysCount; i++) {
+    if (_currentHeaders[i].key.equalsIgnoreCase(headerName)) {
+            _currentHeaders[i].value=headerValue;
+            return true;
+        }
+  }
+  return false;
+}
+
+void WebServer::_parseArguments(String data) {
+#ifdef DEBUG_ESP_HTTP_SERVER
+  DEBUG_OUTPUT.print("args: ");
+  DEBUG_OUTPUT.println(data);
+#endif
+  if (_currentArgs)
+    delete[] _currentArgs;
+  _currentArgs = 0;
+  if (data.length() == 0) {
+    _currentArgCount = 0;
+    _currentArgs = new RequestArgument[1];
+    return;
+  }
+  _currentArgCount = 1;
+
+  for (int i = 0; i < (int)data.length(); ) {
+    i = data.indexOf('&', i);
+    if (i == -1)
+      break;
+    ++i;
+    ++_currentArgCount;
+  }
+#ifdef DEBUG_ESP_HTTP_SERVER
+  DEBUG_OUTPUT.print("args count: ");
+  DEBUG_OUTPUT.println(_currentArgCount);
+#endif
+
+  _currentArgs = new RequestArgument[_currentArgCount+1];
+  int pos = 0;
+  int iarg;
+  for (iarg = 0; iarg < _currentArgCount;) {
+    int equal_sign_index = data.indexOf('=', pos);
+    int next_arg_index = data.indexOf('&', pos);
+#ifdef DEBUG_ESP_HTTP_SERVER
+    DEBUG_OUTPUT.print("pos ");
+    DEBUG_OUTPUT.print(pos);
+    DEBUG_OUTPUT.print("=@ ");
+    DEBUG_OUTPUT.print(equal_sign_index);
+    DEBUG_OUTPUT.print(" &@ ");
+    DEBUG_OUTPUT.println(next_arg_index);
+#endif
+    if ((equal_sign_index == -1) || ((equal_sign_index > next_arg_index) && (next_arg_index != -1))) {
+#ifdef DEBUG_ESP_HTTP_SERVER
+      DEBUG_OUTPUT.print("arg missing value: ");
+      DEBUG_OUTPUT.println(iarg);
+#endif
+      if (next_arg_index == -1)
+        break;
+      pos = next_arg_index + 1;
+      continue;
+    }
+    RequestArgument& arg = _currentArgs[iarg];
+    arg.key = urlDecode(data.substring(pos, equal_sign_index));
+    arg.value = urlDecode(data.substring(equal_sign_index + 1, next_arg_index));
+#ifdef DEBUG_ESP_HTTP_SERVER
+    DEBUG_OUTPUT.print("arg ");
+    DEBUG_OUTPUT.print(iarg);
+    DEBUG_OUTPUT.print(" key: ");
+    DEBUG_OUTPUT.print(arg.key);
+    DEBUG_OUTPUT.print(" value: ");
+    DEBUG_OUTPUT.println(arg.value);
+#endif
+    ++iarg;
+    if (next_arg_index == -1)
+      break;
+    pos = next_arg_index + 1;
+  }
+  _currentArgCount = iarg;
+#ifdef DEBUG_ESP_HTTP_SERVER
+  DEBUG_OUTPUT.print("args count: ");
+  DEBUG_OUTPUT.println(_currentArgCount);
+#endif
+
+}
+
+void WebServer::_uploadWriteByte(uint8_t b){
+  if (_currentUpload->currentSize == HTTP_UPLOAD_BUFLEN){
+    if(_currentHandler && _currentHandler->canUpload(_currentUri))
+      _currentHandler->upload(*this, _currentUri, *_currentUpload);
+    _currentUpload->totalSize += _currentUpload->currentSize;
+    _currentUpload->currentSize = 0;
+  }
+  _currentUpload->buf[_currentUpload->currentSize++] = b;
+}
+
+uint8_t WebServer::_uploadReadByte(WiFiClient& client){
+  int res = client.read();
+  if(res == -1){
+    while(!client.available() && client.connected())
+      yield();
+    res = client.read();
+  }
+  return (uint8_t)res;
+}
+
+bool WebServer::_parseForm(WiFiClient& client, String boundary, uint32_t len){
+  (void) len;
+#ifdef DEBUG_ESP_HTTP_SERVER
+  DEBUG_OUTPUT.print("Parse Form: Boundary: ");
+  DEBUG_OUTPUT.print(boundary);
+  DEBUG_OUTPUT.print(" Length: ");
+  DEBUG_OUTPUT.println(len);
+#endif
+  String line;
+  int retry = 0;
+  do {
+    line = client.readStringUntil('\r');
+    ++retry;
+  } while (line.length() == 0 && retry < 3);
+
+  client.readStringUntil('\n');
+  //start reading the form
+  if (line == ("--"+boundary)){
+    RequestArgument* postArgs = new RequestArgument[32];
+    int postArgsLen = 0;
+    while(1){
+      String argName;
+      String argValue;
+      String argType;
+      String argFilename;
+      bool argIsFile = false;
+
+      line = client.readStringUntil('\r');
+      client.readStringUntil('\n');
+      if (line.length() > 19 && line.substring(0, 19).equalsIgnoreCase(F("Content-Disposition"))){
+        int nameStart = line.indexOf('=');
+        if (nameStart != -1){
+          argName = line.substring(nameStart+2);
+          nameStart = argName.indexOf('=');
+          if (nameStart == -1){
+            argName = argName.substring(0, argName.length() - 1);
+          } else {
+            argFilename = argName.substring(nameStart+2, argName.length() - 1);
+            argName = argName.substring(0, argName.indexOf('"'));
+            argIsFile = true;
+#ifdef DEBUG_ESP_HTTP_SERVER
+            DEBUG_OUTPUT.print("PostArg FileName: ");
+            DEBUG_OUTPUT.println(argFilename);
+#endif
+            //use GET to set the filename if uploading using blob
+            if (argFilename == F("blob") && hasArg(FPSTR(filename))) 
+              argFilename = arg(FPSTR(filename));
+          }
+#ifdef DEBUG_ESP_HTTP_SERVER
+          DEBUG_OUTPUT.print("PostArg Name: ");
+          DEBUG_OUTPUT.println(argName);
+#endif
+          using namespace mime;
+          argType = FPSTR(mimeTable[txt].mimeType);
+          line = client.readStringUntil('\r');
+          client.readStringUntil('\n');
+          if (line.length() > 12 && line.substring(0, 12).equalsIgnoreCase(FPSTR(Content_Type))){
+            argType = line.substring(line.indexOf(':')+2);
+            //skip next line
+            client.readStringUntil('\r');
+            client.readStringUntil('\n');
+          }
+#ifdef DEBUG_ESP_HTTP_SERVER
+          DEBUG_OUTPUT.print("PostArg Type: ");
+          DEBUG_OUTPUT.println(argType);
+#endif
+          if (!argIsFile){
+            while(1){
+              line = client.readStringUntil('\r');
+              client.readStringUntil('\n');
+              if (line.startsWith("--"+boundary)) break;
+              if (argValue.length() > 0) argValue += "\n";
+              argValue += line;
+            }
+#ifdef DEBUG_ESP_HTTP_SERVER
+            DEBUG_OUTPUT.print("PostArg Value: ");
+            DEBUG_OUTPUT.println(argValue);
+            DEBUG_OUTPUT.println();
+#endif
+
+            RequestArgument& arg = postArgs[postArgsLen++];
+            arg.key = argName;
+            arg.value = argValue;
+
+            if (line == ("--"+boundary+"--")){
+#ifdef DEBUG_ESP_HTTP_SERVER
+              DEBUG_OUTPUT.println("Done Parsing POST");
+#endif
+              break;
+            }
+          } else {
+            _currentUpload.reset(new HTTPUpload());
+            _currentUpload->status = UPLOAD_FILE_START;
+            _currentUpload->name = argName;
+            _currentUpload->filename = argFilename;
+            _currentUpload->type = argType;
+            _currentUpload->totalSize = 0;
+            _currentUpload->currentSize = 0;
+#ifdef DEBUG_ESP_HTTP_SERVER
+            DEBUG_OUTPUT.print("Start File: ");
+            DEBUG_OUTPUT.print(_currentUpload->filename);
+            DEBUG_OUTPUT.print(" Type: ");
+            DEBUG_OUTPUT.println(_currentUpload->type);
+#endif
+            if(_currentHandler && _currentHandler->canUpload(_currentUri))
+              _currentHandler->upload(*this, _currentUri, *_currentUpload);
+            _currentUpload->status = UPLOAD_FILE_WRITE;
+            uint8_t argByte = _uploadReadByte(client);
+readfile:
+            while(argByte != 0x0D){
+              if (!client.connected()) return _parseFormUploadAborted();
+              _uploadWriteByte(argByte);
+              argByte = _uploadReadByte(client);
+            }
+
+            argByte = _uploadReadByte(client);
+            if (!client.connected()) return _parseFormUploadAborted();
+            if (argByte == 0x0A){
+              argByte = _uploadReadByte(client);
+              if (!client.connected()) return _parseFormUploadAborted();
+              if ((char)argByte != '-'){
+                //continue reading the file
+                _uploadWriteByte(0x0D);
+                _uploadWriteByte(0x0A);
+                goto readfile;
+              } else {
+                argByte = _uploadReadByte(client);
+                if (!client.connected()) return _parseFormUploadAborted();
+                if ((char)argByte != '-'){
+                  //continue reading the file
+                  _uploadWriteByte(0x0D);
+                  _uploadWriteByte(0x0A);
+                  _uploadWriteByte((uint8_t)('-'));
+                  goto readfile;
+                }
+              }
+
+              uint8_t endBuf[boundary.length()];
+              client.readBytes(endBuf, boundary.length());
+
+              if (strstr((const char*)endBuf, boundary.c_str()) != NULL){
+                if(_currentHandler && _currentHandler->canUpload(_currentUri))
+                  _currentHandler->upload(*this, _currentUri, *_currentUpload);
+                _currentUpload->totalSize += _currentUpload->currentSize;
+                _currentUpload->status = UPLOAD_FILE_END;
+                if(_currentHandler && _currentHandler->canUpload(_currentUri))
+                  _currentHandler->upload(*this, _currentUri, *_currentUpload);
+#ifdef DEBUG_ESP_HTTP_SERVER
+                DEBUG_OUTPUT.print("End File: ");
+                DEBUG_OUTPUT.print(_currentUpload->filename);
+                DEBUG_OUTPUT.print(" Type: ");
+                DEBUG_OUTPUT.print(_currentUpload->type);
+                DEBUG_OUTPUT.print(" Size: ");
+                DEBUG_OUTPUT.println(_currentUpload->totalSize);
+#endif
+                line = client.readStringUntil(0x0D);
+                client.readStringUntil(0x0A);
+                if (line == "--"){
+#ifdef DEBUG_ESP_HTTP_SERVER
+                  DEBUG_OUTPUT.println("Done Parsing POST");
+#endif
+                  break;
+                }
+                continue;
+              } else {
+                _uploadWriteByte(0x0D);
+                _uploadWriteByte(0x0A);
+                _uploadWriteByte((uint8_t)('-'));
+                _uploadWriteByte((uint8_t)('-'));
+                uint32_t i = 0;
+                while(i < boundary.length()){
+                  _uploadWriteByte(endBuf[i++]);
+                }
+                argByte = _uploadReadByte(client);
+                goto readfile;
+              }
+            } else {
+              _uploadWriteByte(0x0D);
+              goto readfile;
+            }
+            break;
+          }
+        }
+      }
+    }
+
+    int iarg;
+    int totalArgs = ((32 - postArgsLen) < _currentArgCount)?(32 - postArgsLen):_currentArgCount;
+    for (iarg = 0; iarg < totalArgs; iarg++){
+      RequestArgument& arg = postArgs[postArgsLen++];
+      arg.key = _currentArgs[iarg].key;
+      arg.value = _currentArgs[iarg].value;
+    }
+    if (_currentArgs) delete[] _currentArgs;
+    _currentArgs = new RequestArgument[postArgsLen];
+    for (iarg = 0; iarg < postArgsLen; iarg++){
+      RequestArgument& arg = _currentArgs[iarg];
+      arg.key = postArgs[iarg].key;
+      arg.value = postArgs[iarg].value;
+    }
+    _currentArgCount = iarg;
+    if (postArgs) 
+      delete[] postArgs;
+    return true;
+  }
+#ifdef DEBUG_ESP_HTTP_SERVER
+  DEBUG_OUTPUT.print("Error: line: ");
+  DEBUG_OUTPUT.println(line);
+#endif
+  return false;
+}
+
+String WebServer::urlDecode(const String& text)
+{
+	String decoded = "";
+	char temp[] = "0x00";
+	unsigned int len = text.length();
+	unsigned int i = 0;
+	while (i < len)
+	{
+		char decodedChar;
+		char encodedChar = text.charAt(i++);
+		if ((encodedChar == '%') && (i + 1 < len))
+		{
+			temp[2] = text.charAt(i++);
+			temp[3] = text.charAt(i++);
+
+			decodedChar = strtol(temp, NULL, 16);
+		}
+		else {
+			if (encodedChar == '+')
+			{
+				decodedChar = ' ';
+			}
+			else {
+				decodedChar = encodedChar;  // normal ascii char
+			}
+		}
+		decoded += decodedChar;
+	}
+	return decoded;
+}
+
+bool WebServer::_parseFormUploadAborted(){
+  _currentUpload->status = UPLOAD_FILE_ABORTED;
+  if(_currentHandler && _currentHandler->canUpload(_currentUri))
+    _currentHandler->upload(*this, _currentUri, *_currentUpload);
+  return false;
+}

libraries/WebServer/src/WebServer.cpp

@@ -0,0 +1,676 @@
+/*
+  WebServer.cpp - Dead simple web-server.
+  Supports only one simultaneous client, knows how to handle GET and POST.
+
+  Copyright (c) 2014 Ivan Grokhotkov. All rights reserved.
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+  Modified 8 May 2015 by Hristo Gochkov (proper post and file upload handling)
+*/
+
+
+#include <Arduino.h>
+#include <libb64/cencode.h>
+#include "WiFiServer.h"
+#include "WiFiClient.h"
+#include "WebServer.h"
+#include "FS.h"
+#include "detail/RequestHandlersImpl.h"
+#include "mbedtls/md5.h"
+
+//#define DEBUG_ESP_HTTP_SERVER
+#ifdef DEBUG_ESP_PORT
+#define DEBUG_OUTPUT DEBUG_ESP_PORT
+#else
+#define DEBUG_OUTPUT Serial
+#endif
+
+static const char AUTHORIZATION_HEADER[] = "Authorization";
+static const char qop_auth[] = "qop=auth";
+static const char WWW_Authenticate[] = "WWW-Authenticate";
+static const char Content_Length[] = "Content-Length";
+
+
+WebServer::WebServer(IPAddress addr, int port)
+: _server(addr, port)
+, _currentMethod(HTTP_ANY)
+, _currentVersion(0)
+, _currentStatus(HC_NONE)
+, _statusChange(0)
+, _currentHandler(nullptr)
+, _firstHandler(nullptr)
+, _lastHandler(nullptr)
+, _currentArgCount(0)
+, _currentArgs(nullptr)
+, _headerKeysCount(0)
+, _currentHeaders(nullptr)
+, _contentLength(0)
+, _chunked(false)
+{
+}
+
+WebServer::WebServer(int port)
+: _server(port)
+, _currentMethod(HTTP_ANY)
+, _currentVersion(0)
+, _currentStatus(HC_NONE)
+, _statusChange(0)
+, _currentHandler(nullptr)
+, _firstHandler(nullptr)
+, _lastHandler(nullptr)
+, _currentArgCount(0)
+, _currentArgs(nullptr)
+, _headerKeysCount(0)
+, _currentHeaders(nullptr)
+, _contentLength(0)
+, _chunked(false)
+{
+}
+
+WebServer::~WebServer() {
+  _server.close();
+  if (_currentHeaders)
+    delete[]_currentHeaders;
+  RequestHandler* handler = _firstHandler;
+  while (handler) {
+    RequestHandler* next = handler->next();
+    delete handler;
+    handler = next;
+  }
+}
+
+void WebServer::begin() {
+  close();
+  _server.begin();
+}
+
+void WebServer::begin(uint16_t port) {
+  close();
+  _server.begin(port);
+}
+
+String WebServer::_extractParam(String& authReq,const String& param,const char delimit){
+  int _begin = authReq.indexOf(param);
+  if (_begin == -1) 
+    return "";
+  return authReq.substring(_begin+param.length(),authReq.indexOf(delimit,_begin+param.length()));
+}
+
+static String md5str(String &in){
+  char out[33] = {0};
+  mbedtls_md5_context _ctx;
+  uint8_t i;
+  uint8_t * _buf = (uint8_t*)malloc(16);
+  if(_buf == NULL)
+    return String(out);
+  memset(_buf, 0x00, 16);
+  mbedtls_md5_init(&_ctx);
+  mbedtls_md5_starts(&_ctx);
+  mbedtls_md5_update(&_ctx, (const uint8_t *)in.c_str(), in.length());
+  mbedtls_md5_finish(&_ctx, _buf);
+  for(i = 0; i < 16; i++) {
+    sprintf(out + (i * 2), "%02x", _buf[i]);
+  }
+  out[32] = 0;
+  free(_buf);
+  return String(out);
+}
+
+bool WebServer::authenticate(const char * username, const char * password){
+  if(hasHeader(FPSTR(AUTHORIZATION_HEADER))) {
+    String authReq = header(FPSTR(AUTHORIZATION_HEADER));
+    if(authReq.startsWith(F("Basic"))){
+      authReq = authReq.substring(6);
+      authReq.trim();
+      char toencodeLen = strlen(username)+strlen(password)+1;
+      char *toencode = new char[toencodeLen + 1];
+      if(toencode == NULL){
+        authReq = "";
+        return false;
+      }
+      char *encoded = new char[base64_encode_expected_len(toencodeLen)+1];
+      if(encoded == NULL){
+        authReq = "";
+        delete[] toencode;
+        return false;
+      }
+      sprintf(toencode, "%s:%s", username, password);
+      if(base64_encode_chars(toencode, toencodeLen, encoded) > 0 && authReq.equalsConstantTime(encoded)) {
+        authReq = "";
+        delete[] toencode;
+        delete[] encoded;
+        return true;
+      }
+      delete[] toencode;
+      delete[] encoded;
+    } else if(authReq.startsWith(F("Digest"))) {
+      authReq = authReq.substring(7);
+      #ifdef DEBUG_ESP_HTTP_SERVER
+      DEBUG_OUTPUT.println(authReq);
+      #endif
+      String _username = _extractParam(authReq,F("username=\""));
+      if(!_username.length() || _username != String(username)) {
+        authReq = "";
+        return false;
+      }
+      // extracting required parameters for RFC 2069 simpler Digest
+      String _realm    = _extractParam(authReq, F("realm=\""));
+      String _nonce    = _extractParam(authReq, F("nonce=\""));
+      String _uri      = _extractParam(authReq, F("uri=\""));
+      String _response = _extractParam(authReq, F("response=\""));
+      String _opaque   = _extractParam(authReq, F("opaque=\""));
+
+      if((!_realm.length()) || (!_nonce.length()) || (!_uri.length()) || (!_response.length()) || (!_opaque.length())) {
+        authReq = "";
+        return false;
+      }
+      if((_opaque != _sopaque) || (_nonce != _snonce) || (_realm != _srealm)) {
+        authReq = "";
+        return false;
+      }
+      // parameters for the RFC 2617 newer Digest
+      String _nc,_cnonce;
+      if(authReq.indexOf(FPSTR(qop_auth)) != -1) {
+        _nc = _extractParam(authReq, F("nc="), ',');
+        _cnonce = _extractParam(authReq, F("cnonce=\""));
+      }
+      String _H1 = md5str(String(username) + ':' + _realm + ':' + String(password));
+      #ifdef DEBUG_ESP_HTTP_SERVER
+      DEBUG_OUTPUT.println("Hash of user:realm:pass=" + _H1);
+      #endif
+      String _H2 = "";
+      if(_currentMethod == HTTP_GET){
+          _H2 = md5str(String(F("GET:")) + _uri);
+      }else if(_currentMethod == HTTP_POST){
+          _H2 = md5str(String(F("POST:")) + _uri);
+      }else if(_currentMethod == HTTP_PUT){
+          _H2 = md5str(String(F("PUT:")) + _uri);
+      }else if(_currentMethod == HTTP_DELETE){
+          _H2 = md5str(String(F("DELETE:")) + _uri);
+      }else{
+          _H2 = md5str(String(F("GET:")) + _uri);
+      }
+      #ifdef DEBUG_ESP_HTTP_SERVER
+      DEBUG_OUTPUT.println("Hash of GET:uri=" + _H2);
+      #endif
+      String _responsecheck = "";
+      if(authReq.indexOf(FPSTR(qop_auth)) != -1) {
+          _responsecheck = md5str(_H1 + ':' + _nonce + ':' + _nc + ':' + _cnonce + F(":auth:") + _H2);
+      } else {
+          _responsecheck = md5str(_H1 + ':' + _nonce + ':' + _H2);
+      }
+      #ifdef DEBUG_ESP_HTTP_SERVER
+      DEBUG_OUTPUT.println("The Proper response=" +_responsecheck);
+      #endif
+      if(_response == _responsecheck){
+        authReq = "";
+        return true;
+      }
+    }
+    authReq = "";
+  }
+  return false;
+}
+
+String WebServer::_getRandomHexString() {
+  char buffer[33];  // buffer to hold 32 Hex Digit + /0
+  int i;
+  for(i = 0; i < 4; i++) {
+    sprintf (buffer + (i*8), "%08x", esp_random());
+  }
+  return String(buffer);
+}
+
+void WebServer::requestAuthentication(HTTPAuthMethod mode, const char* realm, const String& authFailMsg) {
+  if(realm == NULL) {
+    _srealm = String(F("Login Required"));
+  } else {
+    _srealm = String(realm);
+  }
+  if(mode == BASIC_AUTH) {
+    sendHeader(String(FPSTR(WWW_Authenticate)), String(F("Basic realm=\"")) + _srealm + String(F("\"")));
+  } else {
+    _snonce=_getRandomHexString();
+    _sopaque=_getRandomHexString();
+    sendHeader(String(FPSTR(WWW_Authenticate)), String(F("Digest realm=\"")) +_srealm + String(F("\", qop=\"auth\", nonce=\"")) + _snonce + String(F("\", opaque=\"")) + _sopaque + String(F("\"")));
+  }
+  using namespace mime;
+  send(401, String(FPSTR(mimeTable[html].mimeType)), authFailMsg);
+}
+
+void WebServer::on(const String &uri, WebServer::THandlerFunction handler) {
+  on(uri, HTTP_ANY, handler);
+}
+
+void WebServer::on(const String &uri, HTTPMethod method, WebServer::THandlerFunction fn) {
+  on(uri, method, fn, _fileUploadHandler);
+}
+
+void WebServer::on(const String &uri, HTTPMethod method, WebServer::THandlerFunction fn, WebServer::THandlerFunction ufn) {
+  _addRequestHandler(new FunctionRequestHandler(fn, ufn, uri, method));
+}
+
+void WebServer::addHandler(RequestHandler* handler) {
+    _addRequestHandler(handler);
+}
+
+void WebServer::_addRequestHandler(RequestHandler* handler) {
+    if (!_lastHandler) {
+      _firstHandler = handler;
+      _lastHandler = handler;
+    }
+    else {
+      _lastHandler->next(handler);
+      _lastHandler = handler;
+    }
+}
+
+void WebServer::serveStatic(const char* uri, FS& fs, const char* path, const char* cache_header) {
+    _addRequestHandler(new StaticRequestHandler(fs, path, uri, cache_header));
+}
+
+void WebServer::handleClient() {
+  if (_currentStatus == HC_NONE) {
+    WiFiClient client = _server.available();
+    if (!client) {
+      return;
+    }
+
+#ifdef DEBUG_ESP_HTTP_SERVER
+    DEBUG_OUTPUT.println("New client");
+#endif
+
+    _currentClient = client;
+    _currentStatus = HC_WAIT_READ;
+    _statusChange = millis();
+  }
+
+  bool keepCurrentClient = false;
+  bool callYield = false;
+
+  if (_currentClient.connected()) {
+    switch (_currentStatus) {
+    case HC_NONE:
+      // No-op to avoid C++ compiler warning
+      break;
+    case HC_WAIT_READ:
+      // Wait for data from client to become available
+      if (_currentClient.available()) {
+        if (_parseRequest(_currentClient)) {
+          _currentClient.setTimeout(HTTP_MAX_SEND_WAIT);
+          _contentLength = CONTENT_LENGTH_NOT_SET;
+          _handleRequest();
+
+          if (_currentClient.connected()) {
+            _currentStatus = HC_WAIT_CLOSE;
+            _statusChange = millis();
+            keepCurrentClient = true;
+          }
+        }
+      } else { // !_currentClient.available()
+        if (millis() - _statusChange <= HTTP_MAX_DATA_WAIT) {
+          keepCurrentClient = true;
+        }
+        callYield = true;
+      }
+      break;
+    case HC_WAIT_CLOSE:
+      // Wait for client to close the connection
+      if (millis() - _statusChange <= HTTP_MAX_CLOSE_WAIT) {
+        keepCurrentClient = true;
+        callYield = true;
+      }
+    }
+  }
+
+  if (!keepCurrentClient) {
+    _currentClient = WiFiClient();
+    _currentStatus = HC_NONE;
+    _currentUpload.reset();
+  }
+
+  if (callYield) {
+    yield();
+  }
+}
+
+void WebServer::close() {
+  _server.close();
+  _currentStatus = HC_NONE;
+  if(!_headerKeysCount)
+    collectHeaders(0, 0);
+}
+
+void WebServer::stop() {
+  close();
+}
+
+void WebServer::sendHeader(const String& name, const String& value, bool first) {
+  String headerLine = name;
+  headerLine += F(": ");
+  headerLine += value;
+  headerLine += "\r\n";
+
+  if (first) {
+    _responseHeaders = headerLine + _responseHeaders;
+  }
+  else {
+    _responseHeaders += headerLine;
+  }
+}
+
+void WebServer::setContentLength(const size_t contentLength) {
+    _contentLength = contentLength;
+}
+
+void WebServer::_prepareHeader(String& response, int code, const char* content_type, size_t contentLength) {
+    response = String(F("HTTP/1.")) + String(_currentVersion) + ' ';
+    response += String(code);
+    response += ' ';
+    response += _responseCodeToString(code);
+    response += "\r\n";
+
+    using namespace mime;
+    if (!content_type)
+        content_type = mimeTable[html].mimeType;
+
+    sendHeader(String(F("Content-Type")), String(FPSTR(content_type)), true);
+    if (_contentLength == CONTENT_LENGTH_NOT_SET) {
+        sendHeader(String(FPSTR(Content_Length)), String(contentLength));
+    } else if (_contentLength != CONTENT_LENGTH_UNKNOWN) {
+        sendHeader(String(FPSTR(Content_Length)), String(_contentLength));
+    } else if(_contentLength == CONTENT_LENGTH_UNKNOWN && _currentVersion){ //HTTP/1.1 or above client
+      //let's do chunked
+      _chunked = true;
+      sendHeader(String(F("Accept-Ranges")),String(F("none")));
+      sendHeader(String(F("Transfer-Encoding")),String(F("chunked")));
+    }
+    sendHeader(String(F("Connection")), String(F("close")));
+
+    response += _responseHeaders;
+    response += "\r\n";
+    _responseHeaders = "";
+}
+
+void WebServer::send(int code, const char* content_type, const String& content) {
+    String header;
+    // Can we asume the following?
+    //if(code == 200 && content.length() == 0 && _contentLength == CONTENT_LENGTH_NOT_SET)
+    //  _contentLength = CONTENT_LENGTH_UNKNOWN;
+    _prepareHeader(header, code, content_type, content.length());
+    _currentClientWrite(header.c_str(), header.length());
+    if(content.length())
+      sendContent(content);
+}
+
+void WebServer::send_P(int code, PGM_P content_type, PGM_P content) {
+    size_t contentLength = 0;
+
+    if (content != NULL) {
+        contentLength = strlen_P(content);
+    }
+
+    String header;
+    char type[64];
+    memccpy_P((void*)type, (PGM_VOID_P)content_type, 0, sizeof(type));
+    _prepareHeader(header, code, (const char* )type, contentLength);
+    _currentClientWrite(header.c_str(), header.length());
+    sendContent_P(content);
+}
+
+void WebServer::send_P(int code, PGM_P content_type, PGM_P content, size_t contentLength) {
+    String header;
+    char type[64];
+    memccpy_P((void*)type, (PGM_VOID_P)content_type, 0, sizeof(type));
+    _prepareHeader(header, code, (const char* )type, contentLength);
+    sendContent(header);
+    sendContent_P(content, contentLength);
+}
+
+void WebServer::send(int code, char* content_type, const String& content) {
+  send(code, (const char*)content_type, content);
+}
+
+void WebServer::send(int code, const String& content_type, const String& content) {
+  send(code, (const char*)content_type.c_str(), content);
+}
+
+void WebServer::sendContent(const String& content) {
+  const char * footer = "\r\n";
+  size_t len = content.length();
+  if(_chunked) {
+    char * chunkSize = (char *)malloc(11);
+    if(chunkSize){
+      sprintf(chunkSize, "%x%s", len, footer);
+      _currentClientWrite(chunkSize, strlen(chunkSize));
+      free(chunkSize);
+    }
+  }
+  _currentClientWrite(content.c_str(), len);
+  if(_chunked){
+    _currentClient.write(footer, 2);
+    if (len == 0) {
+      _chunked = false;
+    }
+  }
+}
+
+void WebServer::sendContent_P(PGM_P content) {
+  sendContent_P(content, strlen_P(content));
+}
+
+void WebServer::sendContent_P(PGM_P content, size_t size) {
+  const char * footer = "\r\n";
+  if(_chunked) {
+    char * chunkSize = (char *)malloc(11);
+    if(chunkSize){
+      sprintf(chunkSize, "%x%s", size, footer);
+      _currentClientWrite(chunkSize, strlen(chunkSize));
+      free(chunkSize);
+    }
+  }
+  _currentClientWrite_P(content, size);
+  if(_chunked){
+    _currentClient.write(footer, 2);
+    if (size == 0) {
+      _chunked = false;
+    }
+  }
+}
+
+
+void WebServer::_streamFileCore(const size_t fileSize, const String & fileName, const String & contentType)
+{
+  using namespace mime;
+  setContentLength(fileSize);
+  if (fileName.endsWith(String(FPSTR(mimeTable[gz].endsWith))) &&
+      contentType != String(FPSTR(mimeTable[gz].mimeType)) &&
+      contentType != String(FPSTR(mimeTable[none].mimeType))) {
+    sendHeader(F("Content-Encoding"), F("gzip"));
+  }
+  send(200, contentType, "");
+}
+
+
+String WebServer::arg(String name) {
+  for (int i = 0; i < _currentArgCount; ++i) {
+    if ( _currentArgs[i].key == name )
+      return _currentArgs[i].value;
+  }
+  return "";
+}
+
+String WebServer::arg(int i) {
+  if (i < _currentArgCount)
+    return _currentArgs[i].value;
+  return "";
+}
+
+String WebServer::argName(int i) {
+  if (i < _currentArgCount)
+    return _currentArgs[i].key;
+  return "";
+}
+
+int WebServer::args() {
+  return _currentArgCount;
+}
+
+bool WebServer::hasArg(String  name) {
+  for (int i = 0; i < _currentArgCount; ++i) {
+    if (_currentArgs[i].key == name)
+      return true;
+  }
+  return false;
+}
+
+
+String WebServer::header(String name) {
+  for (int i = 0; i < _headerKeysCount; ++i) {
+    if (_currentHeaders[i].key.equalsIgnoreCase(name))
+      return _currentHeaders[i].value;
+  }
+  return "";
+}
+
+void WebServer::collectHeaders(const char* headerKeys[], const size_t headerKeysCount) {
+  _headerKeysCount = headerKeysCount + 1;
+  if (_currentHeaders)
+     delete[]_currentHeaders;
+  _currentHeaders = new RequestArgument[_headerKeysCount];
+  _currentHeaders[0].key = FPSTR(AUTHORIZATION_HEADER);
+  for (int i = 1; i < _headerKeysCount; i++){
+    _currentHeaders[i].key = headerKeys[i-1];
+  }
+}
+
+String WebServer::header(int i) {
+  if (i < _headerKeysCount)
+    return _currentHeaders[i].value;
+  return "";
+}
+
+String WebServer::headerName(int i) {
+  if (i < _headerKeysCount)
+    return _currentHeaders[i].key;
+  return "";
+}
+
+int WebServer::headers() {
+  return _headerKeysCount;
+}
+
+bool WebServer::hasHeader(String name) {
+  for (int i = 0; i < _headerKeysCount; ++i) {
+    if ((_currentHeaders[i].key.equalsIgnoreCase(name)) &&  (_currentHeaders[i].value.length() > 0))
+      return true;
+  }
+  return false;
+}
+
+String WebServer::hostHeader() {
+  return _hostHeader;
+}
+
+void WebServer::onFileUpload(THandlerFunction fn) {
+  _fileUploadHandler = fn;
+}
+
+void WebServer::onNotFound(THandlerFunction fn) {
+  _notFoundHandler = fn;
+}
+
+void WebServer::_handleRequest() {
+  bool handled = false;
+  if (!_currentHandler){
+#ifdef DEBUG_ESP_HTTP_SERVER
+    DEBUG_OUTPUT.println("request handler not found");
+#endif
+  }
+  else {
+    handled = _currentHandler->handle(*this, _currentMethod, _currentUri);
+#ifdef DEBUG_ESP_HTTP_SERVER
+    if (!handled) {
+      DEBUG_OUTPUT.println("request handler failed to handle request");
+    }
+#endif
+  }
+  if (!handled && _notFoundHandler) {
+    _notFoundHandler();
+    handled = true;
+  }
+  if (!handled) {
+    using namespace mime;
+    send(404, String(FPSTR(mimeTable[html].mimeType)), String(F("Not found: ")) + _currentUri);
+    handled = true;
+  }
+  if (handled) {
+    _finalizeResponse();
+  }
+  _currentUri = "";
+}
+
+
+void WebServer::_finalizeResponse() {
+  if (_chunked) {
+    sendContent("");
+  }
+}
+
+String WebServer::_responseCodeToString(int code) {
+  switch (code) {
+    case 100: return F("Continue");
+    case 101: return F("Switching Protocols");
+    case 200: return F("OK");
+    case 201: return F("Created");
+    case 202: return F("Accepted");
+    case 203: return F("Non-Authoritative Information");
+    case 204: return F("No Content");
+    case 205: return F("Reset Content");
+    case 206: return F("Partial Content");
+    case 300: return F("Multiple Choices");
+    case 301: return F("Moved Permanently");
+    case 302: return F("Found");
+    case 303: return F("See Other");
+    case 304: return F("Not Modified");
+    case 305: return F("Use Proxy");
+    case 307: return F("Temporary Redirect");
+    case 400: return F("Bad Request");
+    case 401: return F("Unauthorized");
+    case 402: return F("Payment Required");
+    case 403: return F("Forbidden");
+    case 404: return F("Not Found");
+    case 405: return F("Method Not Allowed");
+    case 406: return F("Not Acceptable");
+    case 407: return F("Proxy Authentication Required");
+    case 408: return F("Request Time-out");
+    case 409: return F("Conflict");
+    case 410: return F("Gone");
+    case 411: return F("Length Required");
+    case 412: return F("Precondition Failed");
+    case 413: return F("Request Entity Too Large");
+    case 414: return F("Request-URI Too Large");
+    case 415: return F("Unsupported Media Type");
+    case 416: return F("Requested range not satisfiable");
+    case 417: return F("Expectation Failed");
+    case 500: return F("Internal Server Error");
+    case 501: return F("Not Implemented");
+    case 502: return F("Bad Gateway");
+    case 503: return F("Service Unavailable");
+    case 504: return F("Gateway Time-out");
+    case 505: return F("HTTP Version not supported");
+    default:  return F("");
+  }
+}

libraries/WebServer/src/WebServer.h

@@ -0,0 +1,199 @@
+/*
+  WebServer.h - Dead simple web-server.
+  Supports only one simultaneous client, knows how to handle GET and POST.
+
+  Copyright (c) 2014 Ivan Grokhotkov. All rights reserved.
+
+  This library is free software; you can redistribute it and/or
+  modify it under the terms of the GNU Lesser General Public
+  License as published by the Free Software Foundation; either
+  version 2.1 of the License, or (at your option) any later version.
+
+  This library is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public
+  License along with this library; if not, write to the Free Software
+  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+  Modified 8 May 2015 by Hristo Gochkov (proper post and file upload handling)
+*/
+
+
+#ifndef WEBSERVER_H
+#define WEBSERVER_H
+
+#include <functional>
+#include <memory>
+#include <WiFi.h>
+
+enum HTTPMethod { HTTP_ANY, HTTP_GET, HTTP_POST, HTTP_PUT, HTTP_PATCH, HTTP_DELETE, HTTP_OPTIONS };
+enum HTTPUploadStatus { UPLOAD_FILE_START, UPLOAD_FILE_WRITE, UPLOAD_FILE_END,
+                        UPLOAD_FILE_ABORTED };
+enum HTTPClientStatus { HC_NONE, HC_WAIT_READ, HC_WAIT_CLOSE };
+enum HTTPAuthMethod { BASIC_AUTH, DIGEST_AUTH };
+
+#define HTTP_DOWNLOAD_UNIT_SIZE 1460
+
+#ifndef HTTP_UPLOAD_BUFLEN
+#define HTTP_UPLOAD_BUFLEN 2048
+#endif
+
+#define HTTP_MAX_DATA_WAIT 5000 //ms to wait for the client to send the request
+#define HTTP_MAX_POST_WAIT 5000 //ms to wait for POST data to arrive
+#define HTTP_MAX_SEND_WAIT 5000 //ms to wait for data chunk to be ACKed
+#define HTTP_MAX_CLOSE_WAIT 2000 //ms to wait for the client to close the connection
+
+#define CONTENT_LENGTH_UNKNOWN ((size_t) -1)
+#define CONTENT_LENGTH_NOT_SET ((size_t) -2)
+
+class WebServer;
+
+typedef struct {
+  HTTPUploadStatus status;
+  String  filename;
+  String  name;
+  String  type;
+  size_t  totalSize;    // file size
+  size_t  currentSize;  // size of data currently in buf
+  uint8_t buf[HTTP_UPLOAD_BUFLEN];
+} HTTPUpload;
+
+#include "detail/RequestHandler.h"
+
+namespace fs {
+class FS;
+}
+
+class WebServer
+{
+public:
+  WebServer(IPAddress addr, int port = 80);
+  WebServer(int port = 80);
+  virtual ~WebServer();
+
+  virtual void begin();
+  virtual void begin(uint16_t port);
+  virtual void handleClient();
+
+  virtual void close();
+  void stop();
+
+  bool authenticate(const char * username, const char * password);
+  void requestAuthentication(HTTPAuthMethod mode = BASIC_AUTH, const char* realm = NULL, const String& authFailMsg = String("") );
+
+  typedef std::function<void(void)> THandlerFunction;
+  void on(const String &uri, THandlerFunction handler);
+  void on(const String &uri, HTTPMethod method, THandlerFunction fn);
+  void on(const String &uri, HTTPMethod method, THandlerFunction fn, THandlerFunction ufn);
+  void addHandler(RequestHandler* handler);
+  void serveStatic(const char* uri, fs::FS& fs, const char* path, const char* cache_header = NULL );
+  void onNotFound(THandlerFunction fn);  //called when handler is not assigned
+  void onFileUpload(THandlerFunction fn); //handle file uploads
+
+  String uri() { return _currentUri; }
+  HTTPMethod method() { return _currentMethod; }
+  virtual WiFiClient client() { return _currentClient; }
+  HTTPUpload& upload() { return *_currentUpload; }
+
+  String arg(String name);        // get request argument value by name
+  String arg(int i);              // get request argument value by number
+  String argName(int i);          // get request argument name by number
+  int args();                     // get arguments count
+  bool hasArg(String name);       // check if argument exists
+  void collectHeaders(const char* headerKeys[], const size_t headerKeysCount); // set the request headers to collect
+  String header(String name);      // get request header value by name
+  String header(int i);              // get request header value by number
+  String headerName(int i);          // get request header name by number
+  int headers();                     // get header count
+  bool hasHeader(String name);       // check if header exists
+
+  String hostHeader();            // get request host header if available or empty String if not
+
+  // send response to the client
+  // code - HTTP response code, can be 200 or 404
+  // content_type - HTTP content type, like "text/plain" or "image/png"
+  // content - actual content body
+  void send(int code, const char* content_type = NULL, const String& content = String(""));
+  void send(int code, char* content_type, const String& content);
+  void send(int code, const String& content_type, const String& content);
+  void send_P(int code, PGM_P content_type, PGM_P content);
+  void send_P(int code, PGM_P content_type, PGM_P content, size_t contentLength);
+
+  void setContentLength(const size_t contentLength);
+  void sendHeader(const String& name, const String& value, bool first = false);
+  void sendContent(const String& content);
+  void sendContent_P(PGM_P content);
+  void sendContent_P(PGM_P content, size_t size);
+
+  static String urlDecode(const String& text);
+
+  template<typename T> 
+  size_t streamFile(T &file, const String& contentType) {
+    _streamFileCore(file.size(), file.name(), contentType);
+    return _currentClient.write(file);
+  }
+  
+protected:
+  virtual size_t _currentClientWrite(const char* b, size_t l) { return _currentClient.write( b, l ); }
+  virtual size_t _currentClientWrite_P(PGM_P b, size_t l) { return _currentClient.write_P( b, l ); }
+  void _addRequestHandler(RequestHandler* handler);
+  void _handleRequest();
+  void _finalizeResponse();
+  bool _parseRequest(WiFiClient& client);
+  void _parseArguments(String data);
+  static String _responseCodeToString(int code);
+  bool _parseForm(WiFiClient& client, String boundary, uint32_t len);
+  bool _parseFormUploadAborted();
+  void _uploadWriteByte(uint8_t b);
+  uint8_t _uploadReadByte(WiFiClient& client);
+  void _prepareHeader(String& response, int code, const char* content_type, size_t contentLength);
+  bool _collectHeader(const char* headerName, const char* headerValue);
+ 
+  void _streamFileCore(const size_t fileSize, const String & fileName, const String & contentType);
+
+  String _getRandomHexString();
+  // for extracting Auth parameters
+  String _extractParam(String& authReq,const String& param,const char delimit = '"');
+
+  struct RequestArgument {
+    String key;
+    String value;
+  };
+
+  WiFiServer  _server;
+
+  WiFiClient  _currentClient;
+  HTTPMethod  _currentMethod;
+  String      _currentUri;
+  uint8_t     _currentVersion;
+  HTTPClientStatus _currentStatus;
+  unsigned long _statusChange;
+
+  RequestHandler*  _currentHandler;
+  RequestHandler*  _firstHandler;
+  RequestHandler*  _lastHandler;
+  THandlerFunction _notFoundHandler;
+  THandlerFunction _fileUploadHandler;
+
+  int              _currentArgCount;
+  RequestArgument* _currentArgs;
+  std::unique_ptr<HTTPUpload> _currentUpload;
+
+  int              _headerKeysCount;
+  RequestArgument* _currentHeaders;
+  size_t           _contentLength;
+  String           _responseHeaders;
+
+  String           _hostHeader;
+  bool             _chunked;
+
+  String           _snonce;  // Store noance and opaque for future comparison
+  String           _sopaque;
+  String           _srealm;  // Store the Auth realm between Calls
+
+};
+
+
+#endif //ESP8266WEBSERVER_H

libraries/WebServer/src/detail/RequestHandler.h

@@ -0,0 +1,19 @@
+#ifndef REQUESTHANDLER_H
+#define REQUESTHANDLER_H
+
+class RequestHandler {
+public:
+    virtual ~RequestHandler() { }
+    virtual bool canHandle(HTTPMethod method, String uri) { (void) method; (void) uri; return false; }
+    virtual bool canUpload(String uri) { (void) uri; return false; }
+    virtual bool handle(WebServer& server, HTTPMethod requestMethod, String requestUri) { (void) server; (void) requestMethod; (void) requestUri; return false; }
+    virtual void upload(WebServer& server, String requestUri, HTTPUpload& upload) { (void) server; (void) requestUri; (void) upload; }
+
+    RequestHandler* next() { return _next; }
+    void next(RequestHandler* r) { _next = r; }
+
+private:
+    RequestHandler* _next = nullptr;
+};
+
+#endif //REQUESTHANDLER_H

libraries/WebServer/src/detail/RequestHandlersImpl.h

@@ -0,0 +1,148 @@
+#ifndef REQUESTHANDLERSIMPL_H
+#define REQUESTHANDLERSIMPL_H
+
+#include "RequestHandler.h"
+#include "mimetable.h"
+#include "WString.h"
+
+using namespace mime;
+
+class FunctionRequestHandler : public RequestHandler {
+public:
+    FunctionRequestHandler(WebServer::THandlerFunction fn, WebServer::THandlerFunction ufn, const String &uri, HTTPMethod method)
+    : _fn(fn)
+    , _ufn(ufn)
+    , _uri(uri)
+    , _method(method)
+    {
+    }
+
+    bool canHandle(HTTPMethod requestMethod, String requestUri) override  {
+        if (_method != HTTP_ANY && _method != requestMethod)
+            return false;
+
+        if (requestUri != _uri)
+            return false;
+
+        return true;
+    }
+
+    bool canUpload(String requestUri) override  {
+        if (!_ufn || !canHandle(HTTP_POST, requestUri))
+            return false;
+
+        return true;
+    }
+
+    bool handle(WebServer& server, HTTPMethod requestMethod, String requestUri) override {
+        (void) server;
+        if (!canHandle(requestMethod, requestUri))
+            return false;
+
+        _fn();
+        return true;
+    }
+
+    void upload(WebServer& server, String requestUri, HTTPUpload& upload) override {
+        (void) server;
+        (void) upload;
+        if (canUpload(requestUri))
+            _ufn();
+    }
+
+protected:
+    WebServer::THandlerFunction _fn;
+    WebServer::THandlerFunction _ufn;
+    String _uri;
+    HTTPMethod _method;
+};
+
+class StaticRequestHandler : public RequestHandler {
+public:
+    StaticRequestHandler(FS& fs, const char* path, const char* uri, const char* cache_header)
+    : _fs(fs)
+    , _uri(uri)
+    , _path(path)
+    , _cache_header(cache_header)
+    {
+        _isFile = fs.exists(path);
+        log_v("StaticRequestHandler: path=%s uri=%s isFile=%d, cache_header=%s\r\n", path, uri, _isFile, cache_header);
+        _baseUriLength = _uri.length();
+    }
+
+    bool canHandle(HTTPMethod requestMethod, String requestUri) override  {
+        if (requestMethod != HTTP_GET)
+            return false;
+
+        if ((_isFile && requestUri != _uri) || !requestUri.startsWith(_uri))
+            return false;
+
+        return true;
+    }
+
+    bool handle(WebServer& server, HTTPMethod requestMethod, String requestUri) override {
+        if (!canHandle(requestMethod, requestUri))
+            return false;
+
+        log_v("StaticRequestHandler::handle: request=%s _uri=%s\r\n", requestUri.c_str(), _uri.c_str());
+
+        String path(_path);
+
+        if (!_isFile) {
+            // Base URI doesn't point to a file.
+            // If a directory is requested, look for index file.
+            if (requestUri.endsWith("/")) 
+              requestUri += "index.htm";
+
+            // Append whatever follows this URI in request to get the file path.
+            path += requestUri.substring(_baseUriLength);
+        }
+        log_v("StaticRequestHandler::handle: path=%s, isFile=%d\r\n", path.c_str(), _isFile);
+
+        String contentType = getContentType(path);
+
+        // look for gz file, only if the original specified path is not a gz.  So part only works to send gzip via content encoding when a non compressed is asked for
+        // if you point the the path to gzip you will serve the gzip as content type "application/x-gzip", not text or javascript etc...
+        if (!path.endsWith(FPSTR(mimeTable[gz].endsWith)) && !_fs.exists(path))  {
+            String pathWithGz = path + FPSTR(mimeTable[gz].endsWith);
+            if(_fs.exists(pathWithGz))
+                path += FPSTR(mimeTable[gz].endsWith);
+        }
+
+        File f = _fs.open(path, "r");
+        if (!f)
+            return false;
+
+        if (_cache_header.length() != 0)
+            server.sendHeader("Cache-Control", _cache_header);
+
+        server.streamFile(f, contentType);
+        return true;
+    }
+
+    static String getContentType(const String& path) {
+        char buff[sizeof(mimeTable[0].mimeType)];
+        // Check all entries but last one for match, return if found
+        for (size_t i=0; i < sizeof(mimeTable)/sizeof(mimeTable[0])-1; i++) {
+            strcpy_P(buff, mimeTable[i].endsWith);
+            if (path.endsWith(buff)) {
+                strcpy_P(buff, mimeTable[i].mimeType);
+                return String(buff);
+            }
+        }
+        // Fall-through and just return default type
+        strcpy_P(buff, mimeTable[sizeof(mimeTable)/sizeof(mimeTable[0])-1].mimeType);
+        return String(buff);
+    }
+
+protected:
+    FS _fs;
+    String _uri;
+    String _path;
+    String _cache_header;
+    bool _isFile;
+    size_t _baseUriLength;
+};
+
+
+#endif //REQUESTHANDLERSIMPL_H

libraries/WebServer/src/detail/mimetable.cpp

@@ -0,0 +1,35 @@
+#include "mimetable.h"
+#include "pgmspace.h"
+
+namespace mime
+{
+
+// Table of extension->MIME strings stored in PROGMEM, needs to be global due to GCC section typing rules
+const Entry mimeTable[maxType] = 
+{
+    { ".html", "text/html" },
+    { ".htm", "text/html" },
+    { ".css", "text/css" },
+    { ".txt", "text/plain" },
+    { ".js", "application/javascript" },
+    { ".json", "application/json" },
+    { ".png", "image/png" },
+    { ".gif", "image/gif" },
+    { ".jpg", "image/jpeg" },
+    { ".ico", "image/x-icon" },
+    { ".svg", "image/svg+xml" },
+    { ".ttf", "application/x-font-ttf" },
+    { ".otf", "application/x-font-opentype" },
+    { ".woff", "application/font-woff" },
+    { ".woff2", "application/font-woff2" },
+    { ".eot", "application/vnd.ms-fontobject" },
+    { ".sfnt", "application/font-sfnt" },
+    { ".xml", "text/xml" },
+    { ".pdf", "application/pdf" },
+    { ".zip", "application/zip" },
+    { ".gz", "application/x-gzip" },
+    { ".appcache", "text/cache-manifest" },
+    { "", "application/octet-stream" } 
+};
+
+}

libraries/WebServer/src/detail/mimetable.h

@@ -0,0 +1,47 @@
+#ifndef __MIMETABLE_H__
+#define __MIMETABLE_H__
+
+
+namespace mime
+{
+
+enum type
+{
+  html,
+  htm,
+  css,
+  txt,
+  js,
+  json,
+  png,
+  gif,
+  jpg,
+  ico,
+  svg,
+  ttf,
+  otf,
+  woff,
+  woff2,
+  eot,
+  sfnt,
+  xml,
+  pdf,
+  zip,
+  gz,
+  appcache,
+  none,
+  maxType
+};
+
+struct Entry
+{
+  const char endsWith[16]; 
+  const char mimeType[32];
+};
+
+
+extern const Entry mimeTable[maxType];
+}
+
+
+#endif

libraries/WiFi/examples/WPS/WPS.ino

@@ -16,16 +16,28 @@ Pranav Cherukupalli <cherukupallip@gmail.com>
 
 #include "WiFi.h"
 #include "esp_wps.h"
-
 /*
 Change the definition of the WPS mode
 from WPS_TYPE_PBC to WPS_TYPE_PIN in
 the case that you are using pin type
 WPS
 */
-#define ESP_WPS_MODE WPS_TYPE_PBC
+#define ESP_WPS_MODE      WPS_TYPE_PBC
+#define ESP_MANUFACTURER  "ESPRESSIF"
+#define ESP_MODEL_NUMBER  "ESP32"
+#define ESP_MODEL_NAME    "ESPRESSIF IOT"
+#define ESP_DEVICE_NAME   "ESP STATION"
 
-esp_wps_config_t config = WPS_CONFIG_INIT_DEFAULT(ESP_WPS_MODE);
+static esp_wps_config_t config;
+
+void wpsInitConfig(){
+  config.crypto_funcs = &g_wifi_default_wps_crypto_funcs;
+  config.wps_type = ESP_WPS_MODE;
+  strcpy(config.factory_info.manufacturer, ESP_MANUFACTURER);
+  strcpy(config.factory_info.model_number, ESP_MODEL_NUMBER);
+  strcpy(config.factory_info.model_name, ESP_MODEL_NAME);
+  strcpy(config.factory_info.device_name, ESP_DEVICE_NAME);
+}
 
 String wpspin2string(uint8_t a[]){
   char wps_pin[9];
@@ -39,40 +51,40 @@ String wpspin2string(uint8_t a[]){
 void WiFiEvent(WiFiEvent_t event, system_event_info_t info){
   switch(event){
     case SYSTEM_EVENT_STA_START:
-    Serial.println("Station Mode Started");
-    break;
+      Serial.println("Station Mode Started");
+      break;
     case SYSTEM_EVENT_STA_GOT_IP:
-    Serial.println("Connected to :" + String(WiFi.SSID()));
-    Serial.print("Got IP: ");
-    Serial.println(WiFi.localIP());
-    break;
+      Serial.println("Connected to :" + String(WiFi.SSID()));
+      Serial.print("Got IP: ");
+      Serial.println(WiFi.localIP());
+      break;
     case SYSTEM_EVENT_STA_DISCONNECTED:
-    Serial.println("Disconnected from station, attempting reconnection");
-    WiFi.reconnect();
-    break;
+      Serial.println("Disconnected from station, attempting reconnection");
+      WiFi.reconnect();
+      break;
     case SYSTEM_EVENT_STA_WPS_ER_SUCCESS:
-    Serial.println("WPS Successfull, stopping WPS and connecting to: " + String(WiFi.SSID()));
-    esp_wifi_wps_disable();
-    delay(10);
-    WiFi.begin();
-    break;
+      Serial.println("WPS Successfull, stopping WPS and connecting to: " + String(WiFi.SSID()));
+      esp_wifi_wps_disable();
+      delay(10);
+      WiFi.begin();
+      break;
     case SYSTEM_EVENT_STA_WPS_ER_FAILED:
-    Serial.println("WPS Failed, retrying");
-    esp_wifi_wps_disable();
-    esp_wifi_wps_enable(&config);
-    esp_wifi_wps_start(0);
-    break;
+      Serial.println("WPS Failed, retrying");
+      esp_wifi_wps_disable();
+      esp_wifi_wps_enable(&config);
+      esp_wifi_wps_start(0);
+      break;
     case SYSTEM_EVENT_STA_WPS_ER_TIMEOUT:
-    Serial.println("WPS Timedout, retrying");
-    esp_wifi_wps_disable();
-    esp_wifi_wps_enable(&config);
-    esp_wifi_wps_start(0);
-    break;
+      Serial.println("WPS Timedout, retrying");
+      esp_wifi_wps_disable();
+      esp_wifi_wps_enable(&config);
+      esp_wifi_wps_start(0);
+      break;
     case SYSTEM_EVENT_STA_WPS_ER_PIN:
-    Serial.println("WPS_PIN = " + wpspin2string(info.sta_er_pin.pin_code));
-    break;
+      Serial.println("WPS_PIN = " + wpspin2string(info.sta_er_pin.pin_code));
+      break;
     default:
-    break;
+      break;
   }
 }
 
@@ -87,10 +99,11 @@ void setup(){
 
   Serial.println("Starting WPS");
 
+  wpsInitConfig();
   esp_wifi_wps_enable(&config);
   esp_wifi_wps_start(0);
 }
 
 void loop(){
   //nothing to do here
-}
+}

libraries/WiFi/src/WiFi.cpp

@@ -56,9 +56,6 @@ void WiFiClass::printDiag(Print& p)
     wifi_second_chan_t secondChan;
     esp_wifi_get_channel(&primaryChan, &secondChan);
 
-    bool autoConnect;
-    esp_wifi_get_auto_connect(&autoConnect);
-
     p.print("Mode: ");
     p.println(modes[mode]);
 
@@ -71,8 +68,6 @@ void WiFiClass::printDiag(Print& p)
         p.print("Status: ");
         p.println(wifi_station_get_connect_status());
     */
-    p.print("Auto connect: ");
-    p.println(autoConnect);
 
     wifi_config_t conf;
     esp_wifi_get_config(WIFI_IF_STA, &conf);

libraries/WiFi/src/WiFiClient.cpp

@@ -18,6 +18,7 @@
 */
 
 #include "WiFiClient.h"
+#include "WiFi.h"
 #include <lwip/sockets.h>
 #include <lwip/netdb.h>
 #include <errno.h>
@@ -105,12 +106,10 @@ int WiFiClient::connect(IPAddress ip, uint16_t port)
 
 int WiFiClient::connect(const char *host, uint16_t port)
 {
-    struct hostent *server;
-    server = gethostbyname(host);
-    if (server == NULL) {
+    IPAddress srv((uint32_t)0);
+    if(!WiFiGenericClass::hostByName(host, srv)){
         return 0;
     }
-    IPAddress srv((const uint8_t *)(server->h_addr));
     return connect(srv, port);
 }
 
@@ -241,6 +240,24 @@ size_t WiFiClient::write_P(PGM_P buf, size_t size)
     return write(buf, size);
 }
 
+size_t WiFiClient::write(Stream &stream)
+{
+    uint8_t * buf = (uint8_t *)malloc(1360);
+    if(!buf){
+        return 0;
+    }
+    size_t toRead = 0, toWrite = 0, written = 0;
+    size_t available = stream.available();
+    while(available){
+        toRead = (available > 1360)?1360:available;
+        toWrite = stream.readBytes(buf, toRead);
+        written += write(buf, toWrite);
+        available = stream.available();
+    }
+    free(buf);
+    return written;
+}
+
 int WiFiClient::read(uint8_t *buf, size_t size)
 {
     if(!available()) {

libraries/WiFi/src/WiFiClient.h

@@ -45,6 +45,7 @@ public:
     size_t write(uint8_t data);
     size_t write(const uint8_t *buf, size_t size);
     size_t write_P(PGM_P buf, size_t size);
+    size_t write(Stream &stream);
     int available();
     int read();
     int read(uint8_t *buf, size_t size);

libraries/WiFi/src/WiFiGeneric.cpp

@@ -61,6 +61,7 @@ extern "C" {
 
 static xQueueHandle _network_event_queue;
 static TaskHandle_t _network_event_task_handle = NULL;
+static EventGroupHandle_t _network_event_group = NULL;
 
 static void _network_event_task(void * arg){
     system_event_t *event = NULL;
@@ -81,35 +82,42 @@ static esp_err_t _network_event_cb(void *arg, system_event_t *event){
     return ESP_OK;
 }
 
-static void _start_network_event_task(){
+static bool _start_network_event_task(){
+    if(!_network_event_group){
+        _network_event_group = xEventGroupCreate();
+        if(!_network_event_group){
+            log_e("Network Event Group Create Failed!");
+            return false;
+        }
+        xEventGroupSetBits(_network_event_group, WIFI_DNS_IDLE_BIT);
+    }
     if(!_network_event_queue){
         _network_event_queue = xQueueCreate(32, sizeof(system_event_t *));
         if(!_network_event_queue){
             log_e("Network Event Queue Create Failed!");
-            return;
+            return false;
         }
     }
     if(!_network_event_task_handle){
         xTaskCreatePinnedToCore(_network_event_task, "network_event", 4096, NULL, 2, &_network_event_task_handle, ARDUINO_RUNNING_CORE);
         if(!_network_event_task_handle){
             log_e("Network Event Task Start Failed!");
-            return;
+            return false;
         }
     }
-    esp_event_loop_init(&_network_event_cb, NULL);
+    return esp_event_loop_init(&_network_event_cb, NULL) == ESP_OK;
 }
 
 void tcpipInit(){
     static bool initialized = false;
-    if(!initialized){
+    if(!initialized && _start_network_event_task()){
         initialized = true;
-        _start_network_event_task();
         tcpip_adapter_init();
     }
 }
 
+static bool lowLevelInitDone = false;
 static bool wifiLowLevelInit(bool persistent){
-    static bool lowLevelInitDone = false;
     if(!lowLevelInitDone){
         tcpipInit();
         wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
@@ -121,7 +129,6 @@ static bool wifiLowLevelInit(bool persistent){
         if(!persistent){
           esp_wifi_set_storage(WIFI_STORAGE_RAM);
         }
-        esp_wifi_set_mode(WIFI_MODE_NULL);
         lowLevelInitDone = true;
     }
     return true;
@@ -161,12 +168,13 @@ static bool espWiFiStop(){
     if(!_esp_wifi_started){
         return true;
     }
+    _esp_wifi_started = false;
     err = esp_wifi_stop();
     if(err){
         log_e("Could not stop WiFi! %u", err);
+        _esp_wifi_started = true;
         return false;
     }
-    _esp_wifi_started = false;
     return wifiLowLevelDeinit();
 }
 
@@ -198,6 +206,39 @@ WiFiGenericClass::WiFiGenericClass()
 
 }
 
+int WiFiGenericClass::setStatusBits(int bits){
+    if(!_network_event_group){
+        return 0;
+    }
+    return xEventGroupSetBits(_network_event_group, bits);
+}
+
+int WiFiGenericClass::clearStatusBits(int bits){
+    if(!_network_event_group){
+        return 0;
+    }
+    return xEventGroupClearBits(_network_event_group, bits);
+}
+
+int WiFiGenericClass::getStatusBits(){
+    if(!_network_event_group){
+        return 0;
+    }
+    return xEventGroupGetBits(_network_event_group);
+}
+
+int WiFiGenericClass::waitStatusBits(int bits, uint32_t timeout_ms){
+    if(!_network_event_group){
+        return 0;
+    }
+    return xEventGroupWaitBits(
+        _network_event_group,    // The event group being tested.
+        bits,  // The bits within the event group to wait for.
+        pdFALSE,         // BIT_0 and BIT_4 should be cleared before returning.
+        pdTRUE,        // Don't wait for both bits, either bit will do.
+        timeout_ms / portTICK_PERIOD_MS ) & bits; // Wait a maximum of 100ms for either bit to be set.
+}
+
 /**
  * set callback function
  * @param cbEvent WiFiEventCb
@@ -304,6 +345,16 @@ esp_err_t WiFiGenericClass::_eventCallback(void *arg, system_event_t *event)
     log_d("Event: %d - %s", event->event_id, system_event_names[event->event_id]);
     if(event->event_id == SYSTEM_EVENT_SCAN_DONE) {
         WiFiScanClass::_scanDone();
+
+    } else if(event->event_id == SYSTEM_EVENT_STA_START) {
+        WiFiSTAClass::_setStatus(WL_DISCONNECTED);
+        setStatusBits(STA_STARTED_BIT);
+    } else if(event->event_id == SYSTEM_EVENT_STA_STOP) {
+        WiFiSTAClass::_setStatus(WL_NO_SHIELD);
+        clearStatusBits(STA_STARTED_BIT | STA_CONNECTED_BIT | STA_HAS_IP_BIT | STA_HAS_IP6_BIT);
+    } else if(event->event_id == SYSTEM_EVENT_STA_CONNECTED) {
+        WiFiSTAClass::_setStatus(WL_IDLE_STATUS);
+        setStatusBits(STA_CONNECTED_BIT);
     } else if(event->event_id == SYSTEM_EVENT_STA_DISCONNECTED) {
         uint8_t reason = event->event_info.disconnected.reason;
         log_w("Reason: %u - %s", reason, reason2str(reason));
@@ -320,17 +371,47 @@ esp_err_t WiFiGenericClass::_eventCallback(void *arg, system_event_t *event)
         } else {
             WiFiSTAClass::_setStatus(WL_DISCONNECTED);
         }
-    } else if(event->event_id == SYSTEM_EVENT_STA_START) {
-        WiFiSTAClass::_setStatus(WL_DISCONNECTED);
-    } else if(event->event_id == SYSTEM_EVENT_STA_STOP) {
-        WiFiSTAClass::_setStatus(WL_NO_SHIELD);
-    } else if(event->event_id == SYSTEM_EVENT_STA_CONNECTED) {
-        WiFiSTAClass::_setStatus(WL_IDLE_STATUS);
+        clearStatusBits(STA_CONNECTED_BIT | STA_HAS_IP_BIT | STA_HAS_IP6_BIT);
+        if(reason >= WIFI_REASON_BEACON_TIMEOUT && reason != WIFI_REASON_AUTH_FAIL && WiFi.getAutoReconnect()){
+            WiFi.begin();
+        }
     } else if(event->event_id == SYSTEM_EVENT_STA_GOT_IP) {
-//#1081 https://github.com/espressif/arduino-esp32/issues/1081		
-//        if(WiFiSTAClass::status() == WL_IDLE_STATUS) 
-		{        
-            WiFiSTAClass::_setStatus(WL_CONNECTED);
+        WiFiSTAClass::_setStatus(WL_CONNECTED);
+        setStatusBits(STA_HAS_IP_BIT | STA_CONNECTED_BIT);
+    } else if(event->event_id == SYSTEM_EVENT_STA_LOST_IP) {
+        WiFiSTAClass::_setStatus(WL_IDLE_STATUS);
+        clearStatusBits(STA_HAS_IP_BIT);
+
+    } else if(event->event_id == SYSTEM_EVENT_AP_START) {
+        setStatusBits(AP_STARTED_BIT);
+    } else if(event->event_id == SYSTEM_EVENT_AP_STOP) {
+        clearStatusBits(AP_STARTED_BIT | AP_HAS_CLIENT_BIT);
+    } else if(event->event_id == SYSTEM_EVENT_AP_STACONNECTED) {
+        setStatusBits(AP_HAS_CLIENT_BIT);
+    } else if(event->event_id == SYSTEM_EVENT_AP_STADISCONNECTED) {
+        wifi_sta_list_t clients;
+        if(esp_wifi_ap_get_sta_list(&clients) != ESP_OK || !clients.num){
+            clearStatusBits(AP_HAS_CLIENT_BIT);
+        }
+
+    } else if(event->event_id == SYSTEM_EVENT_ETH_START) {
+        setStatusBits(ETH_STARTED_BIT);
+    } else if(event->event_id == SYSTEM_EVENT_ETH_STOP) {
+        clearStatusBits(ETH_STARTED_BIT | ETH_CONNECTED_BIT | ETH_HAS_IP_BIT | ETH_HAS_IP6_BIT);
+    } else if(event->event_id == SYSTEM_EVENT_ETH_CONNECTED) {
+        setStatusBits(ETH_CONNECTED_BIT);
+    } else if(event->event_id == SYSTEM_EVENT_ETH_DISCONNECTED) {
+        clearStatusBits(ETH_CONNECTED_BIT | ETH_HAS_IP_BIT | ETH_HAS_IP6_BIT);
+    } else if(event->event_id == SYSTEM_EVENT_ETH_GOT_IP) {
+        setStatusBits(ETH_CONNECTED_BIT | ETH_HAS_IP_BIT);
+
+    } else if(event->event_id == SYSTEM_EVENT_GOT_IP6) {
+        if(event->event_info.got_ip6.if_index == TCPIP_ADAPTER_IF_AP){
+            setStatusBits(AP_HAS_IP6_BIT);
+        } else if(event->event_info.got_ip6.if_index == TCPIP_ADAPTER_IF_STA){
+            setStatusBits(STA_CONNECTED_BIT | STA_HAS_IP6_BIT);
+        } else if(event->event_info.got_ip6.if_index == TCPIP_ADAPTER_IF_ETH){
+            setStatusBits(ETH_CONNECTED_BIT | ETH_HAS_IP6_BIT);
         }
     }
 
@@ -357,8 +438,11 @@ esp_err_t WiFiGenericClass::_eventCallback(void *arg, system_event_t *event)
  */
 int32_t WiFiGenericClass::channel(void)
 {
-    uint8_t primaryChan;
-    wifi_second_chan_t secondChan;
+    uint8_t primaryChan = 0;
+    wifi_second_chan_t secondChan = WIFI_SECOND_CHAN_NONE;
+    if(!lowLevelInitDone){
+        return primaryChan;
+    }
     esp_wifi_get_channel(&primaryChan, &secondChan);
     return primaryChan;
 }
@@ -380,19 +464,15 @@ void WiFiGenericClass::persistent(bool persistent)
  */
 bool WiFiGenericClass::mode(wifi_mode_t m)
 {
-    if (!_esp_wifi_started) {
-         wifiLowLevelInit(_persistent); 
-    }
     wifi_mode_t cm = getMode();
-    if(cm == WIFI_MODE_MAX){
-        return false;
-    }
     if(cm == m) {
         return true;
     }
-    if(m){
-        espWiFiStart(_persistent);
-    } else {
+    if(!cm && m){
+        if(!espWiFiStart(_persistent)){
+            return false;
+        }
+    } else if(cm && !m){
         return espWiFiStop();
     }
     
@@ -402,10 +482,7 @@ bool WiFiGenericClass::mode(wifi_mode_t m)
         log_e("Could not set mode! %u", err);
         return false;
     }
-    if(m){
-        return espWiFiStart(_persistent);
-    }
-    return espWiFiStop();
+    return true;
 }
 
 /**
@@ -414,13 +491,15 @@ bool WiFiGenericClass::mode(wifi_mode_t m)
  */
 wifi_mode_t WiFiGenericClass::getMode()
 {
-    if(!wifiLowLevelInit(_persistent)){
-        return WIFI_MODE_MAX;
-
+    if(!_esp_wifi_started){
+        return WIFI_MODE_NULL;
     }
-    uint8_t mode;
-    esp_wifi_get_mode((wifi_mode_t*)&mode);
-    return (wifi_mode_t)mode;
+    wifi_mode_t mode;
+    if(esp_wifi_get_mode(&mode) == ESP_ERR_WIFI_NOT_INIT){
+        log_w("WiFi not started");
+        return WIFI_MODE_NULL;
+    }
+    return mode;
 }
 
 /**
@@ -437,12 +516,10 @@ bool WiFiGenericClass::enableSTA(bool enable)
     if(isEnabled != enable) {
         if(enable) {
             return mode((wifi_mode_t)(currentMode | WIFI_MODE_STA));
-        } else {
-            return mode((wifi_mode_t)(currentMode & (~WIFI_MODE_STA)));
         }
-    } else {
-        return true;
+        return mode((wifi_mode_t)(currentMode & (~WIFI_MODE_STA)));
     }
+    return true;
 }
 
 /**
@@ -459,21 +536,72 @@ bool WiFiGenericClass::enableAP(bool enable)
     if(isEnabled != enable) {
         if(enable) {
             return mode((wifi_mode_t)(currentMode | WIFI_MODE_AP));
-        } else {
-            return mode((wifi_mode_t)(currentMode & (~WIFI_MODE_AP)));
         }
-    } else {
-        return true;
+        return mode((wifi_mode_t)(currentMode & (~WIFI_MODE_AP)));
     }
+    return true;
 }
 
+/**
+ * control modem sleep when only in STA mode
+ * @param enable bool
+ * @return ok
+ */
+bool WiFiGenericClass::setSleep(bool enable)
+{
+    if((getMode() & WIFI_MODE_STA) == 0){
+        log_w("STA has not been started");
+        return false;
+    }
+    return esp_wifi_set_ps(enable?WIFI_PS_MIN_MODEM:WIFI_PS_NONE) == ESP_OK;
+}
+
+/**
+ * get modem sleep enabled
+ * @return true if modem sleep is enabled
+ */
+bool WiFiGenericClass::getSleep()
+{
+    wifi_ps_type_t ps;
+    if((getMode() & WIFI_MODE_STA) == 0){
+        log_w("STA has not been started");
+        return false;
+    }
+    if(esp_wifi_get_ps(&ps) == ESP_OK){
+        return ps == WIFI_PS_MIN_MODEM;
+    }
+    return false;
+}
+
+/**
+ * control wifi tx power
+ * @param power enum maximum wifi tx power
+ * @return ok
+ */
+bool WiFiGenericClass::setTxPower(wifi_power_t power){
+    if((getStatusBits() & (STA_STARTED_BIT | AP_STARTED_BIT)) == 0){
+        log_w("Neither AP or STA has been started");
+        return false;
+    }
+    return esp_wifi_set_max_tx_power(power) == ESP_OK;
+}
+
+wifi_power_t WiFiGenericClass::getTxPower(){
+    int8_t power;
+    if((getStatusBits() & (STA_STARTED_BIT | AP_STARTED_BIT)) == 0){
+        log_w("Neither AP or STA has been started");
+        return WIFI_POWER_19_5dBm;
+    }
+    if(esp_wifi_get_max_tx_power(&power)){
+        return WIFI_POWER_19_5dBm;
+    }
+    return (wifi_power_t)power;
+}
 
 // -----------------------------------------------------------------------------------------------------------------------
 // ------------------------------------------------ Generic Network function ---------------------------------------------
 // -----------------------------------------------------------------------------------------------------------------------
 
-static bool _dns_busy = false;
-
 /**
  * DNS callback
  * @param name
@@ -485,7 +613,7 @@ static void wifi_dns_found_callback(const char *name, const ip_addr_t *ipaddr, v
     if(ipaddr) {
         (*reinterpret_cast<IPAddress*>(callback_arg)) = ipaddr->u_addr.ip4.addr;
     }
-    _dns_busy = false;
+    xEventGroupSetBits(_network_event_group, WIFI_DNS_DONE_BIT);
 }
 
 /**
@@ -499,20 +627,19 @@ int WiFiGenericClass::hostByName(const char* aHostname, IPAddress& aResult)
 {
     ip_addr_t addr;
     aResult = static_cast<uint32_t>(0);
-
-    _dns_busy = true;
+    waitStatusBits(WIFI_DNS_IDLE_BIT, 5000);
+    clearStatusBits(WIFI_DNS_IDLE_BIT);
     err_t err = dns_gethostbyname(aHostname, &addr, &wifi_dns_found_callback, &aResult);
     if(err == ERR_OK && addr.u_addr.ip4.addr) {
         aResult = addr.u_addr.ip4.addr;
-        _dns_busy = false;
     } else if(err == ERR_INPROGRESS) {
-        while(_dns_busy){
-            delay(1);
-        }
-    } else {
-        _dns_busy = false;
-        return 0;
+        waitStatusBits(WIFI_DNS_DONE_BIT, 4000);
+        clearStatusBits(WIFI_DNS_DONE_BIT);
     }
-    return 1;
+    setStatusBits(WIFI_DNS_IDLE_BIT);
+    if((uint32_t)aResult == 0){
+        log_e("DNS Failed for %s", aHostname);
+    }
+    return (uint32_t)aResult != 0;
 }
 

libraries/WiFi/src/WiFiGeneric.h

@@ -34,6 +34,37 @@ typedef void (*WiFiEventSysCb)(system_event_t *event);
 
 typedef size_t wifi_event_id_t;
 
+typedef enum {
+    WIFI_POWER_19_5dBm = 78,// 19.5dBm
+    WIFI_POWER_19dBm = 76,// 19dBm
+    WIFI_POWER_18_5dBm = 74,// 18.5dBm
+    WIFI_POWER_17dBm = 68,// 17dBm
+    WIFI_POWER_15dBm = 60,// 15dBm
+    WIFI_POWER_13dBm = 52,// 13dBm
+    WIFI_POWER_11dBm = 44,// 11dBm
+    WIFI_POWER_8_5dBm = 34,// 8.5dBm
+    WIFI_POWER_7dBm = 28,// 7dBm
+    WIFI_POWER_5dBm = 20,// 5dBm
+    WIFI_POWER_2dBm = 8,// 2dBm
+    WIFI_POWER_MINUS_1dBm = -4// -1dBm
+} wifi_power_t;
+
+static const int AP_STARTED_BIT    = BIT0;
+static const int AP_HAS_IP6_BIT    = BIT1;
+static const int AP_HAS_CLIENT_BIT = BIT2;
+static const int STA_STARTED_BIT   = BIT3;
+static const int STA_CONNECTED_BIT = BIT4;
+static const int STA_HAS_IP_BIT    = BIT5;
+static const int STA_HAS_IP6_BIT   = BIT6;
+static const int ETH_STARTED_BIT   = BIT7;
+static const int ETH_CONNECTED_BIT = BIT8;
+static const int ETH_HAS_IP_BIT    = BIT9;
+static const int ETH_HAS_IP6_BIT   = BIT10;
+static const int WIFI_SCANNING_BIT = BIT11;
+static const int WIFI_SCAN_DONE_BIT= BIT12;
+static const int WIFI_DNS_IDLE_BIT = BIT13;
+static const int WIFI_DNS_DONE_BIT = BIT14;
+
 class WiFiGenericClass
 {
   public:
@@ -46,6 +77,9 @@ class WiFiGenericClass
     void removeEvent(WiFiEventSysCb cbEvent, system_event_id_t event = SYSTEM_EVENT_MAX);
     void removeEvent(wifi_event_id_t id);
 
+    static int getStatusBits();
+    static int waitStatusBits(int bits, uint32_t timeout_ms);
+
     int32_t channel(void);
 
     void persistent(bool persistent);
@@ -56,14 +90,23 @@ class WiFiGenericClass
     bool enableSTA(bool enable);
     bool enableAP(bool enable);
 
+    bool setSleep(bool enable);
+    bool getSleep();
+
+    bool setTxPower(wifi_power_t power);
+    wifi_power_t getTxPower();
+
     static esp_err_t _eventCallback(void *arg, system_event_t *event);
 
   protected:
     static bool _persistent;
     static wifi_mode_t _forceSleepLastMode;
 
+    static int setStatusBits(int bits);
+    static int clearStatusBits(int bits);
+
   public:
-    int hostByName(const char *aHostname, IPAddress &aResult);
+    static int hostByName(const char *aHostname, IPAddress &aResult);
 
   protected:
     friend class WiFiSTAClass;

libraries/WiFi/src/WiFiSTA.cpp

@@ -59,24 +59,9 @@ static bool sta_config_equal(const wifi_config_t& lhs, const wifi_config_t& rhs)
  */
 static bool sta_config_equal(const wifi_config_t& lhs, const wifi_config_t& rhs)
 {
-    if(strcmp(reinterpret_cast<const char*>(lhs.sta.ssid), reinterpret_cast<const char*>(rhs.sta.ssid)) != 0) {
+    if(memcmp(&lhs, &rhs, sizeof(wifi_config_t)) != 0) {
         return false;
     }
-
-    if(strcmp(reinterpret_cast<const char*>(lhs.sta.password), reinterpret_cast<const char*>(rhs.sta.password)) != 0) {
-        return false;
-    }
-
-    if(lhs.sta.bssid_set != rhs.sta.bssid_set) {
-        return false;
-    }
-
-    if(lhs.sta.bssid_set) {
-        if(memcmp(lhs.sta.bssid, rhs.sta.bssid, 6) != 0) {
-            return false;
-        }
-    }
-
     return true;
 }
 
@@ -86,7 +71,37 @@ static bool sta_config_equal(const wifi_config_t& lhs, const wifi_config_t& rhs)
 
 bool WiFiSTAClass::_autoReconnect = true;
 bool WiFiSTAClass::_useStaticIp = false;
-wl_status_t WiFiSTAClass::_status = WL_NO_SHIELD;
+
+static wl_status_t _sta_status = WL_NO_SHIELD;
+static EventGroupHandle_t _sta_status_group = NULL;
+
+void WiFiSTAClass::_setStatus(wl_status_t status)
+{
+    if(!_sta_status_group){
+        _sta_status_group = xEventGroupCreate();
+        if(!_sta_status_group){
+            log_e("STA Status Group Create Failed!");
+            _sta_status = status;
+            return;
+        }
+    }
+    xEventGroupClearBits(_sta_status_group, 0x00FFFFFF);
+    xEventGroupSetBits(_sta_status_group, status);
+}
+
+/**
+ * Return Connection status.
+ * @return one of the value defined in wl_status_t
+ *
+ */
+wl_status_t WiFiSTAClass::status()
+{
+    if(!_sta_status_group){
+        return _sta_status;
+    }
+    return (wl_status_t)xEventGroupClearBits(_sta_status_group, 0);
+}
+
 /**
  * Start Wifi connection
  * if passphrase is set the most secure supported mode will be automatically selected
@@ -101,60 +116,68 @@ wl_status_t WiFiSTAClass::begin(const char* ssid, const char *passphrase, int32_
 {
 
     if(!WiFi.enableSTA(true)) {
-        // enable STA failed
+        log_e("STA enable failed!");
         return WL_CONNECT_FAILED;
     }
 
     if(!ssid || *ssid == 0x00 || strlen(ssid) > 31) {
-        // fail SSID too long or missing!
+        log_e("SSID too long or missing!");
         return WL_CONNECT_FAILED;
     }
 
     if(passphrase && strlen(passphrase) > 64) {
-        // fail passphrase too long!
+        log_e("passphrase too long!");
         return WL_CONNECT_FAILED;
     }
 
     wifi_config_t conf;
+    memset(&conf, 0, sizeof(wifi_config_t));
     strcpy(reinterpret_cast<char*>(conf.sta.ssid), ssid);
 
     if(passphrase) {
-        if (strlen(passphrase) == 64) // it's not a passphrase, is the PSK
+        if (strlen(passphrase) == 64){ // it's not a passphrase, is the PSK
             memcpy(reinterpret_cast<char*>(conf.sta.password), passphrase, 64);
-        else
+        } else {
             strcpy(reinterpret_cast<char*>(conf.sta.password), passphrase);
-    } else {
-        *conf.sta.password = 0;
+        }
     }
 
     if(bssid) {
         conf.sta.bssid_set = 1;
         memcpy((void *) &conf.sta.bssid[0], (void *) bssid, 6);
-    } else {
-        conf.sta.bssid_set = 0;
+    }
+
+    if(channel > 0 && channel <= 13) {
+        conf.sta.channel = channel;
     }
 
     wifi_config_t current_conf;
     esp_wifi_get_config(WIFI_IF_STA, &current_conf);
     if(!sta_config_equal(current_conf, conf)) {
+        if(esp_wifi_disconnect()){
+            log_e("disconnect failed!");
+            return WL_CONNECT_FAILED;
+        }
+
         esp_wifi_set_config(WIFI_IF_STA, &conf);
-    }
-
-    if(channel > 0 && channel <= 13) {
-        esp_wifi_set_channel(channel, WIFI_SECOND_CHAN_NONE);
-    }
-
-    esp_wifi_start();
-    if(connect) {
-        esp_wifi_connect();
+    } else if(status() == WL_CONNECTED){
+        return WL_CONNECTED;
     }
 
     if(!_useStaticIp) {
-        tcpip_adapter_dhcpc_start(TCPIP_ADAPTER_IF_STA);
+        if(tcpip_adapter_dhcpc_start(TCPIP_ADAPTER_IF_STA) == ESP_ERR_TCPIP_ADAPTER_DHCPC_START_FAILED){
+            log_e("dhcp client start failed!");
+            return WL_CONNECT_FAILED;
+        }
     } else {
         tcpip_adapter_dhcpc_stop(TCPIP_ADAPTER_IF_STA);
     }
 
+    if(connect && esp_wifi_connect()) {
+        log_e("connect failed!");
+        return WL_CONNECT_FAILED;
+    }
+
     return status();
 }
 
@@ -171,25 +194,68 @@ wl_status_t WiFiSTAClass::begin()
 {
 
     if(!WiFi.enableSTA(true)) {
-        // enable STA failed
+        log_e("STA enable failed!");
         return WL_CONNECT_FAILED;
     }
-    esp_wifi_start();
-    esp_wifi_connect();
 
     if(!_useStaticIp) {
-        tcpip_adapter_dhcpc_start(TCPIP_ADAPTER_IF_STA);
+        if(tcpip_adapter_dhcpc_start(TCPIP_ADAPTER_IF_STA) == ESP_ERR_TCPIP_ADAPTER_DHCPC_START_FAILED){
+            log_e("dhcp client start failed!");
+            return WL_CONNECT_FAILED;
+        }
     } else {
         tcpip_adapter_dhcpc_stop(TCPIP_ADAPTER_IF_STA);
     }
 
+    if(status() != WL_CONNECTED && esp_wifi_connect()){
+        log_e("connect failed!");
+        return WL_CONNECT_FAILED;
+    }
+
     return status();
 }
 
-void WiFiSTAClass::_setStatus(wl_status_t status)
+/**
+ * will force a disconnect an then start reconnecting to AP
+ * @return ok
+ */
+bool WiFiSTAClass::reconnect()
 {
-    _status = status;
-    //log_i("wifi status: %d", status);
+    if(WiFi.getMode() & WIFI_MODE_STA) {
+        if(esp_wifi_disconnect() == ESP_OK) {
+            return esp_wifi_connect() == ESP_OK;
+        }
+    }
+    return false;
+}
+
+/**
+ * Disconnect from the network
+ * @param wifioff
+ * @return  one value of wl_status_t enum
+ */
+bool WiFiSTAClass::disconnect(bool wifioff, bool eraseap)
+{
+    wifi_config_t conf;
+
+    if(WiFi.getMode() & WIFI_MODE_STA){
+        if(eraseap){
+            memset(&conf, 0, sizeof(wifi_config_t));
+            if(esp_wifi_set_config(WIFI_IF_STA, &conf)){
+                log_e("clear config failed!");
+            }
+        }
+        if(esp_wifi_disconnect()){
+            log_e("disconnect failed!");
+            return false;
+        }
+        if(wifioff) {
+             return WiFi.enableSTA(false);
+        }
+        return true;
+    }
+
+    return false;
 }
 
 /**
@@ -207,7 +273,6 @@ bool WiFiSTAClass::config(IPAddress local_ip, IPAddress gateway, IPAddress subne
     if(!WiFi.enableSTA(true)) {
         return false;
     }
-    esp_wifi_start();
 
     tcpip_adapter_ip_info_t info;
 
@@ -237,8 +302,8 @@ bool WiFiSTAClass::config(IPAddress local_ip, IPAddress gateway, IPAddress subne
         _useStaticIp = true;
     } else {
         err = tcpip_adapter_dhcpc_start(TCPIP_ADAPTER_IF_STA);
-        if(err != ESP_OK && err != ESP_ERR_TCPIP_ADAPTER_DHCP_ALREADY_STARTED){
-            log_w("DHCP could not be started! Error: %d", err);
+        if(err == ESP_ERR_TCPIP_ADAPTER_DHCPC_START_FAILED){
+            log_e("dhcp client start failed!");
             return false;
         }
         _useStaticIp = false;
@@ -262,44 +327,6 @@ bool WiFiSTAClass::config(IPAddress local_ip, IPAddress gateway, IPAddress subne
     return true;
 }
 
-/**
- * will force a disconnect an then start reconnecting to AP
- * @return ok
- */
-bool WiFiSTAClass::reconnect()
-{
-    if((WiFi.getMode() & WIFI_MODE_STA) != 0) {
-        if(esp_wifi_disconnect() == ESP_OK) {
-            return esp_wifi_connect() == ESP_OK;
-        }
-    }
-    return false;
-}
-
-/**
- * Disconnect from the network
- * @param wifioff
- * @return  one value of wl_status_t enum
- */
-bool WiFiSTAClass::disconnect(bool wifioff)
-{
-    bool ret;
-    wifi_config_t conf;
-    *conf.sta.ssid = 0;
-    *conf.sta.password = 0;
-
-    WiFi.getMode();
-    esp_wifi_start();
-    esp_wifi_set_config(WIFI_IF_STA, &conf);
-    ret = esp_wifi_disconnect() == ESP_OK;
-
-    if(wifioff) {
-        WiFi.enableSTA(false);
-    }
-
-    return ret;
-}
-
 /**
  * is STA interface connected?
  * @return true if STA is connected to an AD
@@ -318,9 +345,10 @@ bool WiFiSTAClass::isConnected()
  */
 bool WiFiSTAClass::setAutoConnect(bool autoConnect)
 {
-    bool ret;
+    /*bool ret;
     ret = esp_wifi_set_auto_connect(autoConnect);
-    return ret;
+    return ret;*/
+    return false;//now deprecated
 }
 
 /**
@@ -330,9 +358,10 @@ bool WiFiSTAClass::setAutoConnect(bool autoConnect)
  */
 bool WiFiSTAClass::getAutoConnect()
 {
-    bool autoConnect;
+    /*bool autoConnect;
     esp_wifi_get_auto_connect(&autoConnect);
-    return autoConnect;
+    return autoConnect;*/
+    return false;//now deprecated
 }
 
 bool WiFiSTAClass::setAutoReconnect(bool autoReconnect)
@@ -434,16 +463,6 @@ IPAddress WiFiSTAClass::dnsIP(uint8_t dns_no)
     return IPAddress(dns_ip.u_addr.ip4.addr);
 }
 
-/**
- * Return Connection status.
- * @return one of the value defined in wl_status_t
- *
- */
-wl_status_t WiFiSTAClass::status()
-{
-    return WiFiSTAClass::_status;
-}
-
 /**
  * Return the current SSID associated with the network
  * @return SSID

libraries/WiFi/src/WiFiSTA.h

@@ -43,7 +43,7 @@ public:
     bool config(IPAddress local_ip, IPAddress gateway, IPAddress subnet, IPAddress dns1 = (uint32_t)0x00000000, IPAddress dns2 = (uint32_t)0x00000000);
 
     bool reconnect();
-    bool disconnect(bool wifioff = false);
+    bool disconnect(bool wifioff = false, bool eraseap = false);
 
     bool isConnected();
 
@@ -83,7 +83,6 @@ public:
 
     static void _setStatus(wl_status_t status);
 protected:
-    static wl_status_t _status;
     static bool _useStaticIp;
     static bool _autoReconnect;
 

libraries/WiFi/src/WiFiScan.cpp

@@ -42,8 +42,6 @@ extern "C" {
 }
 
 bool WiFiScanClass::_scanAsync = false;
-bool WiFiScanClass::_scanStarted = false;
-bool WiFiScanClass::_scanComplete = false;
 
 uint16_t WiFiScanClass::_scanCount = 0;
 void* WiFiScanClass::_scanResult = 0;
@@ -56,7 +54,7 @@ void* WiFiScanClass::_scanResult = 0;
  */
 int16_t WiFiScanClass::scanNetworks(bool async, bool show_hidden, bool passive, uint32_t max_ms_per_chan)
 {
-    if(WiFiScanClass::_scanStarted) {
+    if(WiFiGenericClass::getStatusBits() & WIFI_SCANNING_BIT) {
         return WIFI_SCAN_RUNNING;
     }
 
@@ -80,20 +78,17 @@ int16_t WiFiScanClass::scanNetworks(bool async, bool show_hidden, bool passive,
         config.scan_time.active.max = max_ms_per_chan;
     }
     if(esp_wifi_scan_start(&config, false) == ESP_OK) {
-        WiFiScanClass::_scanComplete = false;
-        WiFiScanClass::_scanStarted = true;
+        WiFiGenericClass::clearStatusBits(WIFI_SCAN_DONE_BIT);
+        WiFiGenericClass::setStatusBits(WIFI_SCANNING_BIT);
 
         if(WiFiScanClass::_scanAsync) {
             return WIFI_SCAN_RUNNING;
         }
-        while(!(WiFiScanClass::_scanComplete)) {
-            delay(10);
+        if(WiFiGenericClass::waitStatusBits(WIFI_SCAN_DONE_BIT, 10000)){
+            return (int16_t) WiFiScanClass::_scanCount;
         }
-        return (int16_t) WiFiScanClass::_scanCount;
-    } else {
-        return WIFI_SCAN_FAILED;
     }
-
+    return WIFI_SCAN_FAILED;
 }
 
 
@@ -105,18 +100,15 @@ int16_t WiFiScanClass::scanNetworks(bool async, bool show_hidden, bool passive,
  */
 void WiFiScanClass::_scanDone()
 {
-    WiFiScanClass::_scanComplete = true;
-    WiFiScanClass::_scanStarted = false;
     esp_wifi_scan_get_ap_num(&(WiFiScanClass::_scanCount));
     if(WiFiScanClass::_scanCount) {
         WiFiScanClass::_scanResult = new wifi_ap_record_t[WiFiScanClass::_scanCount];
-        if(WiFiScanClass::_scanResult) {
-            esp_wifi_scan_get_ap_records(&(WiFiScanClass::_scanCount), (wifi_ap_record_t*)_scanResult);
-        } else {
-            //no memory
+        if(!WiFiScanClass::_scanResult || esp_wifi_scan_get_ap_records(&(WiFiScanClass::_scanCount), (wifi_ap_record_t*)_scanResult) != ESP_OK) {
             WiFiScanClass::_scanCount = 0;
         }
     }
+    WiFiGenericClass::setStatusBits(WIFI_SCAN_DONE_BIT);
+    WiFiGenericClass::clearStatusBits(WIFI_SCANNING_BIT);
 }
 
 /**
@@ -126,7 +118,7 @@ void WiFiScanClass::_scanDone()
  */
 void * WiFiScanClass::_getScanInfoByIndex(int i)
 {
-    if(!WiFiScanClass::_scanResult || (size_t) i > WiFiScanClass::_scanCount) {
+    if(!WiFiScanClass::_scanResult || (size_t) i >= WiFiScanClass::_scanCount) {
         return 0;
     }
     return reinterpret_cast<wifi_ap_record_t*>(WiFiScanClass::_scanResult) + i;
@@ -138,15 +130,14 @@ void * WiFiScanClass::_getScanInfoByIndex(int i)
  *          -1 if scan not fin
  *          -2 if scan not triggered
  */
-int8_t WiFiScanClass::scanComplete()
+int16_t WiFiScanClass::scanComplete()
 {
-
-    if(_scanStarted) {
-        return WIFI_SCAN_RUNNING;
+    if(WiFiGenericClass::getStatusBits() & WIFI_SCAN_DONE_BIT) {
+        return WiFiScanClass::_scanCount;
     }
 
-    if(_scanComplete) {
-        return WiFiScanClass::_scanCount;
+    if(WiFiGenericClass::getStatusBits() & WIFI_SCANNING_BIT) {
+        return WIFI_SCAN_RUNNING;
     }
 
     return WIFI_SCAN_FAILED;
@@ -157,12 +148,12 @@ int8_t WiFiScanClass::scanComplete()
  */
 void WiFiScanClass::scanDelete()
 {
+    WiFiGenericClass::clearStatusBits(WIFI_SCAN_DONE_BIT);
     if(WiFiScanClass::_scanResult) {
         delete[] reinterpret_cast<wifi_ap_record_t*>(WiFiScanClass::_scanResult);
         WiFiScanClass::_scanResult = 0;
         WiFiScanClass::_scanCount = 0;
     }
-    _scanComplete = false;
 }
 
 

libraries/WiFi/src/WiFiScan.h

@@ -33,7 +33,7 @@ public:
 
     int16_t scanNetworks(bool async = false, bool show_hidden = false, bool passive = false, uint32_t max_ms_per_chan = 300);
 
-    int8_t scanComplete();
+    int16_t scanComplete();
     void scanDelete();
 
     // scan result
@@ -50,8 +50,6 @@ public:
 protected:
 
     static bool _scanAsync;
-    static bool _scanStarted;
-    static bool _scanComplete;
 
     static uint16_t _scanCount;
     static void* _scanResult;

libraries/WiFi/src/WiFiServer.cpp

@@ -62,9 +62,12 @@ WiFiClient WiFiServer::available(){
   return WiFiClient();
 }
 
-void WiFiServer::begin(){
+void WiFiServer::begin(uint16_t port){
   if(_listening)
     return;
+  if(port){
+      _port = port;
+  }
   struct sockaddr_in server;
   sockfd = socket(AF_INET , SOCK_STREAM, 0);
   if (sockfd < 0)

libraries/WiFi/src/WiFiServer.h

@@ -39,7 +39,7 @@ class WiFiServer : public Server {
     ~WiFiServer(){ end();}
     WiFiClient available();
     WiFiClient accept(){return available();}
-    void begin();
+    void begin(uint16_t port=0);
     void setNoDelay(bool nodelay);
     bool getNoDelay();
     bool hasClient();

libraries/WiFiClientSecure/src/ssl_client.cpp

@@ -17,6 +17,7 @@
 #include <algorithm>
 #include <string>
 #include "ssl_client.h"
+#include "WiFi.h"
 
 
 const char *pers = "esp32-tls";
@@ -60,14 +61,11 @@ int start_ssl_client(sslclient_context *ssl_client, const char *host, uint32_t p
         return ssl_client->socket;
     }
 
-	struct hostent *server;
-    server = gethostbyname(host);
-    if (server == NULL) {
-        log_e("gethostbyname failed");
+    IPAddress srv((uint32_t)0);
+    if(!WiFiGenericClass::hostByName(host, srv)){
         return -1;
     }
-    IPAddress srv((const uint8_t *)(server->h_addr));
-	
+
     struct sockaddr_in serv_addr;
     memset(&serv_addr, 0, sizeof(serv_addr));
     serv_addr.sin_family = AF_INET;

libraries/Wire/src/Wire.cpp

@@ -19,7 +19,8 @@
   Modified 2012 by Todd Krein (todd@krein.org) to implement repeated starts
   Modified December 2014 by Ivan Grokhotkov (ivan@esp8266.com) - esp8266 support
   Modified April 2015 by Hrsto Gochkov (ficeto@ficeto.com) - alternative esp8266 support
-*/
+  Modified Nov 2017 by Chuck Todd (ctodd@cableone.net) - ESP32 ISR Support
+ */
 
 extern "C" {
 #include <stdlib.h>
@@ -38,64 +39,80 @@ TwoWire::TwoWire(uint8_t bus_num)
     ,i2c(NULL)
     ,rxIndex(0)
     ,rxLength(0)
+    ,rxQueued(0)
     ,txIndex(0)
     ,txLength(0)
     ,txAddress(0)
+    ,txQueued(0)
     ,transmitting(0)
+    ,last_error(I2C_ERROR_OK)
+    ,_timeOutMillis(50)
 {}
 
+TwoWire::~TwoWire()
+{
+    flush();
+    if(i2c) {
+        i2cRelease(i2c);
+        i2c=NULL;
+    }
+}
+
 void TwoWire::begin(int sdaPin, int sclPin, uint32_t frequency)
 {
     if(sdaPin < 0) { // default param passed
         if(num == 0) {
-            if(sda==-1) sdaPin = SDA; //use Default Pin
-            else sdaPin = sda; // reuse prior pin
+            if(sda==-1) {
+                sdaPin = SDA;    //use Default Pin
+            } else {
+                sdaPin = sda;    // reuse prior pin
+            }
         } else {
             if(sda==-1) {
                 log_e("no Default SDA Pin for Second Peripheral");
                 return; //no Default pin for Second Peripheral
-            } else sdaPin = sda; // reuse prior pin
+            } else {
+                sdaPin = sda;    // reuse prior pin
+            }
         }
     }
 
     if(sclPin < 0) { // default param passed
         if(num == 0) {
-            if(scl==-1) sclPin = SCL; // use Default pin
-            else sclPin = scl; // reuse prior pin
+            if(scl == -1) {
+                sclPin = SCL;    // use Default pin
+            } else {
+                sclPin = scl;    // reuse prior pin
+            }
         } else {
-            if(scl==-1){
+            if(scl == -1) {
                 log_e("no Default SCL Pin for Second Peripheral");
                 return; //no Default pin for Second Peripheral
-            } else sclPin = scl; // reuse prior pin
+            } else {
+                sclPin = scl;    // reuse prior pin
+            }
         }
     }
 
-    if(i2c == NULL) {
-        i2c = i2cInit(num, 0, false);
-        if(i2c == NULL) {
-            return;
-        }
-    }
-
-    i2cSetFrequency(i2c, frequency);
-
-    if(sda >= 0 && sda != sdaPin) {
-        i2cDetachSDA(i2c, sda);
-    }
-
-    if(scl >= 0 && scl != sclPin) {
-        i2cDetachSCL(i2c, scl);
-    }
-
     sda = sdaPin;
     scl = sclPin;
-
-    i2cAttachSDA(i2c, sda);
-    i2cAttachSCL(i2c, scl);
+    i2c = i2cInit(num, sdaPin, sclPin, frequency);
+    if(!i2c) {
+        return;
+    }
 
     flush();
 
-    i2cInitFix(i2c);
+}
+
+void TwoWire::setTimeOut(uint16_t timeOutMillis)
+{
+    _timeOutMillis = timeOutMillis;
+}
+
+uint16_t TwoWire::getTimeOut()
+{
+    return _timeOutMillis;
 }
 
 void TwoWire::setClock(uint32_t frequency)
@@ -103,62 +120,82 @@ void TwoWire::setClock(uint32_t frequency)
     i2cSetFrequency(i2c, frequency);
 }
 
-size_t TwoWire::requestFrom(uint8_t address, size_t size, bool sendStop)
+size_t TwoWire::getClock()
 {
-    if(size > I2C_BUFFER_LENGTH) {
-        size = I2C_BUFFER_LENGTH;
-    }
-    size_t read = (i2cRead(i2c, address, false, rxBuffer, size, sendStop) == 0)?size:0;
-    rxIndex = 0;
-    rxLength = read;
-    return read;
+    return i2cGetFrequency(i2c);
 }
 
-uint8_t TwoWire::endTransmission(uint8_t sendStop)
+/* stickBreaker Nov 2017 ISR, and bigblock 64k-1
+ */
+i2c_err_t TwoWire::writeTransmission(uint16_t address, uint8_t *buff, uint16_t size, bool sendStop)
 {
-    int8_t ret = i2cWrite(i2c, txAddress, false, txBuffer, txLength, sendStop);
-    txIndex = 0;
-    txLength = 0;
-    transmitting = 0;
-    return ret;
+    last_error = i2cWrite(i2c, address, buff, size, sendStop, _timeOutMillis);
+    return last_error;
 }
 
-uint8_t TwoWire::requestFrom(uint8_t address, uint8_t quantity, uint8_t sendStop)
+i2c_err_t TwoWire::readTransmission(uint16_t address, uint8_t *buff, uint16_t size, bool sendStop, uint32_t *readCount)
 {
-    return requestFrom(address, static_cast<size_t>(quantity), static_cast<bool>(sendStop));
+    last_error = i2cRead(i2c, address, buff, size, sendStop, _timeOutMillis, readCount);
+    return last_error;
 }
 
-uint8_t TwoWire::requestFrom(uint8_t address, uint8_t quantity)
-{
-    return requestFrom(address, static_cast<size_t>(quantity), true);
-}
-
-uint8_t TwoWire::requestFrom(int address, int quantity)
-{
-    return requestFrom(static_cast<uint8_t>(address), static_cast<size_t>(quantity), true);
-}
-
-uint8_t TwoWire::requestFrom(int address, int quantity, int sendStop)
-{
-    return requestFrom(static_cast<uint8_t>(address), static_cast<size_t>(quantity), static_cast<bool>(sendStop));
-}
-
-void TwoWire::beginTransmission(uint8_t address)
+void TwoWire::beginTransmission(uint16_t address)
 {
     transmitting = 1;
     txAddress = address;
+    txIndex = txQueued; // allow multiple beginTransmission(),write(),endTransmission(false) until endTransmission(true)
+    txLength = txQueued;
+}
+
+/*stickbreaker isr
+ */
+uint8_t TwoWire::endTransmission(bool sendStop)  // Assumes Wire.beginTransaction(), Wire.write()
+{
+    if(transmitting == 1) {
+        last_error = writeTransmission(txAddress, &txBuffer[txQueued], txLength - txQueued, sendStop);
+        rxIndex = 0;
+        rxLength = rxQueued;
+        rxQueued = 0;
+        txQueued = 0; // the SendStop=true will restart all Queueing
+        if(last_error == I2C_ERROR_CONTINUE){
+            // txlength is howmany bytes in txbuffer have been use
+            txQueued = txLength;
+        }
+    } else {
+        last_error = I2C_ERROR_NO_BEGIN;
+        flush();
+    }
     txIndex = 0;
     txLength = 0;
+    transmitting = 0;
+    return last_error;
 }
 
-void TwoWire::beginTransmission(int address)
+/* @stickBreaker 11/2017 fix for ReSTART timeout, ISR
+ */
+uint8_t TwoWire::requestFrom(uint16_t address, uint8_t size, bool sendStop)
 {
-    beginTransmission((uint8_t)address);
-}
+    //use internal Wire rxBuffer, multiple requestFrom()'s may be pending, try to share rxBuffer
+    uint32_t cnt = rxQueued; // currently queued reads, next available position in rxBuffer
+    if(cnt < (I2C_BUFFER_LENGTH-1) && (size + cnt) <= I2C_BUFFER_LENGTH) { // any room left in rxBuffer
+        rxQueued += size;
+    } else { // no room to receive more!
+        log_e("rxBuff overflow %d", cnt + size);
+        cnt = 0;
+        last_error = I2C_ERROR_MEMORY;
+        flush();
+        return cnt;
+    }
 
-uint8_t TwoWire::endTransmission(void)
-{
-    return endTransmission(true);
+    last_error = readTransmission(address, &rxBuffer[cnt], size, sendStop, &cnt);
+    rxIndex = 0;
+    rxLength = rxQueued;
+    rxQueued = 0;
+    txQueued = 0; // the SendStop=true will restart all Queueing
+    if(last_error != I2C_ERROR_OK){
+        cnt = 0;
+    }
+    return cnt;
 }
 
 size_t TwoWire::write(uint8_t data)
@@ -170,8 +207,9 @@ size_t TwoWire::write(uint8_t data)
         txBuffer[txIndex] = data;
         ++txIndex;
         txLength = txIndex;
+        return 1;
     }
-    return 1;
+    return 0;
 }
 
 size_t TwoWire::write(const uint8_t *data, size_t quantity)
@@ -182,8 +220,9 @@ size_t TwoWire::write(const uint8_t *data, size_t quantity)
                 return i;
             }
         }
+        return quantity;
     }
-    return quantity;
+    return 0;
 }
 
 int TwoWire::available(void)
@@ -217,13 +256,111 @@ void TwoWire::flush(void)
     rxLength = 0;
     txIndex = 0;
     txLength = 0;
+    rxQueued = 0;
+    txQueued = 0;
+    i2cFlush(i2c); // cleanup
 }
 
-void TwoWire::reset(void)
+uint8_t TwoWire::requestFrom(uint8_t address, uint8_t quantity, uint8_t sendStop)
 {
-    i2cReset( i2c );
-    i2c = NULL;
-    begin( sda, scl );
+    return requestFrom(static_cast<uint16_t>(address), static_cast<size_t>(quantity), static_cast<bool>(sendStop));
+}
+
+uint8_t TwoWire::requestFrom(uint16_t address, uint8_t quantity, uint8_t sendStop)
+{
+    return requestFrom(address, static_cast<size_t>(quantity), static_cast<bool>(sendStop));
+}
+
+uint8_t TwoWire::requestFrom(uint8_t address, uint8_t quantity)
+{
+    return requestFrom(static_cast<uint16_t>(address), static_cast<size_t>(quantity), true);
+}
+
+uint8_t TwoWire::requestFrom(uint16_t address, uint8_t quantity)
+{
+    return requestFrom(address, static_cast<size_t>(quantity), true);
+}
+
+uint8_t TwoWire::requestFrom(int address, int quantity)
+{
+    return requestFrom(static_cast<uint16_t>(address), static_cast<size_t>(quantity), true);
+}
+
+uint8_t TwoWire::requestFrom(int address, int quantity, int sendStop)
+{
+    return static_cast<uint8_t>(requestFrom(static_cast<uint16_t>(address), static_cast<size_t>(quantity), static_cast<bool>(sendStop)));
+}
+
+void TwoWire::beginTransmission(int address)
+{
+    beginTransmission(static_cast<uint16_t>(address));
+}
+
+void TwoWire::beginTransmission(uint8_t address)
+{
+    beginTransmission(static_cast<uint16_t>(address));
+}
+
+uint8_t TwoWire::endTransmission(void)
+{
+    return endTransmission(true);
+}
+
+uint8_t TwoWire::endTransmission(uint8_t sendStop)
+{
+    return endTransmission(static_cast<bool>(sendStop));
+}
+
+/* stickbreaker Nov2017 better error reporting
+ */
+uint8_t TwoWire::lastError()
+{
+    return (uint8_t)last_error;
+}
+
+const char ERRORTEXT[] =
+    "OK\0"
+    "DEVICE\0"
+    "ACK\0"
+    "TIMEOUT\0"
+    "BUS\0"
+    "BUSY\0"
+    "MEMORY\0"
+    "CONTINUE\0"
+    "NO_BEGIN\0"
+    "\0";
+
+
+char * TwoWire::getErrorText(uint8_t err)
+{
+    uint8_t t = 0;
+    bool found = false;
+    char * message = (char*)&ERRORTEXT;
+
+    while(!found && message[0]) {
+        found = t == err;
+        if(!found) {
+            message = message + strlen(message) + 1;
+            t++;
+        }
+    }
+    if(!found) {
+        return NULL;
+    } else {
+        return message;
+    }
+}
+
+/*stickbreaker Dump i2c Interrupt buffer, i2c isr Debugging
+ */
+void TwoWire::dumpInts()
+{
+    i2cDumpInts(num);
+}
+
+void TwoWire::dumpI2C()
+{
+    i2cDumpI2c(i2c);
 }
 
 TwoWire Wire = TwoWire(0);

libraries/Wire/src/Wire.h

@@ -19,6 +19,7 @@
   Modified 2012 by Todd Krein (todd@krein.org) to implement repeated starts
   Modified December 2014 by Ivan Grokhotkov (ivan@esp8266.com) - esp8266 support
   Modified April 2015 by Hrsto Gochkov (ficeto@ficeto.com) - alternative esp8266 support
+  Modified November 2017 by Chuck Todd <stickbreaker on GitHub> to use ISR and increase stability.
 */
 
 #ifndef TwoWire_h
@@ -29,7 +30,10 @@
 #include "freertos/queue.h"
 #include "Stream.h"
 
+#define STICKBREAKER V0.2.2
 #define I2C_BUFFER_LENGTH 128
+typedef void(*user_onRequest)(void);
+typedef void(*user_onReceive)(uint8_t*, int);
 
 class TwoWire: public Stream
 {
@@ -42,28 +46,57 @@ protected:
     uint8_t rxBuffer[I2C_BUFFER_LENGTH];
     uint16_t rxIndex;
     uint16_t rxLength;
+    uint16_t rxQueued; //@stickBreaker
 
     uint8_t txBuffer[I2C_BUFFER_LENGTH];
     uint16_t txIndex;
     uint16_t txLength;
-    uint8_t txAddress;
+    uint16_t txAddress;
+    uint16_t txQueued; //@stickbreaker
 
     uint8_t transmitting;
+    /* slave Mode, not yet Stickbreaker
+            static user_onRequest uReq[2];
+            static user_onReceive uRcv[2];
+        void onRequestService(void);
+        void onReceiveService(uint8_t*, int);
+    */
+    i2c_err_t last_error; // @stickBreaker from esp32-hal-i2c.h
+    uint16_t _timeOutMillis;
 
 public:
     TwoWire(uint8_t bus_num);
-    void begin(int sda=-1, int scl=-1, uint32_t frequency=100000);
-    void setClock(uint32_t);
-    void beginTransmission(uint8_t);
-    void beginTransmission(int);
-    uint8_t endTransmission(void);
-    uint8_t endTransmission(uint8_t);
-    size_t requestFrom(uint8_t address, size_t size, bool sendStop);
+    ~TwoWire();
+    void begin(int sda=-1, int scl=-1, uint32_t frequency=0);
 
-    uint8_t requestFrom(uint8_t, uint8_t);
-    uint8_t requestFrom(uint8_t, uint8_t, uint8_t);
-    uint8_t requestFrom(int, int);
-    uint8_t requestFrom(int, int, int);
+    void setClock(uint32_t frequency); // change bus clock without initing hardware
+    size_t getClock(); // current bus clock rate in hz
+
+    void setTimeOut(uint16_t timeOutMillis);
+    uint16_t getTimeOut();
+
+    uint8_t lastError();
+    char * getErrorText(uint8_t err);
+
+    //@stickBreaker for big blocks and ISR model
+    i2c_err_t writeTransmission(uint16_t address, uint8_t* buff, uint16_t size, bool sendStop=true);
+    i2c_err_t readTransmission(uint16_t address, uint8_t* buff, uint16_t size, bool sendStop=true, uint32_t *readCount=NULL);
+
+    void beginTransmission(uint16_t address);
+    void beginTransmission(uint8_t address);
+    void beginTransmission(int address);
+
+    uint8_t endTransmission(bool sendStop);
+    uint8_t endTransmission(uint8_t sendStop);
+    uint8_t endTransmission(void);
+
+    uint8_t requestFrom(uint16_t address, uint8_t size, bool sendStop);
+    uint8_t requestFrom(uint16_t address, uint8_t size, uint8_t sendStop);
+    uint8_t requestFrom(uint16_t address, uint8_t size);
+    uint8_t requestFrom(uint8_t address, uint8_t size, uint8_t sendStop);
+    uint8_t requestFrom(uint8_t address, uint8_t size);
+    uint8_t requestFrom(int address, int size, int sendStop);
+    uint8_t requestFrom(int address, int size);
 
     size_t write(uint8_t);
     size_t write(const uint8_t *, size_t);
@@ -72,8 +105,6 @@ public:
     int peek(void);
     void flush(void);
 
-    void reset(void);
-
     inline size_t write(const char * s)
     {
         return write((uint8_t*) s, strlen(s));
@@ -94,8 +125,19 @@ public:
     {
         return write((uint8_t)n);
     }
+
+    void onReceive( void (*)(int) );
+    void onRequest( void (*)(void) );
+
+    void dumpInts();
+    void dumpI2C();
 };
 
 extern TwoWire Wire;
 
+
+/*
+V0.2.2 13APR2018 preserve custom SCL,SDA,Frequency when no parameters passed to begin()
+V0.2.1 15MAR2018 Hardware reset, Glitch prevention, adding destructor for second i2c testing
+*/
 #endif

package/merge_packages.py

@@ -0,0 +1,78 @@
+#!/usr/bin/env python
+# This script merges two Arduino Board Manager package json files.
+# Usage:
+#   python merge_packages.py package_esp8266com_index.json version/new/package_esp8266com_index.json
+# Written by Ivan Grokhotkov, 2015
+#
+from __future__ import print_function
+from distutils.version import LooseVersion
+import re
+import json
+import sys
+
+def load_package(filename):
+    pkg = json.load(open(filename))['packages'][0]
+    print("Loaded package {0} from {1}".format(pkg['name'], filename), file=sys.stderr)
+    print("{0} platform(s), {1} tools".format(len(pkg['platforms']), len(pkg['tools'])), file=sys.stderr)
+    return pkg
+
+def merge_objects(versions, obj):
+    for o in obj:
+        name = o['name'].encode('ascii')
+        ver = o['version'].encode('ascii')
+        if not name in versions:
+            print("found new object, {0}".format(name), file=sys.stderr)
+            versions[name] = {}
+        if not ver in versions[name]:
+            print("found new version {0} for object {1}".format(ver, name), file=sys.stderr)
+            versions[name][ver] = o
+    return versions
+
+# Normalize ESP release version string (x.x.x) by adding '-rc<MAXINT>' (x.x.x-rc9223372036854775807) to ensure having REL above any RC
+# Dummy approach, functional anyway for current ESP package versioning (unlike NormalizedVersion/LooseVersion/StrictVersion & similar crap)
+def pkgVersionNormalized(versionString):
+
+    verStr = str(versionString)
+    verParts = re.split('\.|-rc', verStr, flags=re.IGNORECASE)
+    
+    if len(verParts) == 3:
+        verStr = str(versionString) + '-rc' + str(sys.maxint)
+    elif len(verParts) != 4:
+        print("pkgVersionNormalized WARNING: unexpected version format: {0})".format(verStr), file=sys.stderr)
+        
+    return verStr
+
+
+def main(args):
+    if len(args) < 3:
+        print("Usage: {0} <package1> <package2>".format(args[0]), file=sys.stderr)
+        return 1
+
+    tools = {}
+    platforms = {} 
+    pkg1 = load_package(args[1])
+    tools = merge_objects(tools, pkg1['tools']);
+    platforms = merge_objects(platforms, pkg1['platforms']);
+    pkg2 = load_package(args[2])
+    tools = merge_objects(tools, pkg2['tools']);
+    platforms = merge_objects(platforms, pkg2['platforms']);
+
+    pkg1['tools'] = []
+    pkg1['platforms'] = []
+
+    for name in tools:
+        for version in tools[name]:
+            print("Adding tool {0}-{1}".format(name, version), file=sys.stderr)
+            pkg1['tools'].append(tools[name][version])
+
+    for name in platforms:
+        for version in platforms[name]:
+            print("Adding platform {0}-{1}".format(name, version), file=sys.stderr)
+            pkg1['platforms'].append(platforms[name][version])
+                
+    pkg1['platforms'] = sorted(pkg1['platforms'], key=lambda k: LooseVersion(pkgVersionNormalized(k['version'])), reverse=True)
+
+    json.dump({'packages':[pkg1]}, sys.stdout, indent=2)
+
+if __name__ == '__main__':
+    sys.exit(main(sys.argv))

package/package_esp32_index.template.json

@@ -43,7 +43,7 @@
             {
               "packager": "esp32",
               "name": "mkspiffs",
-              "version": "0.2.2"
+              "version": "0.2.3"
             }
           ]
         }
@@ -105,49 +105,49 @@
         },
         {
           "name": "mkspiffs",
-          "version": "0.2.2",
+          "version": "0.2.3",
           "systems": [
             {
               "host": "i686-mingw32",
-              "url": "https://github.com/igrr/mkspiffs/releases/download/0.2.2/mkspiffs-0.2.2-arduino-esp32-win32.zip",
-              "archiveFileName": "mkspiffs-0.2.2-arduino-esp32-win32.zip",
-              "checksum": "SHA-256:988baa2827005a20a7c7028f0c2d45d19df2e0a7d42319f4a7a5776a3f0dff2e",
-              "size": "347207"
+              "url": "https://github.com/igrr/mkspiffs/releases/download/0.2.3/mkspiffs-0.2.3-arduino-esp32-win32.zip",
+              "archiveFileName": "mkspiffs-0.2.3-arduino-esp32-win32.zip",
+              "checksum": "SHA-256:b647f2c2efe6949819c85ea9404271b55c7c9c25bcb98d3b98a1d0ba771adf56",
+              "size": "249809"
             },
             {
               "host": "x86_64-apple-darwin",
-              "url": "https://github.com/igrr/mkspiffs/releases/download/0.2.2/mkspiffs-0.2.2-arduino-esp32-osx.tar.gz",
-              "archiveFileName": "mkspiffs-0.2.2-arduino-esp32-osx.tar.gz",
-              "checksum": "SHA-256:7aee138be9a73fe7fd1f75cf3f3695f0afae812d04fcbf74b17da330f66ae4cd",
-              "size": "130211"
+              "url": "https://github.com/igrr/mkspiffs/releases/download/0.2.3/mkspiffs-0.2.3-arduino-esp32-osx.tar.gz",
+              "archiveFileName": "mkspiffs-0.2.3-arduino-esp32-osx.tar.gz",
+              "checksum": "SHA-256:9f43fc74a858cf564966b5035322c3e5e61c31a647c5a1d71b388ed6efc48423",
+              "size": "130270"
             },
             {
               "host": "i386-apple-darwin",
-              "url": "https://github.com/igrr/mkspiffs/releases/download/0.2.2/mkspiffs-0.2.2-arduino-esp32-osx.tar.gz",
-              "archiveFileName": "mkspiffs-0.2.2-arduino-esp32-osx.tar.gz",
-              "checksum": "SHA-256:7aee138be9a73fe7fd1f75cf3f3695f0afae812d04fcbf74b17da330f66ae4cd",
-              "size": "130211"
+              "url": "https://github.com/igrr/mkspiffs/releases/download/0.2.3/mkspiffs-0.2.3-arduino-esp32-osx.tar.gz",
+              "archiveFileName": "mkspiffs-0.2.3-arduino-esp32-osx.tar.gz",
+              "checksum": "SHA-256:9f43fc74a858cf564966b5035322c3e5e61c31a647c5a1d71b388ed6efc48423",
+              "size": "130270"
             },
             {
               "host": "x86_64-pc-linux-gnu",
-              "url": "https://github.com/igrr/mkspiffs/releases/download/0.2.2/mkspiffs-0.2.2-arduino-esp32-linux64.tar.gz",
-              "archiveFileName": "mkspiffs-0.2.2-arduino-esp32-linux64.tar.gz",
-              "checksum": "SHA-256:17f89d9b38d4f68f2f03f7561b951d1d3b6d6f5b74d35b6d3eb8da3440be3400",
-              "size": "50611"
+              "url": "https://github.com/igrr/mkspiffs/releases/download/0.2.3/mkspiffs-0.2.3-arduino-esp32-linux64.tar.gz",
+              "archiveFileName": "mkspiffs-0.2.3-arduino-esp32-linux64.tar.gz",
+              "checksum": "SHA-256:5e1a4ff41385e842f389f6b5254102a547e566a06b49babeffa93ef37115cb5d",
+              "size": "50646"
             },
             {
               "host": "i686-pc-linux-gnu",
-              "url": "https://github.com/igrr/mkspiffs/releases/download/0.2.2/mkspiffs-0.2.2-arduino-esp32-linux32.tar.gz",
-              "archiveFileName": "mkspiffs-0.2.2-arduino-esp32-linux32.tar.gz",
-              "checksum": "SHA-256:181fca76210de04a23eb7af028d9886de5a73e638c63d351a691a24cfb9f03d3",
-              "size": "48730"
+              "url": "https://github.com/igrr/mkspiffs/releases/download/0.2.3/mkspiffs-0.2.3-arduino-esp32-linux32.tar.gz",
+              "archiveFileName": "mkspiffs-0.2.3-arduino-esp32-linux32.tar.gz",
+              "checksum": "SHA-256:464463a93e8833209cdc29ba65e1a12fec31718dc10075c195a2445b2c3f6cb0",
+              "size": "48751"
             },
             {
               "host": "arm-linux-gnueabihf",
-              "url": "https://github.com/igrr/mkspiffs/releases/download/0.2.2/mkspiffs-0.2.2-arduino-esp32-linux-armhf.tar.gz",
-              "archiveFileName": "mkspiffs-0.2.2-arduino-esp32-linux-armhf.tar.gz",
-              "checksum": "SHA-256:2e99cbdf5ee60b27d6ade096d4caf03a90edfd5f4edf4da2a8674d770aa4ca1b",
-              "size": "40658"
+              "url": "https://github.com/igrr/mkspiffs/releases/download/0.2.3/mkspiffs-0.2.3-arduino-esp32-linux-armhf.tar.gz",
+              "archiveFileName": "mkspiffs-0.2.3-arduino-esp32-linux-armhf.tar.gz",
+              "checksum": "SHA-256:ade3dc00117912ac08a1bdbfbfe76b12d21a34bc5fa1de0cfc45fe7a8d0a0185",
+              "size": "40665"
             }
           ]
         }

platform.txt

@@ -22,7 +22,7 @@ compiler.warning_flags.all=-Wall -Werror=all -Wextra
 
 compiler.path={runtime.tools.xtensa-esp32-elf-gcc.path}/bin/
 compiler.sdk.path={runtime.platform.path}/tools/sdk
-compiler.cpreprocessor.flags=-DESP_PLATFORM -DMBEDTLS_CONFIG_FILE="mbedtls/esp_config.h" -DHAVE_CONFIG_H "-I{compiler.sdk.path}/include/config" "-I{compiler.sdk.path}/include/bluedroid" "-I{compiler.sdk.path}/include/app_trace" "-I{compiler.sdk.path}/include/app_update" "-I{compiler.sdk.path}/include/bootloader_support" "-I{compiler.sdk.path}/include/bt" "-I{compiler.sdk.path}/include/driver" "-I{compiler.sdk.path}/include/esp32" "-I{compiler.sdk.path}/include/esp_adc_cal" "-I{compiler.sdk.path}/include/ethernet" "-I{compiler.sdk.path}/include/fatfs" "-I{compiler.sdk.path}/include/freertos" "-I{compiler.sdk.path}/include/heap" "-I{compiler.sdk.path}/include/jsmn" "-I{compiler.sdk.path}/include/log" "-I{compiler.sdk.path}/include/mdns" "-I{compiler.sdk.path}/include/mbedtls" "-I{compiler.sdk.path}/include/mbedtls_port" "-I{compiler.sdk.path}/include/newlib" "-I{compiler.sdk.path}/include/nvs_flash" "-I{compiler.sdk.path}/include/openssl" "-I{compiler.sdk.path}/include/spi_flash" "-I{compiler.sdk.path}/include/sdmmc" "-I{compiler.sdk.path}/include/spiffs" "-I{compiler.sdk.path}/include/tcpip_adapter" "-I{compiler.sdk.path}/include/ulp" "-I{compiler.sdk.path}/include/vfs" "-I{compiler.sdk.path}/include/wear_levelling" "-I{compiler.sdk.path}/include/xtensa-debug-module" "-I{compiler.sdk.path}/include/coap" "-I{compiler.sdk.path}/include/console" "-I{compiler.sdk.path}/include/expat" "-I{compiler.sdk.path}/include/json" "-I{compiler.sdk.path}/include/lwip" "-I{compiler.sdk.path}/include/newlib" "-I{compiler.sdk.path}/include/nghttp" "-I{compiler.sdk.path}/include/soc" "-I{compiler.sdk.path}/include/wpa_supplicant"
+compiler.cpreprocessor.flags=-DESP_PLATFORM -DMBEDTLS_CONFIG_FILE="mbedtls/esp_config.h" -DHAVE_CONFIG_H "-I{compiler.sdk.path}/include/config" "-I{compiler.sdk.path}/include/bluedroid" "-I{compiler.sdk.path}/include/bluedroid/api" "-I{compiler.sdk.path}/include/app_trace" "-I{compiler.sdk.path}/include/app_update" "-I{compiler.sdk.path}/include/bootloader_support" "-I{compiler.sdk.path}/include/bt" "-I{compiler.sdk.path}/include/driver" "-I{compiler.sdk.path}/include/esp32" "-I{compiler.sdk.path}/include/esp_adc_cal" "-I{compiler.sdk.path}/include/esp_http_client" "-I{compiler.sdk.path}/include/esp-tls" "-I{compiler.sdk.path}/include/ethernet" "-I{compiler.sdk.path}/include/fatfs" "-I{compiler.sdk.path}/include/freertos" "-I{compiler.sdk.path}/include/heap" "-I{compiler.sdk.path}/include/jsmn" "-I{compiler.sdk.path}/include/log" "-I{compiler.sdk.path}/include/mdns" "-I{compiler.sdk.path}/include/mbedtls" "-I{compiler.sdk.path}/include/mbedtls_port" "-I{compiler.sdk.path}/include/newlib" "-I{compiler.sdk.path}/include/nvs_flash" "-I{compiler.sdk.path}/include/openssl" "-I{compiler.sdk.path}/include/spi_flash" "-I{compiler.sdk.path}/include/sdmmc" "-I{compiler.sdk.path}/include/smartconfig_ack" "-I{compiler.sdk.path}/include/spiffs" "-I{compiler.sdk.path}/include/tcpip_adapter" "-I{compiler.sdk.path}/include/ulp" "-I{compiler.sdk.path}/include/vfs" "-I{compiler.sdk.path}/include/wear_levelling" "-I{compiler.sdk.path}/include/xtensa-debug-module" "-I{compiler.sdk.path}/include/coap" "-I{compiler.sdk.path}/include/console" "-I{compiler.sdk.path}/include/expat" "-I{compiler.sdk.path}/include/json" "-I{compiler.sdk.path}/include/lwip" "-I{compiler.sdk.path}/include/newlib" "-I{compiler.sdk.path}/include/nghttp" "-I{compiler.sdk.path}/include/soc" "-I{compiler.sdk.path}/include/wpa_supplicant"
 
 compiler.c.cmd=xtensa-esp32-elf-gcc
 compiler.c.flags=-std=gnu99 -Os -g3 -fstack-protector -ffunction-sections -fdata-sections -fstrict-volatile-bitfields -mlongcalls -nostdlib -Wpointer-arith {compiler.warning_flags} -Wno-error=unused-function -Wno-error=unused-but-set-variable -Wno-error=unused-variable -Wno-error=deprecated-declarations -Wno-unused-parameter -Wno-sign-compare -Wno-old-style-declaration -MMD -c
@@ -35,7 +35,7 @@ compiler.S.flags=-c -g3 -x assembler-with-cpp -MMD -mlongcalls
 
 compiler.c.elf.cmd=xtensa-esp32-elf-gcc
 compiler.c.elf.flags=-nostdlib "-L{compiler.sdk.path}/lib" "-L{compiler.sdk.path}/ld" -T esp32_out.ld -T esp32.common.ld -T esp32.rom.ld -T esp32.peripherals.ld -T esp32.rom.spiram_incompatible_fns.ld -u ld_include_panic_highint_hdl -u call_user_start_cpu0 -Wl,--gc-sections -Wl,-static -Wl,--undefined=uxTopUsedPriority  -u __cxa_guard_dummy -u __cxx_fatal_exception
-compiler.c.elf.libs=-lgcc -lopenssl -lbtdm_app -lfatfs -lwps -lcoexist -lwear_levelling -lhal -lnewlib -ldriver -lbootloader_support -lpp -lmesh -lsmartconfig -ljsmn -lwpa -lethernet -lphy -lapp_trace -lconsole -lulp -lwpa_supplicant -lfreertos -lbt -lmicro-ecc -lcxx -lxtensa-debug-module -lmdns -lvfs -lsoc -lcore -lsdmmc -lcoap -ltcpip_adapter -lc_nano -lrtc -lspi_flash -lwpa2 -lesp32 -lapp_update -lnghttp -lspiffs -lespnow -lnvs_flash -lesp_adc_cal -llog -lexpat -lm -lc -lheap -lmbedtls -llwip -lnet80211 -lpthread -ljson  -lstdc++
+compiler.c.elf.libs=-lgcc -lopenssl -lbtdm_app -lfatfs -lwps -lcoexist -lwear_levelling -lesp_http_client -lhal -lnewlib -ldriver -lbootloader_support -lpp -lmesh -lsmartconfig -ljsmn -lwpa -lethernet -lphy -lapp_trace -lconsole -lulp -lwpa_supplicant -lfreertos -lbt -lmicro-ecc -lcxx -lxtensa-debug-module -lmdns -lvfs -lsoc -lcore -lsdmmc -lcoap -ltcpip_adapter -lc_nano -lesp-tls -lrtc -lspi_flash -lwpa2 -lesp32 -lapp_update -lnghttp -lspiffs -lespnow -lnvs_flash -lesp_adc_cal -llog -lsmartconfig_ack -lexpat -lm -lc -lheap -lmbedtls -llwip -lnet80211 -lpthread -ljson  -lstdc++
 
 compiler.as.cmd=xtensa-esp32-elf-as
 

tools/build-release.sh

@@ -0,0 +1,348 @@
+#!/bin/bash
+
+############################################################
+# $1 - download link
+# $2 - JSON output file 
+function downloadAndMergePackageJSON()
+{
+	echo " --- Package JSON definition merge BEGIN ---"
+	
+	jsonLink=$1
+	jsonOut=$2
+	curlAuthToken=$3
+	outDirectory=$4
+	
+	echo "Remote package JSON: $jsonLink (source)"
+	echo "Current package JSON: $jsonOut (target)"
+	
+	old_json=$outDirectory/oldJson.json
+	merged_json=$outDirectory/mergedJson.json
+	
+	#DEBUG
+	#echo "     Local tmp for remote JSON: $old_json"
+	#echo "     Merge output JSON: $merged_json"
+	
+	echo "Downloading JSON package definition: $jsonLink ..."
+
+	# Authentication through HTTP headers might fail on redirection due to bug in cURL (https://curl.haxx.se/docs/adv_2018-b3bf.html - headers are resent to the target location including the original authentication)
+	# Notes:
+	#  - eg AmazonAWS fails with Bad Request due to having maximum 1 authentication mechanism per a request, might be general issue
+	#  - it's a first-class credential leakage
+	#  - the fix is available in cURL 7.58.0+, however, TravisCI is not yet updated (May 29, 2018) - see https://docs.travis-ci.com/user/build-environment-updates
+	#  - TravisCI workaround: updating build environment through .travis.yml (ie install required version of cURL using apt-get, see https://docs.travis-ci.com/user/installing-dependencies/) 
+	#  - previous point not used on purpose (build time increase, possible failure corrupts whole build, etc) but it's good to know there's a way out of hell
+	#  - local workaround: authentication through 'access_token' as GET parameter works smoothly, however, HTTP headers are preferred
+	
+	#curl --verbose -sH "Authorization: token $curlAuthToken" -L -o "$old_json" "$jsonLink"
+	curl -L -o "$old_json" "$jsonLink?access_token=$curlAuthToken"
+	
+	#curl -L -o "$old_json" "$jsonLink"
+	
+	echo "Merging $old_json into $jsonOut ..."
+	
+	echo
+	set +e
+	stdbuf -oL python package/merge_packages.py "$jsonOut" "$old_json" > "$merged_json"
+	set -e	#supposed to be ON by default
+	echo
+	
+	set -v
+	if [ ! -s $merged_json ]; then
+		rm -f "$merged_json"
+		echo "Nothing to merge ($merged_json empty), $jsonOut unchanged"
+	else
+		rm -f "$jsonOut"
+		mv "$merged_json" "$jsonOut"
+		echo "Data successfully merged to $jsonOut"
+	fi
+
+	rm -f "$old_json"
+	set +v
+	echo " --- Package JSON definition merge END ---"
+}
+############################################################
+
+#Cmdline options
+# -a: GitHub API access token
+# -d: output directory to store the (pre)release filedir set
+
+set -e
+
+echo
+echo "==================================================================="
+echo "RELEASE PACKAGE PUBLISHING ARRANGEMENTS (GitHub/Arduino compliance)"
+echo "==================================================================="
+echo
+
+# cURL authentication token
+while getopts ":a:,:d:" opt; do
+  case $opt in
+	a)
+	  curlAuth=$OPTARG
+	  echo "ACCESS TOKEN: $curlAuth" >&2
+	  ;;
+	d)
+	  releaseDir=$OPTARG
+	  echo "RELEASE OUTPUT DIRECTORY: $releaseDir" >&2
+	  ;;
+	\?)
+	  echo "Invalid option: -$OPTARG" >&2
+	  exit 1
+	  ;;
+	:)
+	  echo "Option -$OPTARG requires an argument." >&2
+	  exit 1
+	  ;;
+  esac
+done
+
+# where we at?
+if [ -z "$TRAVIS_BUILD_DIR" ]; then
+	echo "Non-TravisCI environment"
+    cd "$( dirname ${BASH_SOURCE[0]} )"/..
+	bTravisRun=0
+else
+	echo "TravisCI run"
+	cd $TRAVIS_BUILD_DIR
+	bTravisRun=1
+fi
+
+# no tag, no love
+if [ -z "$TRAVIS_TAG" ] && [ $bTravisRun -eq 1 ]; then
+	echo "Non-tagged builds not supported in Travis CI environment, exiting"
+	exit 0
+fi
+	
+currentDir=`pwd`
+echo "Current working directory: $currentDir"
+
+srcdir=$currentDir
+
+if [ -z "$releaseDir" ]; then
+	releaseDir=release
+fi
+echo "Release output directory: $releaseDir"
+
+
+# get current branch name and commit hash
+branch_name=""
+verx=""
+extent=""
+
+if [ -z "$TRAVIS_TAG" ]; then	
+	branch_name=`git rev-parse --abbrev-ref HEAD 2>/dev/null`
+	ver=`sed -n -E 's/version=([0-9.]+)/\1/p' platform.txt`
+	verx=`git rev-parse --short=8 HEAD 2>/dev/null`
+else 
+	ver=$TRAVIS_TAG
+fi
+
+# Package name (case-insensitive)
+shopt -s nocasematch
+
+if [ ! -z "$branch_name" ] && [ "$branch_name" != "master" ]; then
+	extent="-$branch_name-$verx"
+fi
+	
+package_name=esp32-$ver$extent
+
+shopt -u nocasematch
+
+echo "Version: $ver"
+echo "Branch name: $branch_name"
+echo "Git revision (8B): $verx"
+echo "Extension: $extent"	
+echo "Travis CI tag: $TRAVIS_TAG"
+echo "Package name: $package_name"
+
+# Set REMOTE_URL environment variable to the address where the package will be
+# available for download. This gets written into package json file.
+
+if [ -z "$REMOTE_URL" ]; then
+    REMOTE_URL="http://localhost:8000"
+    echo "REMOTE_URL not defined, using default"
+fi
+
+echo "Remote: $REMOTE_URL"
+
+# Create directory for the package
+outdir=$releaseDir/$package_name
+echo "Temporary output directory: $outdir"
+
+rm -rf $releaseDir
+mkdir -p $outdir
+
+# Copy package required stuff:
+
+# <package root>
+cp -f $srcdir/boards.txt $outdir/
+cp -f $srcdir/platform.txt $outdir/
+cp -f $srcdir/programmers.txt $outdir/
+
+# <complete dirs> 
+#	cores/
+#	libraries/
+#	variants/
+cp -Rf $srcdir/cores $outdir/
+cp -Rf $srcdir/libraries $outdir/
+cp -Rf $srcdir/variants $outdir/
+
+# <dir & files>
+#	tools/partitions/
+mkdir -p $outdir/tools/partitions
+cp -f $srcdir/tools/partitions/boot_app0.bin $outdir/tools/partitions
+cp -f $srcdir/tools/partitions/default.csv $outdir/tools/partitions
+cp -f $srcdir/tools/partitions/minimal.csv $outdir/tools/partitions
+cp -f $srcdir/tools/partitions/min_spiffs.csv $outdir/tools/partitions
+cp -f $srcdir/tools/partitions/no_ota.csv $outdir/tools/partitions
+
+#	tools/sdk/
+cp -Rf $srcdir/tools/sdk $outdir/tools/
+
+#	tools/
+cp -f $srcdir/tools/espota.exe $outdir/tools/
+cp -f $srcdir/tools/espota.py $outdir/tools/
+cp -f $srcdir/tools/esptool.py $outdir/tools/
+cp -f $srcdir/tools/gen_esp32part.py $outdir/tools/
+cp -f $srcdir/tools/gen_esp32part.exe $outdir/tools/
+
+find $outdir -name '*.DS_Store' -exec rm -f {} \;
+
+# Do some replacements in platform.txt file, which are required because IDE
+# handles tool paths differently when package is installed in hardware folder
+cat $srcdir/platform.txt | \
+sed 's/runtime.tools.xtensa-esp32-elf-gcc.path={runtime.platform.path}\/tools\/xtensa-esp32-elf//g' | \
+sed 's/tools.esptool.path={runtime.platform.path}\/tools\/esptool/tools.esptool.path=\{runtime.tools.esptool.path\}/g' \
+ > $outdir/platform.txt
+ 
+# Put core version and short hash of git version into core_version.h
+ver_define=`echo $plain_ver | tr "[:lower:].\055" "[:upper:]_"`
+echo Ver define: $ver_define
+echo \#define ARDUINO_ESP32_GIT_VER 0x`git rev-parse --short=8 HEAD 2>/dev/null` >$outdir/cores/esp32/core_version.h
+echo \#define ARDUINO_ESP32_GIT_DESC `git describe --tags 2>/dev/null` >>$outdir/cores/esp32/core_version.h
+echo \#define ARDUINO_ESP32_RELEASE_$ver_define >>$outdir/cores/esp32/core_version.h
+echo \#define ARDUINO_ESP32_RELEASE \"$ver_define\" >>$outdir/cores/esp32/core_version.h
+ 
+# Store submodules' current versions
+git submodule status > $releaseDir/submodules.txt
+
+# remove all .git* files
+find $outdir -name '*.git*' -type f -delete
+
+# Zip the package
+package_name_zip=$package_name.zip
+
+echo "----------------------------------------------------------"
+echo "Making $package_name ZIP archive..."
+echo
+
+pushd $releaseDir >/dev/null
+
+zip -qr $package_name_zip $package_name
+
+
+echo "----------------------------------------------------------"
+echo "Making $package_name JSON definition file(s)..."
+echo
+
+# Calculate SHA sum and size
+sha=`shasum -a 256 $package_name_zip | cut -f 1 -d ' '`
+size=`/bin/ls -l $package_name_zip | awk '{print $5}'`	
+echo Size: $size
+echo SHA-256: $sha
+
+popd >/dev/null
+
+PACKAGE_JSON_DEV="package_esp32_dev_index.json"
+PACKAGE_JSON_REL="package_esp32_index.json"
+
+# figure out the package type (release / pre-release)
+shopt -s nocasematch
+if [[ $TRAVIS_TAG == *-RC* ]]; then
+	bIsPrerelease=1
+	package_name_json=$PACKAGE_JSON_DEV
+	echo "Package type: PRE-RELEASE, JSON def.file: $PACKAGE_JSON_DEV"
+else
+	bIsPrerelease=0
+	package_name_json=$PACKAGE_JSON_REL
+	echo "Package type: RELEASE, JSON def.files: $PACKAGE_JSON_REL, $PACKAGE_JSON_DEV"
+fi
+shopt -u nocasematch
+
+# Generate JSON package definition
+echo
+echo "----------------------------------------------------------"
+echo "Preparing current package definition ($package_name_json)..."
+
+# JSON contents
+jq_arg=".packages[0].platforms[0].version = \"$ver\" | \
+    .packages[0].platforms[0].url = \"$REMOTE_URL/$package_name_zip\" |\
+    .packages[0].platforms[0].archiveFileName = \"$package_name_zip\""
+
+jq_arg="$jq_arg |\
+	.packages[0].platforms[0].size = \"$size\" |\
+	.packages[0].platforms[0].checksum = \"SHA-256:$sha\""
+
+
+# Cleanup temporary work dir
+rm -rf $outdir
+
+
+# Get previous release name
+echo
+echo "----------------------------------------------------------"
+echo "Getting previous releases versions..."
+
+releasesJson=$releaseDir/releases.json
+
+curl -sH "Authorization: token $curlAuth" https://api.github.com/repos/$TRAVIS_REPO_SLUG/releases > $releasesJson
+
+# Previous final release (prerelase == false)
+prev_release=$(jq -r '. | map(select(.draft == false and .prerelease == false)) | sort_by(.created_at | - fromdateiso8601) | .[0].tag_name' ${releasesJson})
+# Previous release (possibly a pre-release)
+prev_any_release=$(jq -r '. | map(select(.draft == false)) | sort_by(.created_at | - fromdateiso8601)  | .[0].tag_name' ${releasesJson})
+# Previous pre-release
+prev_pre_release=$(jq -r '. | map(select(.draft == false and .prerelease == true)) | sort_by(.created_at | - fromdateiso8601)  | .[0].tag_name' ${releasesJson})
+
+rm -f "$releasesJson"
+
+echo "Previous release: $prev_release"
+echo "Previous (pre-?)release: $prev_any_release"
+echo "Previous pre-release: $prev_pre_release"
+
+# always get DEV version of JSON (included in both RC/REL)
+echo
+echo "----------------------------------------------------------"
+echo "Generating $PACKAGE_JSON_DEV..."
+echo
+
+cat $srcdir/package/package_esp32_index.template.json | jq "$jq_arg" > $releaseDir/$PACKAGE_JSON_DEV
+if [ ! -z "$prev_any_release" ] && [ "$prev_any_release" != "null" ]; then
+	downloadAndMergePackageJSON "https://github.com/$TRAVIS_REPO_SLUG/releases/download/${prev_any_release}/${PACKAGE_JSON_DEV}" "$releaseDir/${PACKAGE_JSON_DEV}" "${curlAuth}" "$releaseDir"
+	
+	# Release notes: GIT log comments (prev_any_release, current_release>
+	git log --oneline $prev_any_release.. > $releaseDir/commits.txt
+fi	
+
+# for RELEASE run update REL JSON as well
+if [ $bIsPrerelease -eq 0 ]; then
+
+	echo
+	echo "----------------------------------------------------------"
+	echo "Generating $PACKAGE_JSON_REL..."
+	echo
+
+	cat $srcdir/package/package_esp32_index.template.json | jq "$jq_arg" > $releaseDir/$PACKAGE_JSON_REL
+	if [ ! -z "$prev_release" ] && [ "$prev_release" != "null" ]; then
+		downloadAndMergePackageJSON "https://github.com/$TRAVIS_REPO_SLUG/releases/download/${prev_release}/${PACKAGE_JSON_REL}" "$releaseDir/${PACKAGE_JSON_REL}" "${curlAuth}" "$releaseDir"
+		
+		# Release notes: GIT log comments (prev_release, current_release>
+		git log --oneline $prev_release.. > $releaseDir/commits.txt
+	fi
+fi
+
+echo
+echo "=============================================================="
+echo "Package '$package_name' ready for publishing, script finished."
+echo "=============================================================="
+echo

tools/build-tests.sh

@@ -0,0 +1,53 @@
+#!/bin/bash
+
+#- set -e
+
+if [ ! -z "$TRAVIS_TAG" ]; then
+	echo "No sketch builds & tests required for tagged TravisCI builds, exiting"
+	exit 0
+fi
+
+echo -e "travis_fold:start:sketch_test_env_prepare"
+pip install pyserial
+wget -O arduino.tar.xz https://www.arduino.cc/download.php?f=/arduino-nightly-linux64.tar.xz
+tar xf arduino.tar.xz
+mv arduino-nightly $HOME/arduino_ide
+mkdir -p $HOME/Arduino/libraries
+cd $HOME/arduino_ide/hardware
+mkdir espressif
+cd espressif
+ln -s $TRAVIS_BUILD_DIR esp32
+cd esp32
+git submodule update --init --recursive
+cd tools
+python get.py
+cd $TRAVIS_BUILD_DIR
+export PATH="$HOME/arduino_ide:$TRAVIS_BUILD_DIR/tools/xtensa-esp32-elf/bin:$PATH"
+source tools/common.sh
+echo -e "travis_fold:end:sketch_test_env_prepare"
+
+echo -e "travis_fold:start:sketch_test"
+build_sketches $HOME/arduino_ide $TRAVIS_BUILD_DIR/libraries "-l $HOME/Arduino/libraries"
+if [ $? -ne 0 ]; then exit 1; fi
+echo -e "travis_fold:end:sketch_test"
+
+echo -e "travis_fold:start:size_report"
+cat size.log
+echo -e "travis_fold:end:size_report"
+
+echo -e "travis_fold:start:platformio_test_env_prepare"
+pip install -U https://github.com/platformio/platformio/archive/develop.zip && \
+platformio platform install https://github.com/platformio/platform-espressif32.git#feature/stage && \
+sed -i 's/https:\/\/github\.com\/espressif\/arduino-esp32\.git/*/' ~/.platformio/platforms/espressif32/platform.json && \
+ln -s $TRAVIS_BUILD_DIR ~/.platformio/packages/framework-arduinoespressif32
+if [ $? -ne 0 ]; then exit 1; fi
+echo -e "travis_fold:end:platformio_test_env_prepare"
+
+echo -e "travis_fold:start:platformio_test"
+platformio ci  --board esp32dev libraries/WiFi/examples/WiFiClient && \
+platformio ci  --board esp32dev libraries/WiFiClientSecure/examples/WiFiClientSecure && \
+platformio ci  --board esp32dev libraries/BluetoothSerial/examples/SerialToSerialBT && \
+platformio ci  --board esp32dev libraries/BLE/examples/BLE_server && \
+platformio ci  --board esp32dev libraries/AzureIoT/examples/GetStarted
+if [ $? -ne 0 ]; then exit 1; fi
+echo -e "travis_fold:end:platformio_test"

tools/build.sh

@@ -0,0 +1,12 @@
+#!/bin/bash
+
+# run cmake tests
+tools/check_cmakelists.sh
+if [ $? -ne 0 ]; then exit 1; fi
+
+# run sketch tests
+tools/build-tests.sh
+if [ $? -ne 0 ]; then exit 1; fi
+
+# zip the package if tagged build, otherwise finish here
+tools/build-release.sh -a$ESP32_GITHUB_TOKEN

tools/deploy.sh

@@ -0,0 +1,147 @@
+#!/bin/bash
+
+set -e
+
+#Cmdline options
+# -t: tag (*_RC* determines prerelease version, can be overriden be -p)
+# -a: GitHub API access token
+# -s: GitHub repository slug (user/repo)
+# -p: prerelease true/false
+# -f: files to upload (ie assets. delim = ';', must come quoted)
+# -d: directory to upload (by adding dir contents to assets)
+while getopts ":t:,:a:,:s:,:p:,:f:,:d:" opt; do
+  case $opt in
+	t)
+	  varTagName=$OPTARG
+	  echo "TAG: $varTagName" >&2
+	  ;;
+	a)
+	  varAccessToken=$OPTARG
+	  echo "ACCESS TOKEN: $varAccessToken" >&2
+	  ;;
+	s)
+	  varRepoSlug=$OPTARG
+	  echo "REPO SLUG: $varRepoSlug" >&2
+	  ;;
+	p)
+	  varPrerelease=$OPTARG
+	  echo "PRERELEASE: $varPrerelease" >&2
+	  ;;
+	f)
+	  varAssets=$OPTARG
+	  echo "ASSETS: $varAssets" >&2
+	  ;;	  
+	d)
+	  varAssetsDir=$OPTARG
+	  echo "ASSETS DIR: $varAssetsDir" >&2
+	  ;;	  
+	\?)
+	  echo "Invalid option: -$OPTARG" >&2
+	  exit 1
+	  ;;
+	:)
+	  echo "Option -$OPTARG requires an argument." >&2
+	  exit 1
+	  ;;
+  esac
+done
+
+#Check tag name for release/prerelease (prerelease tag contains '_RC' as for release-candidate. case-insensitive)
+shopt -s nocasematch
+if [ -z $varPrerelease ]; then
+	if [[ $varTagName == *-RC* ]]; then
+		varPrerelease=true
+	else
+		varPrerelease=false
+	fi
+fi
+shopt -u nocasematch
+
+#
+# Prepare Markdown release notes:
+#################################
+#
+# - tag's description:
+# 	ignore first 3 lines - commiter, tagname, blank
+#	first line of message: heading
+#	other lines: converted to bullets
+#	empty lines ignored
+#	if '* ' found as a first char pair, it's converted to '- ' to keep bulleting unified
+relNotesRaw=`git show -s --format=%b $varTagName`
+readarray -t msgArray <<<"$relNotesRaw"
+
+arrLen=${#msgArray[@]}
+if [ $arrLen > 3 ]; then 
+	ind=3
+	while [ $ind -lt $arrLen ]; do
+		if [ $ind -eq 3 ]; then
+			releaseNotes="#### ${msgArray[ind]}\\n"
+		else
+			oneLine="$(echo -e "${msgArray[ind]}" | sed -e 's/^[[:space:]]*//')"
+			
+			if [ ${#oneLine} -gt 0 ]; then
+				if [ "${oneLine:0:2}" == "* " ]; then oneLine=$(echo ${oneLine/\*/-}); fi
+				if [ "${oneLine:0:2}" != "- " ]; then releaseNotes+="- "; fi		
+				releaseNotes+="$oneLine\\n"
+			fi
+		fi
+		let ind=$ind+1
+	done
+else
+	releaseNotes="#### Release of $varTagName\\n"
+fi
+
+# - list of commits (commits.txt must exit in the output dir)
+commitFile=$varAssetsDir/commits.txt
+if [ -e "$commitFile" ]; then
+	
+	releaseNotes+="\\n##### Commits\\n"
+	
+	IFS=$'\n'
+	for next in `cat $commitFile`
+	do
+		IFS=' ' read -r commitId commitMsg <<< "$next"
+		releaseNotes+="- [$commitId](https://github.com/$varRepoSlug/commit/$commitId) $commitMsg\\n"
+	done
+	rm -f $commitFile
+fi
+
+releaseNotes=$(perl -pe 's/\r?\n/\\n/' <<< ${releaseNotes})
+
+#JSON parameters to create a new release
+curlData="{\"tag_name\": \"$varTagName\",\"target_commitish\": \"master\",\"name\": \"v$varTagName\",\"body\": \"$releaseNotes\",\"draft\": false,\"prerelease\": $varPrerelease}"
+
+#Create the release (initial source file assets created by GitHub)
+releaseId=$(curl --data "$curlData" https://api.github.com/repos/$varRepoSlug/releases?access_token=$varAccessToken | jq -r '.id')
+echo Release ID: $releaseId
+
+# Assets defined by dir contents
+if [ ! -z $varAssetsDir ]; then
+	varAssetsTemp=$(ls -p $varAssetsDir | grep -v / | tr '\n' ';')
+	for item in $(echo $varAssetsTemp | tr ";" "\n")
+	do	  
+	  varAssets+=$varAssetsDir/$item;
+	  varAssets+=';'
+	done	
+fi
+
+echo
+echo varAssets: $varAssets
+
+#Upload additional assets
+if [ ! -z $varAssets ]; then
+	curlAuth="Authorization: token $varAccessToken"
+	for filename in $(echo $varAssets | tr ";" "\n")
+	do
+	  echo
+	  echo
+	  echo Uploading $filename...
+	  
+	  curl -X POST -sH "$curlAuth" -H "Content-Type: application/octet-stream" --data-binary @"$filename" https://uploads.github.com/repos/$varRepoSlug/releases/$releaseId/assets?name=$(basename $filename)
+	done
+fi
+
+echo
+echo
+	
+

tools/gen_esp32part.py

@@ -4,7 +4,7 @@
 #
 # Converts partition tables to/from CSV and binary formats.
 #
-# See http://esp-idf.readthedocs.io/en/latest/api-guides/partition-tables.html
+# See https://docs.espressif.com/projects/esp-idf/en/latest/api-guides/partition-tables.html
 # for explanation of partition table structure and uses.
 #
 # Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
@@ -31,11 +31,38 @@ import binascii
 
 MAX_PARTITION_LENGTH = 0xC00   # 3K for partition data (96 entries) leaves 1K in a 4K sector for signature
 MD5_PARTITION_BEGIN = b"\xEB\xEB" + b"\xFF" * 14 # The first 2 bytes are like magic numbers for MD5 sum
+PARTITION_TABLE_SIZE  = 0x1000  # Size of partition table
 
-__version__ = '1.0'
+__version__ = '1.2'
+
+APP_TYPE = 0x00
+DATA_TYPE = 0x01
+
+TYPES = {
+    "app" : APP_TYPE,
+    "data" : DATA_TYPE,
+}
+
+# Keep this map in sync with esp_partition_subtype_t enum in esp_partition.h
+SUBTYPES = {
+    APP_TYPE : {
+        "factory" : 0x00,
+        "test" : 0x20,
+    },
+    DATA_TYPE : {
+        "ota" : 0x00,
+        "phy" : 0x01,
+        "nvs" : 0x02,
+        "coredump" : 0x03,
+        "esphttpd" : 0x80,
+        "fat" : 0x81,
+        "spiffs" : 0x82,
+    },
+}
 
 quiet = False
 md5sum = True
+offset_part_table = 0
 
 def status(msg):
     """ Print status message to stderr """
@@ -44,9 +71,8 @@ def status(msg):
 
 def critical(msg):
     """ Print critical message to stderr """
-    if not quiet:
-        sys.stderr.write(msg)
-        sys.stderr.write('\n')
+    sys.stderr.write(msg)
+    sys.stderr.write('\n')
 
 class PartitionTable(list):
     def __init__(self):
@@ -77,10 +103,13 @@ class PartitionTable(list):
                 raise
 
         # fix up missing offsets & negative sizes
-        last_end = 0x5000 # first offset after partition table
+        last_end = offset_part_table + PARTITION_TABLE_SIZE # first offset after partition table
         for e in res:
+            if offset_part_table != 0 and e.offset is not None and e.offset < last_end:
+                critical("WARNING: 0x%x address in the partition table is below 0x%x" % (e.offset, last_end))
+                e.offset = None
             if e.offset is None:
-                pad_to = 0x10000 if e.type == PartitionDefinition.APP_TYPE else 4
+                pad_to = 0x10000 if e.type == APP_TYPE else 4
                 if last_end % pad_to != 0:
                     last_end += pad_to - (last_end % pad_to)
                 e.offset = last_end
@@ -101,6 +130,36 @@ class PartitionTable(list):
         else:
             return super(PartitionTable, self).__getitem__(item)
 
+    def find_by_type(self, ptype, subtype):
+        """ Return a partition by type & subtype, returns
+        None if not found """
+        # convert ptype & subtypes names (if supplied this way) to integer values
+        try:
+            ptype = TYPES[ptype]
+        except KeyError:
+            try:
+                ptypes = int(ptype, 0)
+            except TypeError:
+                pass
+        try:
+            subtype = SUBTYPES[int(ptype)][subtype]
+        except KeyError:
+            try:
+                ptypes = int(ptype, 0)
+            except TypeError:
+                pass
+
+        for p in self:
+            if p.type == ptype and p.subtype == subtype:
+                return p
+        return None
+
+    def find_by_name(self, name):
+        for p in self:
+            if p.name == name:
+                return p
+        return None
+
     def verify(self):
         # verify each partition individually
         for p in self:
@@ -108,12 +167,22 @@ class PartitionTable(list):
         # check for overlaps
         last = None
         for p in sorted(self, key=lambda x:x.offset):
-            if p.offset < 0x5000:
-                raise InputError("Partition offset 0x%x is below 0x5000" % p.offset)
+            if p.offset < offset_part_table + PARTITION_TABLE_SIZE:
+                raise InputError("Partition offset 0x%x is below 0x%x" % (p.offset, offset_part_table + PARTITION_TABLE_SIZE))
             if last is not None and p.offset < last.offset + last.size:
                 raise InputError("Partition at 0x%x overlaps 0x%x-0x%x" % (p.offset, last.offset, last.offset+last.size-1))
             last = p
 
+    def flash_size(self):
+        """ Return the size that partitions will occupy in flash
+            (ie the offset the last partition ends at)
+        """
+        try:
+            last = sorted(self, reverse=True)[0]
+        except IndexError:
+            return 0  # empty table!
+        return last.offset + last.size
+
     @classmethod
     def from_binary(cls, b):
         md5 = hashlib.md5();
@@ -150,30 +219,6 @@ class PartitionTable(list):
         return "\n".join(rows) + "\n"
 
 class PartitionDefinition(object):
-    APP_TYPE = 0x00
-    DATA_TYPE = 0x01
-    TYPES = {
-        "app" : APP_TYPE,
-        "data" : DATA_TYPE,
-    }
-
-    # Keep this map in sync with esp_partition_subtype_t enum in esp_partition.h 
-    SUBTYPES = {
-        APP_TYPE : {
-            "factory" : 0x00,
-            "test" : 0x20,
-            },
-        DATA_TYPE : {
-            "ota" : 0x00,
-            "phy" : 0x01,
-            "nvs" : 0x02,
-            "coredump" : 0x03,
-            "esphttpd" : 0x80,
-            "fat" : 0x81,
-            "spiffs" : 0x82,
-            },
-    }
-
     MAGIC_BYTES = b"\xAA\x50"
 
     ALIGNMENT = {
@@ -187,7 +232,7 @@ class PartitionDefinition(object):
         "encrypted" : 0
     }
 
-    # add subtypes for the 16 OTA slot values ("ota_XXX, etc.")
+    # add subtypes for the 16 OTA slot values ("ota_XX, etc.")
     for ota_slot in range(16):
         SUBTYPES[TYPES["app"]]["ota_%d" % ota_slot] = 0x10 + ota_slot
 
@@ -240,15 +285,27 @@ class PartitionDefinition(object):
     def __cmp__(self, other):
         return self.offset - other.offset
 
+    def __lt__(self, other):
+        return self.offset < other.offset
+
+    def __gt__(self, other):
+        return self.offset > other.offset
+
+    def __le__(self, other):
+        return self.offset <= other.offset
+
+    def __ge__(self, other):
+        return self.offset >= other.offset
+
     def parse_type(self, strval):
         if strval == "":
             raise InputError("Field 'type' can't be left empty.")
-        return parse_int(strval, self.TYPES)
+        return parse_int(strval, TYPES)
 
     def parse_subtype(self, strval):
         if strval == "":
             return 0 # default
-        return parse_int(strval, self.SUBTYPES.get(self.type, {}))
+        return parse_int(strval, SUBTYPES.get(self.type, {}))
 
     def parse_address(self, strval):
         if strval == "":
@@ -268,6 +325,14 @@ class PartitionDefinition(object):
         if self.size is None:
             raise ValidationError(self, "Size field is not set")
 
+        if self.name in TYPES and TYPES.get(self.name, "") != self.type:
+            critical("WARNING: Partition has name '%s' which is a partition type, but does not match this partition's type (0x%x). Mistake in partition table?" % (self.name, self.type))
+        all_subtype_names = []
+        for names in (t.keys() for t in SUBTYPES.values()):
+            all_subtype_names += names
+        if self.name in all_subtype_names and SUBTYPES.get(self.type, {}).get(self.name, "") != self.subtype:
+            critical("WARNING: Partition has name '%s' which is a partition subtype, but this partition has non-matching type 0x%x and subtype 0x%x. Mistake in partition table?" % (self.name, self.type, self.subtype))
+
     STRUCT_FORMAT = "<2sBBLL16sL"
 
     @classmethod
@@ -321,8 +386,8 @@ class PartitionDefinition(object):
             return ":".join(self.get_flags_list())
 
         return ",".join([ self.name,
-                          lookup_keyword(self.type, self.TYPES),
-                          lookup_keyword(self.subtype, self.SUBTYPES.get(self.type, {})),
+                          lookup_keyword(self.type, TYPES),
+                          lookup_keyword(self.subtype, SUBTYPES.get(self.type, {})),
                           addr_format(self.offset, False),
                           addr_format(self.size, True),
                           generate_text_flags()])
@@ -348,21 +413,26 @@ def parse_int(v, keywords={}):
 def main():
     global quiet
     global md5sum
+    global offset_part_table
     parser = argparse.ArgumentParser(description='ESP32 partition table utility')
 
+    parser.add_argument('--flash-size', help='Optional flash size limit, checks partition table fits in flash',
+                        nargs='?', choices=[ '1MB', '2MB', '4MB', '8MB', '16MB' ])
     parser.add_argument('--disable-md5sum', help='Disable md5 checksum for the partition table', default=False, action='store_true')
-    parser.add_argument('--verify', '-v', help='Verify partition table fields', default=True, action='store_false')
-    parser.add_argument('--quiet', '-q', help="Don't print status messages to stderr", action='store_true')
-
-    parser.add_argument('input', help='Path to CSV or binary file to parse. Will use stdin if omitted.', type=argparse.FileType('rb'), default=sys.stdin)
-    parser.add_argument('output', help='Path to output converted binary or CSV file. Will use stdout if omitted, unless the --display argument is also passed (in which case only the summary is printed.)',
-                        nargs='?',
-                        default='-')
+    parser.add_argument('--no-verify', help="Don't verify partition table fields", action='store_true')
+    parser.add_argument('--verify', '-v', help="Verify partition table fields (deprecated, this behaviour is enabled by default and this flag does nothing.", action='store_true')
+    parser.add_argument('--quiet', '-q', help="Don't print non-critical status messages to stderr", action='store_true')
+    parser.add_argument('--offset', '-o', help='Set offset partition table', default='0x8000')
+    
+    parser.add_argument('input', help='Path to CSV or binary file to parse.', type=argparse.FileType('rb'))
+    parser.add_argument('output', help='Path to output converted binary or CSV file. Will use stdout if omitted.',
+                        nargs='?', default='-')
 
     args = parser.parse_args()
 
     quiet = args.quiet
     md5sum = not args.disable_md5sum
+    offset_part_table = int(args.offset, 0)
     input = args.input.read()
     input_is_binary = input[0:2] == PartitionDefinition.MAGIC_BYTES
     if input_is_binary:
@@ -373,17 +443,29 @@ def main():
         status("Parsing CSV input...")
         table = PartitionTable.from_csv(input)
 
-    if args.verify:
+    if not args.no_verify:
         status("Verifying table...")
         table.verify()
 
+    if args.flash_size:
+        size_mb = int(args.flash_size.replace("MB", ""))
+        size = size_mb * 1024 * 1024  # flash memory uses honest megabytes!
+        table_size = table.flash_size()
+        if size < table_size:
+            raise InputError("Partitions defined in '%s' occupy %.1fMB of flash (%d bytes) which does not fit in configured flash size %dMB. Change the flash size in menuconfig under the 'Serial Flasher Config' menu." %
+                             (args.input.name, table_size / 1024.0 / 1024.0, table_size, size_mb))
+
     if input_is_binary:
         output = table.to_csv()
         with sys.stdout if args.output == '-' else open(args.output, 'w') as f:
             f.write(output)
     else:
         output = table.to_binary()
-        with sys.stdout.buffer if args.output == '-' else open(args.output, 'wb') as f:
+        try:
+            stdout_binary = sys.stdout.buffer  # Python 3
+        except AttributeError:
+            stdout_binary = sys.stdout
+        with stdout_binary if args.output == '-' else open(args.output, 'wb') as f:
             f.write(output)
 
 

tools/platformio-build.py

@@ -56,6 +56,7 @@ env.Prepend(
     CPPPATH=[
         join(FRAMEWORK_DIR, "tools", "sdk", "include", "config"),
         join(FRAMEWORK_DIR, "tools", "sdk", "include", "bluedroid"),
+        join(FRAMEWORK_DIR, "tools", "sdk", "include", "bluedroid", "api"),
         join(FRAMEWORK_DIR, "tools", "sdk", "include", "app_trace"),
         join(FRAMEWORK_DIR, "tools", "sdk", "include", "app_update"),
         join(FRAMEWORK_DIR, "tools", "sdk", "include", "bootloader_support"),
@@ -63,6 +64,8 @@ env.Prepend(
         join(FRAMEWORK_DIR, "tools", "sdk", "include", "driver"),
         join(FRAMEWORK_DIR, "tools", "sdk", "include", "esp32"),
         join(FRAMEWORK_DIR, "tools", "sdk", "include", "esp_adc_cal"),
+        join(FRAMEWORK_DIR, "tools", "sdk", "include", "esp_http_client"),
+        join(FRAMEWORK_DIR, "tools", "sdk", "include", "esp-tls"),
         join(FRAMEWORK_DIR, "tools", "sdk", "include", "ethernet"),
         join(FRAMEWORK_DIR, "tools", "sdk", "include", "fatfs"),
         join(FRAMEWORK_DIR, "tools", "sdk", "include", "freertos"),
@@ -77,6 +80,7 @@ env.Prepend(
         join(FRAMEWORK_DIR, "tools", "sdk", "include", "openssl"),
         join(FRAMEWORK_DIR, "tools", "sdk", "include", "spi_flash"),
         join(FRAMEWORK_DIR, "tools", "sdk", "include", "sdmmc"),
+        join(FRAMEWORK_DIR, "tools", "sdk", "include", "smartconfig_ack"),
         join(FRAMEWORK_DIR, "tools", "sdk", "include", "spiffs"),
         join(FRAMEWORK_DIR, "tools", "sdk", "include", "tcpip_adapter"),
         join(FRAMEWORK_DIR, "tools", "sdk", "include", "ulp"),
@@ -99,7 +103,7 @@ env.Prepend(
         join(FRAMEWORK_DIR, "tools", "sdk", "ld")
     ],
     LIBS=[
-        "gcc", "openssl", "btdm_app", "fatfs", "wps", "coexist", "wear_levelling", "hal", "newlib", "driver", "bootloader_support", "pp", "mesh", "smartconfig", "jsmn", "wpa", "ethernet", "phy", "app_trace", "console", "ulp", "wpa_supplicant", "freertos", "bt", "micro-ecc", "cxx", "xtensa-debug-module", "mdns", "vfs", "soc", "core", "sdmmc", "coap", "tcpip_adapter", "c_nano", "rtc", "spi_flash", "wpa2", "esp32", "app_update", "nghttp", "spiffs", "espnow", "nvs_flash", "esp_adc_cal", "log", "expat", "m", "c", "heap", "mbedtls", "lwip", "net80211", "pthread", "json", "stdc++"
+        "gcc", "openssl", "btdm_app", "fatfs", "wps", "coexist", "wear_levelling", "esp_http_client", "hal", "newlib", "driver", "bootloader_support", "pp", "mesh", "smartconfig", "jsmn", "wpa", "ethernet", "phy", "app_trace", "console", "ulp", "wpa_supplicant", "freertos", "bt", "micro-ecc", "cxx", "xtensa-debug-module", "mdns", "vfs", "soc", "core", "sdmmc", "coap", "tcpip_adapter", "c_nano", "esp-tls", "rtc", "spi_flash", "wpa2", "esp32", "app_update", "nghttp", "spiffs", "espnow", "nvs_flash", "esp_adc_cal", "log", "smartconfig_ack", "expat", "m", "c", "heap", "mbedtls", "lwip", "net80211", "pthread", "json", "stdc++"
     ]
 )
 

tools/sdk/include/bluedroid/a2d_int.h

@@ -24,7 +24,7 @@
 #ifndef A2D_INT_H
 #define A2D_INT_H
 
-#include "a2d_api.h"
+#include "stack/a2d_api.h"
 #if (A2D_INCLUDED == TRUE)
 /*****************************************************************************
 **  Constants

tools/sdk/include/bluedroid/api/esp_bt_defs.h

@@ -48,9 +48,9 @@ typedef enum {
     ESP_BT_STATUS_UNACCEPT_CONN_INTERVAL,       /* relate to BT_UNACCEPT_CONN_INTERVAL in bt_def.h */
     ESP_BT_STATUS_PARAM_OUT_OF_RANGE,           /* relate to BT_PARAM_OUT_OF_RANGE in bt_def.h */
     ESP_BT_STATUS_TIMEOUT,                      /* relate to BT_STATUS_TIMEOUT in bt_def.h */
-    ESP_BT_STATUS_PEER_LE_DATA_LEN_UNSUPPORTED, /* relate to BTM_PEER_LE_DATA_LEN_UNSUPPORTED in btm_api.h */
-    ESP_BT_STATUS_CONTROL_LE_DATA_LEN_UNSUPPORTED,/* relate to BTM_CONTROL_LE_DATA_LEN_UNSUPPORTED in btm_api.h */
-    ESP_BT_STATUS_ERR_ILLEGAL_PARAMETER_FMT,    /* relate to HCI_ERR_ILLEGAL_PARAMETER_FMT in hcidefs.h */
+    ESP_BT_STATUS_PEER_LE_DATA_LEN_UNSUPPORTED, /* relate to BTM_PEER_LE_DATA_LEN_UNSUPPORTED in stack/btm_api.h */
+    ESP_BT_STATUS_CONTROL_LE_DATA_LEN_UNSUPPORTED,/* relate to BTM_CONTROL_LE_DATA_LEN_UNSUPPORTED in stack/btm_api.h */
+    ESP_BT_STATUS_ERR_ILLEGAL_PARAMETER_FMT,    /* relate to HCI_ERR_ILLEGAL_PARAMETER_FMT in stack/hcidefs.h */
     ESP_BT_STATUS_MEMORY_FULL,                  /* relate to BT_STATUS_MEMORY_FULL in bt_def.h */
 } esp_bt_status_t;
 
@@ -67,13 +67,13 @@ typedef uint8_t esp_link_key[ESP_BT_OCTET16_LEN];      /* Link Key */
 /// Default GATT interface id
 #define ESP_DEFAULT_GATT_IF             0xff
 
-#define ESP_BLE_CONN_INT_MIN                0x0006       /*!< relate to BTM_BLE_CONN_INT_MIN in btm_ble_api.h */
-#define ESP_BLE_CONN_INT_MAX                0x0C80       /*!< relate to BTM_BLE_CONN_INT_MAX in btm_ble_api.h */
-#define ESP_BLE_CONN_LATENCY_MAX            500          /*!< relate to ESP_BLE_CONN_LATENCY_MAX in btm_ble_api.h */
-#define ESP_BLE_CONN_SUP_TOUT_MIN           0x000A       /*!< relate to BTM_BLE_CONN_SUP_TOUT_MIN in btm_ble_api.h */
-#define ESP_BLE_CONN_SUP_TOUT_MAX           0x0C80       /*!< relate to ESP_BLE_CONN_SUP_TOUT_MAX in btm_ble_api.h */
-#define ESP_BLE_CONN_PARAM_UNDEF            0xffff       /* use this value when a specific value not to be overwritten */ /* relate to ESP_BLE_CONN_PARAM_UNDEF in btm_ble_api.h */
-#define ESP_BLE_SCAN_PARAM_UNDEF            0xffffffff   /* relate to ESP_BLE_SCAN_PARAM_UNDEF in btm_ble_api.h */
+#define ESP_BLE_CONN_INT_MIN                0x0006       /*!< relate to BTM_BLE_CONN_INT_MIN in stack/btm_ble_api.h */
+#define ESP_BLE_CONN_INT_MAX                0x0C80       /*!< relate to BTM_BLE_CONN_INT_MAX in stack/btm_ble_api.h */
+#define ESP_BLE_CONN_LATENCY_MAX            500          /*!< relate to ESP_BLE_CONN_LATENCY_MAX in stack/btm_ble_api.h */
+#define ESP_BLE_CONN_SUP_TOUT_MIN           0x000A       /*!< relate to BTM_BLE_CONN_SUP_TOUT_MIN in stack/btm_ble_api.h */
+#define ESP_BLE_CONN_SUP_TOUT_MAX           0x0C80       /*!< relate to ESP_BLE_CONN_SUP_TOUT_MAX in stack/btm_ble_api.h */
+#define ESP_BLE_CONN_PARAM_UNDEF            0xffff       /* use this value when a specific value not to be overwritten */ /* relate to ESP_BLE_CONN_PARAM_UNDEF in stack/btm_ble_api.h */
+#define ESP_BLE_SCAN_PARAM_UNDEF            0xffffffff   /* relate to ESP_BLE_SCAN_PARAM_UNDEF in stack/btm_ble_api.h */
 
 /// Check the param is valid or not
 #define ESP_BLE_IS_VALID_PARAM(x, min, max)  (((x) >= (min) && (x) <= (max)) || ((x) == ESP_BLE_CONN_PARAM_UNDEF))
@@ -113,13 +113,13 @@ typedef enum {
 } esp_ble_addr_type_t;
 
 /// Used to exchange the encrytyption key in the init key & response key
-#define ESP_BLE_ENC_KEY_MASK    (1 << 0)            /* relate to BTM_BLE_ENC_KEY_MASK in btm_api.h */
+#define ESP_BLE_ENC_KEY_MASK    (1 << 0)            /* relate to BTM_BLE_ENC_KEY_MASK in stack/btm_api.h */
 /// Used to exchange the IRK key in the init key & response key
-#define ESP_BLE_ID_KEY_MASK     (1 << 1)            /* relate to BTM_BLE_ID_KEY_MASK in btm_api.h */
+#define ESP_BLE_ID_KEY_MASK     (1 << 1)            /* relate to BTM_BLE_ID_KEY_MASK in stack/btm_api.h */
 /// Used to exchange the CSRK key in the init key & response key
-#define ESP_BLE_CSR_KEY_MASK    (1 << 2)            /* relate to BTM_BLE_CSR_KEY_MASK in btm_api.h */
+#define ESP_BLE_CSR_KEY_MASK    (1 << 2)            /* relate to BTM_BLE_CSR_KEY_MASK in stack/btm_api.h */
 /// Used to exchange the link key(this key just used in the BLE & BR/EDR coexist mode) in the init key & response key
-#define ESP_BLE_LINK_KEY_MASK   (1 << 3)            /* relate to BTM_BLE_LINK_KEY_MASK in btm_api.h */
+#define ESP_BLE_LINK_KEY_MASK   (1 << 3)            /* relate to BTM_BLE_LINK_KEY_MASK in stack/btm_api.h */
 typedef uint8_t esp_ble_key_mask_t;            /* the key mask type */
 
 /// Minimum of the application id

tools/sdk/include/bluedroid/api/esp_bt_device.h

@@ -27,22 +27,24 @@ extern "C" {
 /**
  *
  * @brief      Get bluetooth device address.  Must use after "esp_bluedroid_enable".
- * 
+ *
  * @return     bluetooth device address (six bytes), or NULL if bluetooth stack is not enabled
  */
 const uint8_t *esp_bt_dev_get_address(void);
 
 
 /**
- * @brief           Set bluetooth device name. This function should be called after esp_bluedroid_enable() 
- *                  completes successfully
+ * @brief           Set bluetooth device name. This function should be called after esp_bluedroid_enable()
+ *                  completes successfully.
+ *                  A BR/EDR/LE device type shall have a single Bluetooth device name which shall be
+ *                  identical irrespective of the physical channel used to perform the name discovery procedure.
  *
  * @param[in]       name : device name to be set
  *
  * @return
  *                  - ESP_OK : Succeed
  *                  - ESP_ERR_INVALID_ARG : if name is NULL pointer or empty, or string length out of limit
- *                  - ESP_INVALID_STATE : if bluetooth stack is not yet enabled
+ *                  - ESP_ERR_INVALID_STATE : if bluetooth stack is not yet enabled
  *                  - ESP_FAIL : others
  */
 esp_err_t esp_bt_dev_set_device_name(const char *name);

tools/sdk/include/bluedroid/api/esp_gap_ble_api.h

@@ -38,34 +38,94 @@ extern "C" {
  * @}
  */
 
-/* relate to BTM_LE_KEY_xxx in btm_api.h */
-#define ESP_LE_KEY_NONE                    0                                                                         /* relate to BTM_LE_KEY_NONE in btm_api.h */
-#define ESP_LE_KEY_PENC                    (1 << 0)   /*!< encryption key, encryption information of peer device */  /* relate to BTM_LE_KEY_PENC in btm_api.h */
-#define ESP_LE_KEY_PID                     (1 << 1)   /*!< identity key of the peer device */                        /* relate to BTM_LE_KEY_PID in btm_api.h */
-#define ESP_LE_KEY_PCSRK                   (1 << 2)   /*!< peer SRK */                                               /* relate to BTM_LE_KEY_PCSRK in btm_api.h */
-#define ESP_LE_KEY_PLK                     (1 << 3)   /*!< Link key*/                                                /* relate to BTM_LE_KEY_PLK in btm_api.h */
-#define ESP_LE_KEY_LLK                     (ESP_LE_KEY_PLK << 4)                                                     /* relate to BTM_LE_KEY_LLK in btm_api.h */
-#define ESP_LE_KEY_LENC                    (ESP_LE_KEY_PENC << 4)   /*!< master role security information:div */     /* relate to BTM_LE_KEY_LENC in btm_api.h */
-#define ESP_LE_KEY_LID                     (ESP_LE_KEY_PID << 4)    /*!< master device ID key */                     /* relate to BTM_LE_KEY_LID in btm_api.h */
-#define ESP_LE_KEY_LCSRK                   (ESP_LE_KEY_PCSRK << 4)  /*!< local CSRK has been deliver to peer */      /* relate to BTM_LE_KEY_LCSRK in btm_api.h */
+/* relate to BTM_LE_KEY_xxx in stack/btm_api.h */
+#define ESP_LE_KEY_NONE                    0                                                                         /* relate to BTM_LE_KEY_NONE in stack/btm_api.h */
+#define ESP_LE_KEY_PENC                    (1 << 0)   /*!< encryption key, encryption information of peer device */  /* relate to BTM_LE_KEY_PENC in stack/btm_api.h */
+#define ESP_LE_KEY_PID                     (1 << 1)   /*!< identity key of the peer device */                        /* relate to BTM_LE_KEY_PID in stack/btm_api.h */
+#define ESP_LE_KEY_PCSRK                   (1 << 2)   /*!< peer SRK */                                               /* relate to BTM_LE_KEY_PCSRK in stack/btm_api.h */
+#define ESP_LE_KEY_PLK                     (1 << 3)   /*!< Link key*/                                                /* relate to BTM_LE_KEY_PLK in stack/btm_api.h */
+#define ESP_LE_KEY_LLK                     (ESP_LE_KEY_PLK << 4)                                                     /* relate to BTM_LE_KEY_LLK in stack/btm_api.h */
+#define ESP_LE_KEY_LENC                    (ESP_LE_KEY_PENC << 4)   /*!< master role security information:div */     /* relate to BTM_LE_KEY_LENC in stack/btm_api.h */
+#define ESP_LE_KEY_LID                     (ESP_LE_KEY_PID << 4)    /*!< master device ID key */                     /* relate to BTM_LE_KEY_LID in stack/btm_api.h */
+#define ESP_LE_KEY_LCSRK                   (ESP_LE_KEY_PCSRK << 4)  /*!< local CSRK has been deliver to peer */      /* relate to BTM_LE_KEY_LCSRK in stack/btm_api.h */
 typedef uint8_t esp_ble_key_type_t;
 
-/* relate to BTM_LE_AUTH_xxx in btm_api.h */
-#define ESP_LE_AUTH_NO_BOND                 0x00                                     /*!< 0*/                     /* relate to BTM_LE_AUTH_NO_BOND in btm_api.h */
-#define ESP_LE_AUTH_BOND                    0x01                                     /*!< 1 << 0 */               /* relate to BTM_LE_AUTH_BOND in btm_api.h */
-#define ESP_LE_AUTH_REQ_MITM                (1 << 2)                                 /*!< 1 << 2 */               /* relate to BTM_LE_AUTH_REQ_MITM in btm_api.h */
-#define ESP_LE_AUTH_REQ_SC_ONLY             (1 << 3)                                 /*!< 1 << 3 */               /* relate to BTM_LE_AUTH_REQ_SC_ONLY in btm_api.h */
-#define ESP_LE_AUTH_REQ_SC_BOND             (ESP_LE_AUTH_BOND | ESP_LE_AUTH_REQ_SC_ONLY)            /*!< 1001 */  /* relate to BTM_LE_AUTH_REQ_SC_BOND in btm_api.h */
-#define ESP_LE_AUTH_REQ_SC_MITM             (ESP_LE_AUTH_REQ_MITM | ESP_LE_AUTH_REQ_SC_ONLY)        /*!< 1100 */  /* relate to BTM_LE_AUTH_REQ_SC_MITM in btm_api.h */
-#define ESP_LE_AUTH_REQ_SC_MITM_BOND        (ESP_LE_AUTH_REQ_MITM | ESP_LE_AUTH_REQ_SC_ONLY | ESP_LE_AUTH_BOND)   /*!< 1101 */  /* relate to BTM_LE_AUTH_REQ_SC_MITM_BOND in btm_api.h */
+/* relate to BTM_LE_AUTH_xxx in stack/btm_api.h */
+#define ESP_LE_AUTH_NO_BOND                 0x00                                     /*!< 0*/                     /* relate to BTM_LE_AUTH_NO_BOND in stack/btm_api.h */
+#define ESP_LE_AUTH_BOND                    0x01                                     /*!< 1 << 0 */               /* relate to BTM_LE_AUTH_BOND in stack/btm_api.h */
+#define ESP_LE_AUTH_REQ_MITM                (1 << 2)                                 /*!< 1 << 2 */               /* relate to BTM_LE_AUTH_REQ_MITM in stack/btm_api.h */
+#define ESP_LE_AUTH_REQ_SC_ONLY             (1 << 3)                                 /*!< 1 << 3 */               /* relate to BTM_LE_AUTH_REQ_SC_ONLY in stack/btm_api.h */
+#define ESP_LE_AUTH_REQ_SC_BOND             (ESP_LE_AUTH_BOND | ESP_LE_AUTH_REQ_SC_ONLY)            /*!< 1001 */  /* relate to BTM_LE_AUTH_REQ_SC_BOND in stack/btm_api.h */
+#define ESP_LE_AUTH_REQ_SC_MITM             (ESP_LE_AUTH_REQ_MITM | ESP_LE_AUTH_REQ_SC_ONLY)        /*!< 1100 */  /* relate to BTM_LE_AUTH_REQ_SC_MITM in stack/btm_api.h */
+#define ESP_LE_AUTH_REQ_SC_MITM_BOND        (ESP_LE_AUTH_REQ_MITM | ESP_LE_AUTH_REQ_SC_ONLY | ESP_LE_AUTH_BOND)   /*!< 1101 */  /* relate to BTM_LE_AUTH_REQ_SC_MITM_BOND in stack/btm_api.h */
 typedef uint8_t   esp_ble_auth_req_t;         /*!< combination of the above bit pattern */
 
-/* relate to BTM_IO_CAP_xxx in btm_api.h */
-#define ESP_IO_CAP_OUT                      0   /*!< DisplayOnly */         /* relate to BTM_IO_CAP_OUT in btm_api.h */
-#define ESP_IO_CAP_IO                       1   /*!< DisplayYesNo */        /* relate to BTM_IO_CAP_IO in btm_api.h */
-#define ESP_IO_CAP_IN                       2   /*!< KeyboardOnly */        /* relate to BTM_IO_CAP_IN in btm_api.h */
-#define ESP_IO_CAP_NONE                     3   /*!< NoInputNoOutput */     /* relate to BTM_IO_CAP_NONE in btm_api.h */
-#define ESP_IO_CAP_KBDISP                   4   /*!< Keyboard display */    /* relate to BTM_IO_CAP_KBDISP in btm_api.h */
+/* relate to BTM_IO_CAP_xxx in stack/btm_api.h */
+#define ESP_IO_CAP_OUT                      0   /*!< DisplayOnly */         /* relate to BTM_IO_CAP_OUT in stack/btm_api.h */
+#define ESP_IO_CAP_IO                       1   /*!< DisplayYesNo */        /* relate to BTM_IO_CAP_IO in stack/btm_api.h */
+#define ESP_IO_CAP_IN                       2   /*!< KeyboardOnly */        /* relate to BTM_IO_CAP_IN in stack/btm_api.h */
+#define ESP_IO_CAP_NONE                     3   /*!< NoInputNoOutput */     /* relate to BTM_IO_CAP_NONE in stack/btm_api.h */
+#define ESP_IO_CAP_KBDISP                   4   /*!< Keyboard display */    /* relate to BTM_IO_CAP_KBDISP in stack/btm_api.h */
+
+#define ESP_BLE_APPEARANCE_UNKNOWN                 0x0000 /* relate to BTM_BLE_APPEARANCE_UNKNOWN in stack/btm_ble_api.h */
+#define ESP_BLE_APPEARANCE_GENERIC_PHONE           0x0040 /* relate to BTM_BLE_APPEARANCE_GENERIC_PHONE in stack/btm_ble_api.h */
+#define ESP_BLE_APPEARANCE_GENERIC_COMPUTER        0x0080 /* relate to BTM_BLE_APPEARANCE_GENERIC_COMPUTER in stack/btm_ble_api.h */
+#define ESP_BLE_APPEARANCE_GENERIC_WATCH           0x00C0 /* relate to BTM_BLE_APPEARANCE_GENERIC_WATCH in stack/btm_ble_api.h */
+#define ESP_BLE_APPEARANCE_SPORTS_WATCH            0x00C1 /* relate to BTM_BLE_APPEARANCE_SPORTS_WATCH in stack/btm_ble_api.h */
+#define ESP_BLE_APPEARANCE_GENERIC_CLOCK           0x0100 /* relate to BTM_BLE_APPEARANCE_GENERIC_CLOCK in stack/btm_ble_api.h */
+#define ESP_BLE_APPEARANCE_GENERIC_DISPLAY         0x0140 /* relate to BTM_BLE_APPEARANCE_GENERIC_DISPLAY in stack/btm_ble_api.h */
+#define ESP_BLE_APPEARANCE_GENERIC_REMOTE          0x0180 /* relate to BTM_BLE_APPEARANCE_GENERIC_REMOTE in stack/btm_ble_api.h */
+#define ESP_BLE_APPEARANCE_GENERIC_EYEGLASSES      0x01C0 /* relate to BTM_BLE_APPEARANCE_GENERIC_EYEGLASSES in stack/btm_ble_api.h */
+#define ESP_BLE_APPEARANCE_GENERIC_TAG             0x0200 /* relate to BTM_BLE_APPEARANCE_GENERIC_TAG in stack/btm_ble_api.h */
+#define ESP_BLE_APPEARANCE_GENERIC_KEYRING         0x0240 /* relate to BTM_BLE_APPEARANCE_GENERIC_KEYRING in stack/btm_ble_api.h */
+#define ESP_BLE_APPEARANCE_GENERIC_MEDIA_PLAYER    0x0280 /* relate to BTM_BLE_APPEARANCE_GENERIC_MEDIA_PLAYER in stack/btm_ble_api.h */
+#define ESP_BLE_APPEARANCE_GENERIC_BARCODE_SCANNER 0x02C0 /* relate to BTM_BLE_APPEARANCE_GENERIC_BARCODE_SCANNER in stack/btm_ble_api.h */
+#define ESP_BLE_APPEARANCE_GENERIC_THERMOMETER     0x0300 /* relate to BTM_BLE_APPEARANCE_GENERIC_THERMOMETER in stack/btm_ble_api.h */
+#define ESP_BLE_APPEARANCE_THERMOMETER_EAR         0x0301 /* relate to BTM_BLE_APPEARANCE_THERMOMETER_EAR in stack/btm_ble_api.h */
+#define ESP_BLE_APPEARANCE_GENERIC_HEART_RATE      0x0340 /* relate to BTM_BLE_APPEARANCE_GENERIC_HEART_RATE in stack/btm_ble_api.h */
+#define ESP_BLE_APPEARANCE_HEART_RATE_BELT         0x0341 /* relate to BTM_BLE_APPEARANCE_HEART_RATE_BELT in stack/btm_ble_api.h */
+#define ESP_BLE_APPEARANCE_GENERIC_BLOOD_PRESSURE  0x0380 /* relate to BTM_BLE_APPEARANCE_GENERIC_BLOOD_PRESSURE in stack/btm_ble_api.h */
+#define ESP_BLE_APPEARANCE_BLOOD_PRESSURE_ARM      0x0381 /* relate to BTM_BLE_APPEARANCE_BLOOD_PRESSURE_ARM in stack/btm_ble_api.h */
+#define ESP_BLE_APPEARANCE_BLOOD_PRESSURE_WRIST    0x0382 /* relate to BTM_BLE_APPEARANCE_BLOOD_PRESSURE_WRIST in stack/btm_ble_api.h */
+#define ESP_BLE_APPEARANCE_GENERIC_HID             0x03C0 /* relate to BTM_BLE_APPEARANCE_GENERIC_HID in stack/btm_ble_api.h */
+#define ESP_BLE_APPEARANCE_HID_KEYBOARD            0x03C1 /* relate to BTM_BLE_APPEARANCE_HID_KEYBOARD in stack/btm_ble_api.h */
+#define ESP_BLE_APPEARANCE_HID_MOUSE               0x03C2 /* relate to BTM_BLE_APPEARANCE_HID_MOUSE in stack/btm_ble_api.h */
+#define ESP_BLE_APPEARANCE_HID_JOYSTICK            0x03C3 /* relate to BTM_BLE_APPEARANCE_HID_JOYSTICK in stack/btm_ble_api.h */
+#define ESP_BLE_APPEARANCE_HID_GAMEPAD             0x03C4 /* relate to BTM_BLE_APPEARANCE_HID_GAMEPAD in stack/btm_ble_api.h */
+#define ESP_BLE_APPEARANCE_HID_DIGITIZER_TABLET    0x03C5 /* relate to BTM_BLE_APPEARANCE_HID_DIGITIZER_TABLET in stack/btm_ble_api.h */
+#define ESP_BLE_APPEARANCE_HID_CARD_READER         0x03C6 /* relate to BTM_BLE_APPEARANCE_HID_CARD_READER in stack/btm_ble_api.h */
+#define ESP_BLE_APPEARANCE_HID_DIGITAL_PEN         0x03C7 /* relate to BTM_BLE_APPEARANCE_HID_DIGITAL_PEN in stack/btm_ble_api.h */
+#define ESP_BLE_APPEARANCE_HID_BARCODE_SCANNER     0x03C8 /* relate to BTM_BLE_APPEARANCE_HID_BARCODE_SCANNER in stack/btm_ble_api.h */
+#define ESP_BLE_APPEARANCE_GENERIC_GLUCOSE         0x0400 /* relate to BTM_BLE_APPEARANCE_GENERIC_GLUCOSE in stack/btm_ble_api.h */
+#define ESP_BLE_APPEARANCE_GENERIC_WALKING         0x0440 /* relate to BTM_BLE_APPEARANCE_GENERIC_WALKING in stack/btm_ble_api.h */
+#define ESP_BLE_APPEARANCE_WALKING_IN_SHOE         0x0441 /* relate to BTM_BLE_APPEARANCE_WALKING_IN_SHOE in stack/btm_ble_api.h */
+#define ESP_BLE_APPEARANCE_WALKING_ON_SHOE         0x0442 /* relate to BTM_BLE_APPEARANCE_WALKING_ON_SHOE in stack/btm_ble_api.h */
+#define ESP_BLE_APPEARANCE_WALKING_ON_HIP          0x0443 /* relate to BTM_BLE_APPEARANCE_WALKING_ON_HIP in stack/btm_ble_api.h */
+#define ESP_BLE_APPEARANCE_GENERIC_CYCLING         0x0480 /* relate to BTM_BLE_APPEARANCE_GENERIC_CYCLING in stack/btm_ble_api.h */
+#define ESP_BLE_APPEARANCE_CYCLING_COMPUTER        0x0481 /* relate to BTM_BLE_APPEARANCE_CYCLING_COMPUTER in stack/btm_ble_api.h */
+#define ESP_BLE_APPEARANCE_CYCLING_SPEED           0x0482 /* relate to BTM_BLE_APPEARANCE_CYCLING_SPEED in stack/btm_ble_api.h */
+#define ESP_BLE_APPEARANCE_CYCLING_CADENCE         0x0483 /* relate to BTM_BLE_APPEARANCE_CYCLING_CADENCE in stack/btm_ble_api.h */
+#define ESP_BLE_APPEARANCE_CYCLING_POWER           0x0484 /* relate to BTM_BLE_APPEARANCE_CYCLING_POWER in stack/btm_ble_api.h */
+#define ESP_BLE_APPEARANCE_CYCLING_SPEED_CADENCE   0x0485 /* relate to BTM_BLE_APPEARANCE_CYCLING_SPEED_CADENCE in stack/btm_ble_api.h */
+#define ESP_BLE_APPEARANCE_GENERIC_PULSE_OXIMETER  0x0C40 /* relate to BTM_BLE_APPEARANCE_GENERIC_PULSE_OXIMETER in stack/btm_ble_api.h */
+#define ESP_BLE_APPEARANCE_PULSE_OXIMETER_FINGERTIP 0x0C41 /* relate to BTM_BLE_APPEARANCE_PULSE_OXIMETER_FINGERTIP in stack/btm_ble_api.h */
+#define ESP_BLE_APPEARANCE_PULSE_OXIMETER_WRIST    0x0C42 /* relate to BTM_BLE_APPEARANCE_PULSE_OXIMETER_WRIST in stack/btm_ble_api.h */
+#define ESP_BLE_APPEARANCE_GENERIC_WEIGHT          0x0C80 /* relate to BTM_BLE_APPEARANCE_GENERIC_WEIGHT in stack/btm_ble_api.h */
+#define ESP_BLE_APPEARANCE_GENERIC_PERSONAL_MOBILITY_DEVICE    0x0CC0 /* relate to BTM_BLE_APPEARANCE_GENERIC_PERSONAL_MOBILITY_DEVICE in stack/btm_ble_api.h */
+#define ESP_BLE_APPEARANCE_POWERED_WHEELCHAIR                  0x0CC1 /* relate to BTM_BLE_APPEARANCE_POWERED_WHEELCHAIR in stack/btm_ble_api.h */
+#define ESP_BLE_APPEARANCE_MOBILITY_SCOOTER                    0x0CC2 /* relate to BTM_BLE_APPEARANCE_MOBILITY_SCOOTER in stack/btm_ble_api.h */
+#define ESP_BLE_APPEARANCE_GENERIC_CONTINUOUS_GLUCOSE_MONITOR  0x0D00 /* relate to BTM_BLE_APPEARANCE_GENERIC_CONTINUOUS_GLUCOSE_MONITOR in stack/btm_ble_api.h */
+#define ESP_BLE_APPEARANCE_GENERIC_INSULIN_PUMP                0x0D40 /* relate to BTM_BLE_APPEARANCE_GENERIC_INSULIN_PUMP in stack/btm_ble_api.h */
+#define ESP_BLE_APPEARANCE_INSULIN_PUMP_DURABLE_PUMP           0x0D41 /* relate to BTM_BLE_APPEARANCE_INSULIN_PUMP_DURABLE_PUMP in stack/btm_ble_api.h */
+#define ESP_BLE_APPEARANCE_INSULIN_PUMP_PATCH_PUMP             0x0D44 /* relate to BTM_BLE_APPEARANCE_INSULIN_PUMP_PATCH_PUMP in stack/btm_ble_api.h */
+#define ESP_BLE_APPEARANCE_INSULIN_PEN                         0x0D48 /* relate to BTM_BLE_APPEARANCE_INSULIN_PEN in stack/btm_ble_api.h */
+#define ESP_BLE_APPEARANCE_GENERIC_MEDICATION_DELIVERY         0x0D80 /* relate to BTM_BLE_APPEARANCE_GENERIC_MEDICATION_DELIVERY in stack/btm_ble_api.h */
+#define ESP_BLE_APPEARANCE_GENERIC_OUTDOOR_SPORTS  0x1440             /* relate to BTM_BLE_APPEARANCE_GENERIC_OUTDOOR_SPORTS in stack/btm_ble_api.h */
+#define ESP_BLE_APPEARANCE_OUTDOOR_SPORTS_LOCATION 0x1441             /* relate to BTM_BLE_APPEARANCE_OUTDOOR_SPORTS_LOCATION in stack/btm_ble_api.h */
+#define ESP_BLE_APPEARANCE_OUTDOOR_SPORTS_LOCATION_AND_NAV     0x1442 /* relate to BTM_BLE_APPEARANCE_OUTDOOR_SPORTS_LOCATION_AND_NAV in stack/btm_ble_api.h */
+#define ESP_BLE_APPEARANCE_OUTDOOR_SPORTS_LOCATION_POD         0x1443 /* relate to BTM_BLE_APPEARANCE_OUTDOOR_SPORTS_LOCATION_POD in stack/btm_ble_api.h */
+#define ESP_BLE_APPEARANCE_OUTDOOR_SPORTS_LOCATION_POD_AND_NAV 0x1444 /* relate to BTM_BLE_APPEARANCE_OUTDOOR_SPORTS_LOCATION_POD_AND_NAV in stack/btm_ble_api.h */
+
 typedef uint8_t esp_ble_io_cap_t;               /*!< combination of the io capability */
 
 /// GAP BLE callback event type
@@ -108,45 +168,45 @@ typedef enum {
 /// Scan response data maximum length
 #define ESP_BLE_SCAN_RSP_DATA_LEN_MAX          31
 
-/* relate to BTM_BLE_AD_TYPE_xxx in btm_ble_api.h */
+/* relate to BTM_BLE_AD_TYPE_xxx in stack/btm_ble_api.h */
 /// The type of advertising data(not adv_type)
 typedef enum {
-    ESP_BLE_AD_TYPE_FLAG                     = 0x01,    /* relate to BTM_BLE_AD_TYPE_FLAG in btm_ble_api.h */
-    ESP_BLE_AD_TYPE_16SRV_PART               = 0x02,    /* relate to BTM_BLE_AD_TYPE_16SRV_PART in btm_ble_api.h */
-    ESP_BLE_AD_TYPE_16SRV_CMPL               = 0x03,    /* relate to BTM_BLE_AD_TYPE_16SRV_CMPL in btm_ble_api.h */
-    ESP_BLE_AD_TYPE_32SRV_PART               = 0x04,    /* relate to BTM_BLE_AD_TYPE_32SRV_PART in btm_ble_api.h */
-    ESP_BLE_AD_TYPE_32SRV_CMPL               = 0x05,    /* relate to BTM_BLE_AD_TYPE_32SRV_CMPL in btm_ble_api.h */
-    ESP_BLE_AD_TYPE_128SRV_PART              = 0x06,    /* relate to BTM_BLE_AD_TYPE_128SRV_PART in btm_ble_api.h */
-    ESP_BLE_AD_TYPE_128SRV_CMPL              = 0x07,    /* relate to BTM_BLE_AD_TYPE_128SRV_CMPL in btm_ble_api.h */
-    ESP_BLE_AD_TYPE_NAME_SHORT               = 0x08,    /* relate to BTM_BLE_AD_TYPE_NAME_SHORT in btm_ble_api.h */
-    ESP_BLE_AD_TYPE_NAME_CMPL                = 0x09,    /* relate to BTM_BLE_AD_TYPE_NAME_CMPL in btm_ble_api.h */
-    ESP_BLE_AD_TYPE_TX_PWR                   = 0x0A,    /* relate to BTM_BLE_AD_TYPE_TX_PWR in btm_ble_api.h */
-    ESP_BLE_AD_TYPE_DEV_CLASS                = 0x0D,    /* relate to BTM_BLE_AD_TYPE_DEV_CLASS in btm_ble_api.h */
-    ESP_BLE_AD_TYPE_SM_TK                    = 0x10,    /* relate to BTM_BLE_AD_TYPE_SM_TK in btm_ble_api.h */
-    ESP_BLE_AD_TYPE_SM_OOB_FLAG              = 0x11,    /* relate to BTM_BLE_AD_TYPE_SM_OOB_FLAG in btm_ble_api.h */
-    ESP_BLE_AD_TYPE_INT_RANGE                = 0x12,    /* relate to BTM_BLE_AD_TYPE_INT_RANGE in btm_ble_api.h */
-    ESP_BLE_AD_TYPE_SOL_SRV_UUID             = 0x14,    /* relate to BTM_BLE_AD_TYPE_SOL_SRV_UUID in btm_ble_api.h */
-    ESP_BLE_AD_TYPE_128SOL_SRV_UUID          = 0x15,    /* relate to BTM_BLE_AD_TYPE_128SOL_SRV_UUID in btm_ble_api.h */
-    ESP_BLE_AD_TYPE_SERVICE_DATA             = 0x16,    /* relate to BTM_BLE_AD_TYPE_SERVICE_DATA in btm_ble_api.h */
-    ESP_BLE_AD_TYPE_PUBLIC_TARGET            = 0x17,    /* relate to BTM_BLE_AD_TYPE_PUBLIC_TARGET in btm_ble_api.h */
-    ESP_BLE_AD_TYPE_RANDOM_TARGET            = 0x18,    /* relate to BTM_BLE_AD_TYPE_RANDOM_TARGET in btm_ble_api.h */
-    ESP_BLE_AD_TYPE_APPEARANCE               = 0x19,    /* relate to BTM_BLE_AD_TYPE_APPEARANCE in btm_ble_api.h */
-    ESP_BLE_AD_TYPE_ADV_INT                  = 0x1A,    /* relate to BTM_BLE_AD_TYPE_ADV_INT in btm_ble_api.h */
-    ESP_BLE_AD_TYPE_LE_DEV_ADDR              = 0x1b,    /* relate to BTM_BLE_AD_TYPE_LE_DEV_ADDR in btm_ble_api.h */
-    ESP_BLE_AD_TYPE_LE_ROLE                  = 0x1c,    /* relate to BTM_BLE_AD_TYPE_LE_ROLE in btm_ble_api.h */
-    ESP_BLE_AD_TYPE_SPAIR_C256               = 0x1d,    /* relate to BTM_BLE_AD_TYPE_SPAIR_C256 in btm_ble_api.h */
-    ESP_BLE_AD_TYPE_SPAIR_R256               = 0x1e,    /* relate to BTM_BLE_AD_TYPE_SPAIR_R256 in btm_ble_api.h */
-    ESP_BLE_AD_TYPE_32SOL_SRV_UUID           = 0x1f,    /* relate to BTM_BLE_AD_TYPE_32SOL_SRV_UUID in btm_ble_api.h */
-    ESP_BLE_AD_TYPE_32SERVICE_DATA           = 0x20,    /* relate to BTM_BLE_AD_TYPE_32SERVICE_DATA in btm_ble_api.h */
-    ESP_BLE_AD_TYPE_128SERVICE_DATA          = 0x21,    /* relate to BTM_BLE_AD_TYPE_128SERVICE_DATA in btm_ble_api.h */
-    ESP_BLE_AD_TYPE_LE_SECURE_CONFIRM        = 0x22,    /* relate to BTM_BLE_AD_TYPE_LE_SECURE_CONFIRM in btm_ble_api.h */
-    ESP_BLE_AD_TYPE_LE_SECURE_RANDOM         = 0x23,    /* relate to BTM_BLE_AD_TYPE_LE_SECURE_RANDOM in btm_ble_api.h */
-    ESP_BLE_AD_TYPE_URI                      = 0x24,    /* relate to BTM_BLE_AD_TYPE_URI in btm_ble_api.h */
-    ESP_BLE_AD_TYPE_INDOOR_POSITION          = 0x25,    /* relate to BTM_BLE_AD_TYPE_INDOOR_POSITION in btm_ble_api.h */
-    ESP_BLE_AD_TYPE_TRANS_DISC_DATA          = 0x26,    /* relate to BTM_BLE_AD_TYPE_TRANS_DISC_DATA in btm_ble_api.h */
-    ESP_BLE_AD_TYPE_LE_SUPPORT_FEATURE       = 0x27,    /* relate to BTM_BLE_AD_TYPE_LE_SUPPORT_FEATURE in btm_ble_api.h */
-    ESP_BLE_AD_TYPE_CHAN_MAP_UPDATE          = 0x28,    /* relate to BTM_BLE_AD_TYPE_CHAN_MAP_UPDATE in btm_ble_api.h */
-    ESP_BLE_AD_MANUFACTURER_SPECIFIC_TYPE    = 0xFF,    /* relate to BTM_BLE_AD_MANUFACTURER_SPECIFIC_TYPE in btm_ble_api.h */
+    ESP_BLE_AD_TYPE_FLAG                     = 0x01,    /* relate to BTM_BLE_AD_TYPE_FLAG in stack/btm_ble_api.h */
+    ESP_BLE_AD_TYPE_16SRV_PART               = 0x02,    /* relate to BTM_BLE_AD_TYPE_16SRV_PART in stack/btm_ble_api.h */
+    ESP_BLE_AD_TYPE_16SRV_CMPL               = 0x03,    /* relate to BTM_BLE_AD_TYPE_16SRV_CMPL in stack/btm_ble_api.h */
+    ESP_BLE_AD_TYPE_32SRV_PART               = 0x04,    /* relate to BTM_BLE_AD_TYPE_32SRV_PART in stack/btm_ble_api.h */
+    ESP_BLE_AD_TYPE_32SRV_CMPL               = 0x05,    /* relate to BTM_BLE_AD_TYPE_32SRV_CMPL in stack/btm_ble_api.h */
+    ESP_BLE_AD_TYPE_128SRV_PART              = 0x06,    /* relate to BTM_BLE_AD_TYPE_128SRV_PART in stack/btm_ble_api.h */
+    ESP_BLE_AD_TYPE_128SRV_CMPL              = 0x07,    /* relate to BTM_BLE_AD_TYPE_128SRV_CMPL in stack/btm_ble_api.h */
+    ESP_BLE_AD_TYPE_NAME_SHORT               = 0x08,    /* relate to BTM_BLE_AD_TYPE_NAME_SHORT in stack/btm_ble_api.h */
+    ESP_BLE_AD_TYPE_NAME_CMPL                = 0x09,    /* relate to BTM_BLE_AD_TYPE_NAME_CMPL in stack/btm_ble_api.h */
+    ESP_BLE_AD_TYPE_TX_PWR                   = 0x0A,    /* relate to BTM_BLE_AD_TYPE_TX_PWR in stack/btm_ble_api.h */
+    ESP_BLE_AD_TYPE_DEV_CLASS                = 0x0D,    /* relate to BTM_BLE_AD_TYPE_DEV_CLASS in stack/btm_ble_api.h */
+    ESP_BLE_AD_TYPE_SM_TK                    = 0x10,    /* relate to BTM_BLE_AD_TYPE_SM_TK in stack/btm_ble_api.h */
+    ESP_BLE_AD_TYPE_SM_OOB_FLAG              = 0x11,    /* relate to BTM_BLE_AD_TYPE_SM_OOB_FLAG in stack/btm_ble_api.h */
+    ESP_BLE_AD_TYPE_INT_RANGE                = 0x12,    /* relate to BTM_BLE_AD_TYPE_INT_RANGE in stack/btm_ble_api.h */
+    ESP_BLE_AD_TYPE_SOL_SRV_UUID             = 0x14,    /* relate to BTM_BLE_AD_TYPE_SOL_SRV_UUID in stack/btm_ble_api.h */
+    ESP_BLE_AD_TYPE_128SOL_SRV_UUID          = 0x15,    /* relate to BTM_BLE_AD_TYPE_128SOL_SRV_UUID in stack/btm_ble_api.h */
+    ESP_BLE_AD_TYPE_SERVICE_DATA             = 0x16,    /* relate to BTM_BLE_AD_TYPE_SERVICE_DATA in stack/btm_ble_api.h */
+    ESP_BLE_AD_TYPE_PUBLIC_TARGET            = 0x17,    /* relate to BTM_BLE_AD_TYPE_PUBLIC_TARGET in stack/btm_ble_api.h */
+    ESP_BLE_AD_TYPE_RANDOM_TARGET            = 0x18,    /* relate to BTM_BLE_AD_TYPE_RANDOM_TARGET in stack/btm_ble_api.h */
+    ESP_BLE_AD_TYPE_APPEARANCE               = 0x19,    /* relate to BTM_BLE_AD_TYPE_APPEARANCE in stack/btm_ble_api.h */
+    ESP_BLE_AD_TYPE_ADV_INT                  = 0x1A,    /* relate to BTM_BLE_AD_TYPE_ADV_INT in stack/btm_ble_api.h */
+    ESP_BLE_AD_TYPE_LE_DEV_ADDR              = 0x1b,    /* relate to BTM_BLE_AD_TYPE_LE_DEV_ADDR in stack/btm_ble_api.h */
+    ESP_BLE_AD_TYPE_LE_ROLE                  = 0x1c,    /* relate to BTM_BLE_AD_TYPE_LE_ROLE in stack/btm_ble_api.h */
+    ESP_BLE_AD_TYPE_SPAIR_C256               = 0x1d,    /* relate to BTM_BLE_AD_TYPE_SPAIR_C256 in stack/btm_ble_api.h */
+    ESP_BLE_AD_TYPE_SPAIR_R256               = 0x1e,    /* relate to BTM_BLE_AD_TYPE_SPAIR_R256 in stack/btm_ble_api.h */
+    ESP_BLE_AD_TYPE_32SOL_SRV_UUID           = 0x1f,    /* relate to BTM_BLE_AD_TYPE_32SOL_SRV_UUID in stack/btm_ble_api.h */
+    ESP_BLE_AD_TYPE_32SERVICE_DATA           = 0x20,    /* relate to BTM_BLE_AD_TYPE_32SERVICE_DATA in stack/btm_ble_api.h */
+    ESP_BLE_AD_TYPE_128SERVICE_DATA          = 0x21,    /* relate to BTM_BLE_AD_TYPE_128SERVICE_DATA in stack/btm_ble_api.h */
+    ESP_BLE_AD_TYPE_LE_SECURE_CONFIRM        = 0x22,    /* relate to BTM_BLE_AD_TYPE_LE_SECURE_CONFIRM in stack/btm_ble_api.h */
+    ESP_BLE_AD_TYPE_LE_SECURE_RANDOM         = 0x23,    /* relate to BTM_BLE_AD_TYPE_LE_SECURE_RANDOM in stack/btm_ble_api.h */
+    ESP_BLE_AD_TYPE_URI                      = 0x24,    /* relate to BTM_BLE_AD_TYPE_URI in stack/btm_ble_api.h */
+    ESP_BLE_AD_TYPE_INDOOR_POSITION          = 0x25,    /* relate to BTM_BLE_AD_TYPE_INDOOR_POSITION in stack/btm_ble_api.h */
+    ESP_BLE_AD_TYPE_TRANS_DISC_DATA          = 0x26,    /* relate to BTM_BLE_AD_TYPE_TRANS_DISC_DATA in stack/btm_ble_api.h */
+    ESP_BLE_AD_TYPE_LE_SUPPORT_FEATURE       = 0x27,    /* relate to BTM_BLE_AD_TYPE_LE_SUPPORT_FEATURE in stack/btm_ble_api.h */
+    ESP_BLE_AD_TYPE_CHAN_MAP_UPDATE          = 0x28,    /* relate to BTM_BLE_AD_TYPE_CHAN_MAP_UPDATE in stack/btm_ble_api.h */
+    ESP_BLE_AD_MANUFACTURER_SPECIFIC_TYPE    = 0xFF,    /* relate to BTM_BLE_AD_MANUFACTURER_SPECIFIC_TYPE in stack/btm_ble_api.h */
 } esp_ble_adv_data_type;
 
 /// Advertising mode
@@ -179,18 +239,18 @@ typedef enum {
 } esp_ble_adv_filter_t;
 
 
-/* relate to BTA_DM_BLE_SEC_xxx in bta_api.h */
+/* relate to BTA_DM_BLE_SEC_xxx in bta/bta_api.h */
 typedef enum {
-    ESP_BLE_SEC_ENCRYPT = 1,            /* relate to BTA_DM_BLE_SEC_ENCRYPT in bta_api.h. If the device has already
+    ESP_BLE_SEC_ENCRYPT = 1,            /* relate to BTA_DM_BLE_SEC_ENCRYPT in bta/bta_api.h. If the device has already
                                            bonded, the stack will used LTK to encrypt with the remote device directly.
                                            Else if the device hasn't bonded, the stack will used the default authentication request
                                            used the esp_ble_gap_set_security_param function set by the user. */
-    ESP_BLE_SEC_ENCRYPT_NO_MITM,        /* relate to BTA_DM_BLE_SEC_ENCRYPT_NO_MITM in bta_api.h. If the device has already
+    ESP_BLE_SEC_ENCRYPT_NO_MITM,        /* relate to BTA_DM_BLE_SEC_ENCRYPT_NO_MITM in bta/bta_api.h. If the device has already
                                            bonded, the stack will check the LTK Whether the authentication request has been met, if met, used the LTK
                                            to encrypt with the remote device directly, else Re-pair with the remote device.
                                            Else if the device hasn't bonded, the stack will used NO MITM authentication request in the current link instead of
                                            used the authreq in the esp_ble_gap_set_security_param function set by the user. */
-    ESP_BLE_SEC_ENCRYPT_MITM,           /* relate to BTA_DM_BLE_SEC_ENCRYPT_MITM in bta_api.h. If the device has already
+    ESP_BLE_SEC_ENCRYPT_MITM,           /* relate to BTA_DM_BLE_SEC_ENCRYPT_MITM in bta/bta_api.h. If the device has already
                                            bonded, the stack will check the LTK Whether the authentication request has been met, if met, used the LTK
                                            to encrypt with the remote device directly, else Re-pair with the remote device.
                                            Else if the device hasn't bonded, the stack will used MITM authentication request in the current link instead of
@@ -264,6 +324,13 @@ typedef enum {
                                                   3. directed advertising packets addressed to this device.*/
 } esp_ble_scan_filter_t;
 
+/// Ble scan duplicate type
+typedef enum {
+    BLE_SCAN_DUPLICATE_DISABLE           = 0x0,  /*!< the Link Layer should generate advertising reports to the host for each packet received */
+    BLE_SCAN_DUPLICATE_ENABLE            = 0x1,  /*!< the Link Layer should filter out duplicate advertising reports to the Host */
+    BLE_SCAN_DUPLICATE_MAX               = 0x2,  /*!< 0x02 – 0xFF, Reserved for future use */
+} esp_ble_scan_duplicate_t;
+
 /// Ble scan parameters
 typedef struct {
     esp_ble_scan_type_t     scan_type;              /*!< Scan type */
@@ -279,6 +346,9 @@ typedef struct {
                                                       Range: 0x0004 to 0x4000 Default: 0x0010 (10 ms)
                                                       Time = N * 0.625 msec
                                                       Time Range: 2.5 msec to 10240 msec */
+    esp_ble_scan_duplicate_t  scan_duplicate;       /*!< The Scan_Duplicates parameter controls whether the Link Layer should filter out 
+                                                        duplicate advertising reports (BLE_SCAN_DUPLICATE_ENABLE) to the Host, or if the Link Layer should generate 
+                                                        advertising reports for each packet received */
 } esp_ble_scan_params_t;
 
 /// Connection update parameters
@@ -775,6 +845,20 @@ esp_err_t esp_ble_gap_set_rand_addr(esp_bd_addr_t rand_addr);
  */
 esp_err_t esp_ble_gap_config_local_privacy (bool privacy_enable);
 
+/**
+ * @brief           set local gap appearance icon
+ *
+ *
+ * @param[in]       icon   - External appearance value, these values are defined by the Bluetooth SIG, please refer to
+ *                  https://www.bluetooth.com/specifications/gatt/viewer?attributeXmlFile=org.bluetooth.characteristic.gap.appearance.xml
+ *
+ * @return
+ *                  - ESP_OK : success
+ *                  - other  : failed
+ *
+ */
+esp_err_t esp_ble_gap_config_local_icon (uint16_t icon);
+
 /**
 * @brief            Add or remove device from white list
 *
@@ -982,7 +1066,7 @@ esp_err_t esp_ble_remove_bond_device(esp_bd_addr_t bd_addr);
 *                  It will return the device bonded number immediately.
 *
 * @return          - >= 0 : bonded devices number.
-*                  - < 0  : failed
+*                  - ESP_FAIL  : failed
 *
 */
 int esp_ble_get_bond_device_num(void);

tools/sdk/include/bluedroid/api/esp_gap_bt_api.h

@@ -23,6 +23,27 @@
 extern "C" {
 #endif
 
+/// RSSI threshold
+#define ESP_BT_GAP_RSSI_HIGH_THRLD  -20             /*!< High RSSI threshold */
+#define ESP_BT_GAP_RSSI_LOW_THRLD   -45             /*!< Low RSSI threshold */
+
+/// Class of device
+typedef struct {
+    uint32_t      reserved_2: 2;                    /*!< undefined */
+    uint32_t      minor: 6;                         /*!< minor class */
+    uint32_t      major: 5;                         /*!< major class */
+    uint32_t      service: 11;                      /*!< service class */
+    uint32_t      reserved_8: 8;                    /*!< undefined */
+} esp_bt_cod_t;
+
+/// class of device settings
+typedef enum {
+    ESP_BT_SET_COD_MAJOR_MINOR     = 0x01,          /*!< overwrite major, minor class */
+    ESP_BT_SET_COD_SERVICE_CLASS   = 0x02,          /*!< set the bits in the input, the current bit will remain */
+    ESP_BT_CLR_COD_SERVICE_CLASS   = 0x04,          /*!< clear the bits in the input, others will remain */
+    ESP_BT_SET_COD_ALL             = 0x08,          /*!< overwrite major, minor, set the bits in service class */
+    ESP_BT_INIT_COD                = 0x0a,          /*!< overwrite major, minor, and service class */
+} esp_bt_cod_mode_t;
 
 /// Discoverability and Connectability mode
 typedef enum {
@@ -127,12 +148,15 @@ typedef enum {
     ESP_BT_GAP_DISC_STATE_CHANGED_EVT,              /*!< discovery state changed event */
     ESP_BT_GAP_RMT_SRVCS_EVT,                       /*!< get remote services event */
     ESP_BT_GAP_RMT_SRVC_REC_EVT,                    /*!< get remote service record event */
+    ESP_BT_GAP_AUTH_CMPL_EVT,                       /*!< AUTH complete event */
+    ESP_BT_GAP_READ_RSSI_DELTA_EVT,                 /*!< read rssi event */
+    ESP_BT_GAP_EVT_MAX,
 } esp_bt_gap_cb_event_t;
 
 /** Inquiry Mode */
 typedef enum {
     ESP_BT_INQ_MODE_GENERAL_INQUIRY,                /*!< General inquiry mode */
-    ESP_BT_INQ_MODE_LIMITED_INQIURY,                /*!< Limited inquiry mode */
+    ESP_BT_INQ_MODE_LIMITED_INQUIRY,                /*!< Limited inquiry mode */
 } esp_bt_inq_mode_t;
 
 /** Minimum and Maximum inquiry length*/
@@ -174,6 +198,24 @@ typedef union {
         esp_bd_addr_t bda;                     /*!< remote bluetooth device address*/
         esp_bt_status_t stat;                  /*!< service search status */
     } rmt_srvc_rec;                            /*!< specific service record from remote device parameter struct */
+
+    /**
+     * @brief ESP_BT_GAP_READ_RSSI_DELTA_EVT *
+     */
+    struct read_rssi_delta_param {
+        esp_bd_addr_t bda;                     /*!< remote bluetooth device address*/
+        esp_bt_status_t stat;                  /*!< read rssi status */
+        int8_t rssi_delta;                     /*!< rssi delta value range -128 ~127, The value zero indicates that the RSSI is inside the Golden Receive Power Range, the Golden Receive Power Range is from ESP_BT_GAP_RSSI_LOW_THRLD to ESP_BT_GAP_RSSI_HIGH_THRLD */
+    } read_rssi_delta;                         /*!< read rssi parameter struct */
+
+    /**
+     * @brief ESP_BT_GAP_AUTH_CMPL_EVT
+     */
+    struct auth_cmpl_param {
+        esp_bd_addr_t bda;                     /*!< remote bluetooth device address*/
+        esp_bt_status_t stat;                  /*!< authentication complete status */
+        uint8_t device_name[ESP_BT_GAP_MAX_BDNAME_LEN + 1]; /*!< device name */
+    } auth_cmpl;                               /*!< authentication complete parameter struct */
 } esp_bt_gap_cb_param_t;
 
 /**
@@ -258,7 +300,7 @@ esp_err_t esp_bt_gap_register_callback(esp_bt_gap_cb_t callback);
  * @return
  *                  - ESP_OK : Succeed
  *                  - ESP_ERR_INVALID_ARG: if argument invalid
- *                  - ESP_INVALID_STATE: if bluetooth stack is not yet enabled
+ *                  - ESP_ERR_INVALID_STATE: if bluetooth stack is not yet enabled
  *                  - ESP_FAIL: others
  */
 esp_err_t esp_bt_gap_set_scan_mode(esp_bt_scan_mode_t mode);
@@ -274,7 +316,7 @@ esp_err_t esp_bt_gap_set_scan_mode(esp_bt_scan_mode_t mode);
  *
  * @return
  *                  - ESP_OK : Succeed
- *                  - ESP_INVALID_STATE: if bluetooth stack is not yet enabled
+ *                  - ESP_ERR_INVALID_STATE: if bluetooth stack is not yet enabled
  *                  - ESP_ERR_INVALID_ARG: if invalid parameters are provided
  *                  - ESP_FAIL: others
  */
@@ -286,7 +328,7 @@ esp_err_t esp_bt_gap_start_discovery(esp_bt_inq_mode_t mode, uint8_t inq_len, ui
  *
  * @return
  *                  - ESP_OK : Succeed
- *                  - ESP_INVALID_STATE: if bluetooth stack is not yet enabled
+ *                  - ESP_ERR_INVALID_STATE: if bluetooth stack is not yet enabled
  *                  - ESP_FAIL: others
  */
 esp_err_t esp_bt_gap_cancel_discovery(void);
@@ -297,7 +339,7 @@ esp_err_t esp_bt_gap_cancel_discovery(void);
  *
  * @return
  *                  - ESP_OK : Succeed
- *                  - ESP_INVALID_STATE: if bluetooth stack is not yet enabled
+ *                  - ESP_ERR_INVALID_STATE: if bluetooth stack is not yet enabled
  *                  - ESP_FAIL: others
  */
 esp_err_t esp_bt_gap_get_remote_services(esp_bd_addr_t remote_bda);
@@ -309,7 +351,7 @@ esp_err_t esp_bt_gap_get_remote_services(esp_bd_addr_t remote_bda);
  *                  esp_bt_gap_cb_t will is called with ESP_BT_GAP_RMT_SRVC_REC_EVT after service discovery ends
  * @return
  *                  - ESP_OK : Succeed
- *                  - ESP_INVALID_STATE: if bluetooth stack is not yet enabled
+ *                  - ESP_ERR_INVALID_STATE: if bluetooth stack is not yet enabled
  *                  - ESP_FAIL: others
  */
 esp_err_t esp_bt_gap_get_remote_service_record(esp_bd_addr_t remote_bda, esp_bt_uuid_t *uuid);
@@ -326,6 +368,85 @@ esp_err_t esp_bt_gap_get_remote_service_record(esp_bd_addr_t remote_bda, esp_bt_
  */
 uint8_t *esp_bt_gap_resolve_eir_data(uint8_t *eir, esp_bt_eir_type_t type, uint8_t *length);
 
+/**
+ * @brief           This function is called to set class of device.
+ *                  esp_bt_gap_cb_t will is called with ESP_BT_GAP_SET_COD_EVT after set COD ends
+ *                  Some profile have special restrictions on class of device,
+ *                  changes may cause these profile do not work
+ *
+ * @param[in]       cod - class of device
+ * @param[in]       mode   - setting mode
+ *
+ * @return
+ *                  - ESP_OK : Succeed
+ *                  - ESP_ERR_INVALID_STATE: if bluetooth stack is not yet enabled
+ *                  - ESP_ERR_INVALID_ARG: if param is invalid
+ *                  - ESP_FAIL: others
+ */
+esp_err_t esp_bt_gap_set_cod(esp_bt_cod_t cod, esp_bt_cod_mode_t mode);
+
+/**
+ * @brief           This function is called to get class of device.
+ *
+ * @param[out]      cod - class of device
+ *
+ * @return
+ *                  - ESP_OK : Succeed
+ *                  - ESP_FAIL: others
+ */
+esp_err_t esp_bt_gap_get_cod(esp_bt_cod_t *cod);
+
+/**
+ * @brief           This function is called to read RSSI delta by address after connected. The RSSI value returned by ESP_BT_GAP_READ_RSSI_DELTA_EVT.
+ *
+ *
+ * @param[in]       remote_addr - remote device address, corresponding to a certain connection handle.
+ * @return
+ *                  - ESP_OK : Succeed
+ *                  - ESP_FAIL: others
+ *
+ */
+esp_err_t esp_bt_gap_read_rssi_delta(esp_bd_addr_t remote_addr);
+
+/**
+* @brief           Removes a device from the security database list of
+*                  peer device.
+*
+* @param[in]       bd_addr : BD address of the peer device
+*
+* @return          - ESP_OK : success
+*                  - ESP_FAIL  : failed
+*
+*/
+esp_err_t esp_bt_gap_remove_bond_device(esp_bd_addr_t bd_addr);
+
+/**
+* @brief           Get the device number from the security database list of peer device.
+*                  It will return the device bonded number immediately.
+*
+* @return          - >= 0 : bonded devices number.
+*                  - ESP_FAIL  : failed
+*
+*/
+int esp_bt_gap_get_bond_device_num(void);
+
+/**
+* @brief           Get the device from the security database list of peer device.
+*                  It will return the device bonded information immediately.
+* @param[inout]    dev_num: Indicate the dev_list array(buffer) size as input.
+*                           If dev_num is large enough, it means the actual number as output.
+*                           Suggest that dev_num value equal to esp_ble_get_bond_device_num().
+*
+* @param[out]      dev_list: an array(buffer) of `esp_bd_addr_t` type. Use for storing the bonded devices address.
+*                            The dev_list should be allocated by who call this API.
+*
+* @return
+*                  - ESP_OK : Succeed
+*                  - ESP_ERR_INVALID_STATE: if bluetooth stack is not yet enabled
+*                  - ESP_FAIL: others
+*/
+esp_err_t esp_bt_gap_get_bond_device_list(int *dev_num, esp_bd_addr_t *dev_list);
+
 #ifdef __cplusplus
 }
 #endif

tools/sdk/include/bluedroid/api/esp_gatt_common_api.h

@@ -23,10 +23,10 @@ extern "C" {
 #endif
 
 // Maximum Transmission Unit used in GATT
-#define ESP_GATT_DEF_BLE_MTU_SIZE   23   /* relate to GATT_DEF_BLE_MTU_SIZE in gatt_api.h */
+#define ESP_GATT_DEF_BLE_MTU_SIZE   23   /* relate to GATT_DEF_BLE_MTU_SIZE in stack/gatt_api.h */
 
 // Maximum Transmission Unit allowed in GATT
-#define ESP_GATT_MAX_MTU_SIZE       517  /* relate to GATT_MAX_MTU_SIZE in gatt_api.h */
+#define ESP_GATT_MAX_MTU_SIZE       517  /* relate to GATT_MAX_MTU_SIZE in stack/gatt_api.h */
 
 /**
  * @brief           This function is called to set local MTU,

tools/sdk/include/bluedroid/api/esp_gatt_defs.h

@@ -154,81 +154,81 @@ extern "C" {
  * @}
  */
 
-/* relate to BTA_GATT_PREP_WRITE_xxx in bta_gatt_api.h */
+/* relate to BTA_GATT_PREP_WRITE_xxx in bta/bta_gatt_api.h */
 /// Attribute write data type from the client
 typedef enum {
-    ESP_GATT_PREP_WRITE_CANCEL    = 0x00,       /*!< Prepare write cancel */  /* relate to BTA_GATT_PREP_WRITE_CANCEL in bta_gatt_api.h */
-    ESP_GATT_PREP_WRITE_EXEC      = 0x01,       /*!< Prepare write execute */ /* relate to BTA_GATT_PREP_WRITE_EXEC in bta_gatt_api.h */
+    ESP_GATT_PREP_WRITE_CANCEL    = 0x00,       /*!< Prepare write cancel */  /* relate to BTA_GATT_PREP_WRITE_CANCEL in bta/bta_gatt_api.h */
+    ESP_GATT_PREP_WRITE_EXEC      = 0x01,       /*!< Prepare write execute */ /* relate to BTA_GATT_PREP_WRITE_EXEC in bta/bta_gatt_api.h */
 } esp_gatt_prep_write_type;
 
-/* relate to BTA_GATT_xxx in bta_gatt_api.h */
+/* relate to BTA_GATT_xxx in bta/bta_gatt_api.h */
 /**
  * @brief GATT success code and error codes
  */
 typedef enum {
-    ESP_GATT_OK                     =   0x0,                    /* relate to BTA_GATT_OK in bta_gatt_api.h */
-    ESP_GATT_INVALID_HANDLE         =   0x01,   /* 0x0001 */    /* relate to BTA_GATT_INVALID_HANDLE in bta_gatt_api.h */
-    ESP_GATT_READ_NOT_PERMIT        =   0x02,   /* 0x0002 */    /* relate to BTA_GATT_READ_NOT_PERMIT in bta_gatt_api.h */
-    ESP_GATT_WRITE_NOT_PERMIT       =   0x03,   /* 0x0003 */    /* relate to BTA_GATT_WRITE_NOT_PERMIT in bta_gatt_api.h */
-    ESP_GATT_INVALID_PDU            =   0x04,   /* 0x0004 */    /* relate to BTA_GATT_INVALID_PDU in bta_gatt_api.h */
-    ESP_GATT_INSUF_AUTHENTICATION   =   0x05,   /* 0x0005 */    /* relate to BTA_GATT_INSUF_AUTHENTICATION in bta_gatt_api.h */
-    ESP_GATT_REQ_NOT_SUPPORTED      =   0x06,   /* 0x0006 */    /* relate to BTA_GATT_REQ_NOT_SUPPORTED in bta_gatt_api.h */
-    ESP_GATT_INVALID_OFFSET         =   0x07,   /* 0x0007 */    /* relate to BTA_GATT_INVALID_OFFSET in bta_gatt_api.h */
-    ESP_GATT_INSUF_AUTHORIZATION    =   0x08,   /* 0x0008 */    /* relate to BTA_GATT_INSUF_AUTHORIZATION in bta_gatt_api.h */
-    ESP_GATT_PREPARE_Q_FULL         =   0x09,   /* 0x0009 */    /* relate to BTA_GATT_PREPARE_Q_FULL in bta_gatt_api.h */
-    ESP_GATT_NOT_FOUND              =   0x0a,   /* 0x000a */    /* relate to BTA_GATT_NOT_FOUND in bta_gatt_api.h */
-    ESP_GATT_NOT_LONG               =   0x0b,   /* 0x000b */    /* relate to BTA_GATT_NOT_LONG in bta_gatt_api.h */
-    ESP_GATT_INSUF_KEY_SIZE         =   0x0c,   /* 0x000c */    /* relate to BTA_GATT_INSUF_KEY_SIZE in bta_gatt_api.h */
-    ESP_GATT_INVALID_ATTR_LEN       =   0x0d,   /* 0x000d */    /* relate to BTA_GATT_INVALID_ATTR_LEN in bta_gatt_api.h */
-    ESP_GATT_ERR_UNLIKELY           =   0x0e,   /* 0x000e */    /* relate to BTA_GATT_ERR_UNLIKELY in bta_gatt_api.h */
-    ESP_GATT_INSUF_ENCRYPTION       =   0x0f,   /* 0x000f */    /* relate to BTA_GATT_INSUF_ENCRYPTION in bta_gatt_api.h */
-    ESP_GATT_UNSUPPORT_GRP_TYPE     =   0x10,   /* 0x0010 */    /* relate to BTA_GATT_UNSUPPORT_GRP_TYPE in bta_gatt_api.h */
-    ESP_GATT_INSUF_RESOURCE         =   0x11,   /* 0x0011 */    /* relate to BTA_GATT_INSUF_RESOURCE in bta_gatt_api.h */
+    ESP_GATT_OK                     =   0x0,                    /* relate to BTA_GATT_OK in bta/bta_gatt_api.h */
+    ESP_GATT_INVALID_HANDLE         =   0x01,   /* 0x0001 */    /* relate to BTA_GATT_INVALID_HANDLE in bta/bta_gatt_api.h */
+    ESP_GATT_READ_NOT_PERMIT        =   0x02,   /* 0x0002 */    /* relate to BTA_GATT_READ_NOT_PERMIT in bta/bta_gatt_api.h */
+    ESP_GATT_WRITE_NOT_PERMIT       =   0x03,   /* 0x0003 */    /* relate to BTA_GATT_WRITE_NOT_PERMIT in bta/bta_gatt_api.h */
+    ESP_GATT_INVALID_PDU            =   0x04,   /* 0x0004 */    /* relate to BTA_GATT_INVALID_PDU in bta/bta_gatt_api.h */
+    ESP_GATT_INSUF_AUTHENTICATION   =   0x05,   /* 0x0005 */    /* relate to BTA_GATT_INSUF_AUTHENTICATION in bta/bta_gatt_api.h */
+    ESP_GATT_REQ_NOT_SUPPORTED      =   0x06,   /* 0x0006 */    /* relate to BTA_GATT_REQ_NOT_SUPPORTED in bta/bta_gatt_api.h */
+    ESP_GATT_INVALID_OFFSET         =   0x07,   /* 0x0007 */    /* relate to BTA_GATT_INVALID_OFFSET in bta/bta_gatt_api.h */
+    ESP_GATT_INSUF_AUTHORIZATION    =   0x08,   /* 0x0008 */    /* relate to BTA_GATT_INSUF_AUTHORIZATION in bta/bta_gatt_api.h */
+    ESP_GATT_PREPARE_Q_FULL         =   0x09,   /* 0x0009 */    /* relate to BTA_GATT_PREPARE_Q_FULL in bta/bta_gatt_api.h */
+    ESP_GATT_NOT_FOUND              =   0x0a,   /* 0x000a */    /* relate to BTA_GATT_NOT_FOUND in bta/bta_gatt_api.h */
+    ESP_GATT_NOT_LONG               =   0x0b,   /* 0x000b */    /* relate to BTA_GATT_NOT_LONG in bta/bta_gatt_api.h */
+    ESP_GATT_INSUF_KEY_SIZE         =   0x0c,   /* 0x000c */    /* relate to BTA_GATT_INSUF_KEY_SIZE in bta/bta_gatt_api.h */
+    ESP_GATT_INVALID_ATTR_LEN       =   0x0d,   /* 0x000d */    /* relate to BTA_GATT_INVALID_ATTR_LEN in bta/bta_gatt_api.h */
+    ESP_GATT_ERR_UNLIKELY           =   0x0e,   /* 0x000e */    /* relate to BTA_GATT_ERR_UNLIKELY in bta/bta_gatt_api.h */
+    ESP_GATT_INSUF_ENCRYPTION       =   0x0f,   /* 0x000f */    /* relate to BTA_GATT_INSUF_ENCRYPTION in bta/bta_gatt_api.h */
+    ESP_GATT_UNSUPPORT_GRP_TYPE     =   0x10,   /* 0x0010 */    /* relate to BTA_GATT_UNSUPPORT_GRP_TYPE in bta/bta_gatt_api.h */
+    ESP_GATT_INSUF_RESOURCE         =   0x11,   /* 0x0011 */    /* relate to BTA_GATT_INSUF_RESOURCE in bta/bta_gatt_api.h */
 
-    ESP_GATT_NO_RESOURCES           =   0x80,   /* 0x80 */    /* relate to BTA_GATT_NO_RESOURCES in bta_gatt_api.h */
-    ESP_GATT_INTERNAL_ERROR         =   0x81,   /* 0x81 */    /* relate to BTA_GATT_INTERNAL_ERROR in bta_gatt_api.h */
-    ESP_GATT_WRONG_STATE            =   0x82,   /* 0x82 */    /* relate to BTA_GATT_WRONG_STATE in bta_gatt_api.h */
-    ESP_GATT_DB_FULL                =   0x83,   /* 0x83 */    /* relate to BTA_GATT_DB_FULL in bta_gatt_api.h */
-    ESP_GATT_BUSY                   =   0x84,   /* 0x84 */    /* relate to BTA_GATT_BUSY in bta_gatt_api.h */
-    ESP_GATT_ERROR                  =   0x85,   /* 0x85 */    /* relate to BTA_GATT_ERROR in bta_gatt_api.h */
-    ESP_GATT_CMD_STARTED            =   0x86,   /* 0x86 */    /* relate to BTA_GATT_CMD_STARTED in bta_gatt_api.h */
-    ESP_GATT_ILLEGAL_PARAMETER      =   0x87,   /* 0x87 */    /* relate to BTA_GATT_ILLEGAL_PARAMETER in bta_gatt_api.h */
-    ESP_GATT_PENDING                =   0x88,   /* 0x88 */    /* relate to BTA_GATT_PENDING in bta_gatt_api.h */
-    ESP_GATT_AUTH_FAIL              =   0x89,   /* 0x89 */    /* relate to BTA_GATT_AUTH_FAIL in bta_gatt_api.h */
-    ESP_GATT_MORE                   =   0x8a,   /* 0x8a */    /* relate to BTA_GATT_MORE in bta_gatt_api.h */
-    ESP_GATT_INVALID_CFG            =   0x8b,   /* 0x8b */    /* relate to BTA_GATT_INVALID_CFG in bta_gatt_api.h */
-    ESP_GATT_SERVICE_STARTED        =   0x8c,   /* 0x8c */    /* relate to BTA_GATT_SERVICE_STARTED in bta_gatt_api.h */
-    ESP_GATT_ENCRYPED_MITM          =   ESP_GATT_OK,    /* relate to BTA_GATT_ENCRYPED_MITM in bta_gatt_api.h */
-    ESP_GATT_ENCRYPED_NO_MITM       =   0x8d,   /* 0x8d */    /* relate to BTA_GATT_ENCRYPED_NO_MITM in bta_gatt_api.h */
-    ESP_GATT_NOT_ENCRYPTED          =   0x8e,   /* 0x8e */    /* relate to BTA_GATT_NOT_ENCRYPTED in bta_gatt_api.h */
-    ESP_GATT_CONGESTED              =   0x8f,   /* 0x8f */    /* relate to BTA_GATT_CONGESTED in bta_gatt_api.h */
-    ESP_GATT_DUP_REG                =   0x90,   /* 0x90 */    /* relate to BTA_GATT_DUP_REG in bta_gatt_api.h */
-    ESP_GATT_ALREADY_OPEN           =   0x91,   /* 0x91 */    /* relate to BTA_GATT_ALREADY_OPEN in bta_gatt_api.h */
-    ESP_GATT_CANCEL                 =   0x92,   /* 0x92 */    /* relate to BTA_GATT_CANCEL in bta_gatt_api.h */
+    ESP_GATT_NO_RESOURCES           =   0x80,   /* 0x80 */    /* relate to BTA_GATT_NO_RESOURCES in bta/bta_gatt_api.h */
+    ESP_GATT_INTERNAL_ERROR         =   0x81,   /* 0x81 */    /* relate to BTA_GATT_INTERNAL_ERROR in bta/bta_gatt_api.h */
+    ESP_GATT_WRONG_STATE            =   0x82,   /* 0x82 */    /* relate to BTA_GATT_WRONG_STATE in bta/bta_gatt_api.h */
+    ESP_GATT_DB_FULL                =   0x83,   /* 0x83 */    /* relate to BTA_GATT_DB_FULL in bta/bta_gatt_api.h */
+    ESP_GATT_BUSY                   =   0x84,   /* 0x84 */    /* relate to BTA_GATT_BUSY in bta/bta_gatt_api.h */
+    ESP_GATT_ERROR                  =   0x85,   /* 0x85 */    /* relate to BTA_GATT_ERROR in bta/bta_gatt_api.h */
+    ESP_GATT_CMD_STARTED            =   0x86,   /* 0x86 */    /* relate to BTA_GATT_CMD_STARTED in bta/bta_gatt_api.h */
+    ESP_GATT_ILLEGAL_PARAMETER      =   0x87,   /* 0x87 */    /* relate to BTA_GATT_ILLEGAL_PARAMETER in bta/bta_gatt_api.h */
+    ESP_GATT_PENDING                =   0x88,   /* 0x88 */    /* relate to BTA_GATT_PENDING in bta/bta_gatt_api.h */
+    ESP_GATT_AUTH_FAIL              =   0x89,   /* 0x89 */    /* relate to BTA_GATT_AUTH_FAIL in bta/bta_gatt_api.h */
+    ESP_GATT_MORE                   =   0x8a,   /* 0x8a */    /* relate to BTA_GATT_MORE in bta/bta_gatt_api.h */
+    ESP_GATT_INVALID_CFG            =   0x8b,   /* 0x8b */    /* relate to BTA_GATT_INVALID_CFG in bta/bta_gatt_api.h */
+    ESP_GATT_SERVICE_STARTED        =   0x8c,   /* 0x8c */    /* relate to BTA_GATT_SERVICE_STARTED in bta/bta_gatt_api.h */
+    ESP_GATT_ENCRYPED_MITM          =   ESP_GATT_OK,    /* relate to BTA_GATT_ENCRYPED_MITM in bta/bta_gatt_api.h */
+    ESP_GATT_ENCRYPED_NO_MITM       =   0x8d,   /* 0x8d */    /* relate to BTA_GATT_ENCRYPED_NO_MITM in bta/bta_gatt_api.h */
+    ESP_GATT_NOT_ENCRYPTED          =   0x8e,   /* 0x8e */    /* relate to BTA_GATT_NOT_ENCRYPTED in bta/bta_gatt_api.h */
+    ESP_GATT_CONGESTED              =   0x8f,   /* 0x8f */    /* relate to BTA_GATT_CONGESTED in bta/bta_gatt_api.h */
+    ESP_GATT_DUP_REG                =   0x90,   /* 0x90 */    /* relate to BTA_GATT_DUP_REG in bta/bta_gatt_api.h */
+    ESP_GATT_ALREADY_OPEN           =   0x91,   /* 0x91 */    /* relate to BTA_GATT_ALREADY_OPEN in bta/bta_gatt_api.h */
+    ESP_GATT_CANCEL                 =   0x92,   /* 0x92 */    /* relate to BTA_GATT_CANCEL in bta/bta_gatt_api.h */
     /* 0xE0 ~ 0xFC reserved for future use */
-    ESP_GATT_STACK_RSP              =   0xe0,   /* 0xe0 */    /* relate to BTA_GATT_STACK_RSP in bta_gatt_api.h */
-    ESP_GATT_APP_RSP                =   0xe1,   /* 0xe1 */    /* relate to BTA_GATT_APP_RSP in bta_gatt_api.h */
+    ESP_GATT_STACK_RSP              =   0xe0,   /* 0xe0 */    /* relate to BTA_GATT_STACK_RSP in bta/bta_gatt_api.h */
+    ESP_GATT_APP_RSP                =   0xe1,   /* 0xe1 */    /* relate to BTA_GATT_APP_RSP in bta/bta_gatt_api.h */
     //Error caused by customer application or stack bug
-    ESP_GATT_UNKNOWN_ERROR          =   0xef,   /* 0xef */    /* relate to BTA_GATT_UNKNOWN_ERROR in bta_gatt_api.h */
-    ESP_GATT_CCC_CFG_ERR            =   0xfd,   /* 0xFD Client Characteristic Configuration Descriptor Improperly Configured */    /* relate to BTA_GATT_CCC_CFG_ERR in bta_gatt_api.h */
-    ESP_GATT_PRC_IN_PROGRESS        =   0xfe,   /* 0xFE Procedure Already in progress */  /* relate to BTA_GATT_PRC_IN_PROGRESS in bta_gatt_api.h */
-    ESP_GATT_OUT_OF_RANGE           =   0xff,   /* 0xFFAttribute value out of range */    /* relate to BTA_GATT_OUT_OF_RANGE in bta_gatt_api.h */
+    ESP_GATT_UNKNOWN_ERROR          =   0xef,   /* 0xef */    /* relate to BTA_GATT_UNKNOWN_ERROR in bta/bta_gatt_api.h */
+    ESP_GATT_CCC_CFG_ERR            =   0xfd,   /* 0xFD Client Characteristic Configuration Descriptor Improperly Configured */    /* relate to BTA_GATT_CCC_CFG_ERR in bta/bta_gatt_api.h */
+    ESP_GATT_PRC_IN_PROGRESS        =   0xfe,   /* 0xFE Procedure Already in progress */  /* relate to BTA_GATT_PRC_IN_PROGRESS in bta/bta_gatt_api.h */
+    ESP_GATT_OUT_OF_RANGE           =   0xff,   /* 0xFFAttribute value out of range */    /* relate to BTA_GATT_OUT_OF_RANGE in bta/bta_gatt_api.h */
 } esp_gatt_status_t;
 
-/* relate to BTA_GATT_CONN_xxx in bta_gatt_api.h */
+/* relate to BTA_GATT_CONN_xxx in bta/bta_gatt_api.h */
 /**
  * @brief Gatt Connection reason enum
  */
 typedef enum {
-    ESP_GATT_CONN_UNKNOWN = 0,                      /*!< Gatt connection unknown */               /* relate to BTA_GATT_CONN_UNKNOWN in bta_gatt_api.h */
-    ESP_GATT_CONN_L2C_FAILURE = 1,                  /*!< General L2cap failure  */                /* relate to BTA_GATT_CONN_L2C_FAILURE in bta_gatt_api.h */
-    ESP_GATT_CONN_TIMEOUT = 0x08,                   /*!< Connection timeout  */                   /* relate to BTA_GATT_CONN_TIMEOUT in bta_gatt_api.h */
-    ESP_GATT_CONN_TERMINATE_PEER_USER = 0x13,       /*!< Connection terminate by peer user  */    /* relate to BTA_GATT_CONN_TERMINATE_PEER_USER in bta_gatt_api.h */
-    ESP_GATT_CONN_TERMINATE_LOCAL_HOST = 0x16,      /*!< Connectionterminated by local host */    /* relate to BTA_GATT_CONN_TERMINATE_LOCAL_HOST in bta_gatt_api.h */
-    ESP_GATT_CONN_FAIL_ESTABLISH = 0x3e,            /*!< Connection fail to establish  */         /* relate to BTA_GATT_CONN_FAIL_ESTABLISH in bta_gatt_api.h */
-    ESP_GATT_CONN_LMP_TIMEOUT = 0x22,               /*!< Connection fail for LMP response tout */ /* relate to BTA_GATT_CONN_LMP_TIMEOUT in bta_gatt_api.h */
-    ESP_GATT_CONN_CONN_CANCEL = 0x0100,             /*!< L2CAP connection cancelled  */           /* relate to BTA_GATT_CONN_CONN_CANCEL in bta_gatt_api.h */
-    ESP_GATT_CONN_NONE = 0x0101                     /*!< No connection to cancel  */              /* relate to BTA_GATT_CONN_NONE in bta_gatt_api.h */
+    ESP_GATT_CONN_UNKNOWN = 0,                      /*!< Gatt connection unknown */               /* relate to BTA_GATT_CONN_UNKNOWN in bta/bta_gatt_api.h */
+    ESP_GATT_CONN_L2C_FAILURE = 1,                  /*!< General L2cap failure  */                /* relate to BTA_GATT_CONN_L2C_FAILURE in bta/bta_gatt_api.h */
+    ESP_GATT_CONN_TIMEOUT = 0x08,                   /*!< Connection timeout  */                   /* relate to BTA_GATT_CONN_TIMEOUT in bta/bta_gatt_api.h */
+    ESP_GATT_CONN_TERMINATE_PEER_USER = 0x13,       /*!< Connection terminate by peer user  */    /* relate to BTA_GATT_CONN_TERMINATE_PEER_USER in bta/bta_gatt_api.h */
+    ESP_GATT_CONN_TERMINATE_LOCAL_HOST = 0x16,      /*!< Connectionterminated by local host */    /* relate to BTA_GATT_CONN_TERMINATE_LOCAL_HOST in bta/bta_gatt_api.h */
+    ESP_GATT_CONN_FAIL_ESTABLISH = 0x3e,            /*!< Connection fail to establish  */         /* relate to BTA_GATT_CONN_FAIL_ESTABLISH in bta/bta_gatt_api.h */
+    ESP_GATT_CONN_LMP_TIMEOUT = 0x22,               /*!< Connection fail for LMP response tout */ /* relate to BTA_GATT_CONN_LMP_TIMEOUT in bta/bta_gatt_api.h */
+    ESP_GATT_CONN_CONN_CANCEL = 0x0100,             /*!< L2CAP connection cancelled  */           /* relate to BTA_GATT_CONN_CONN_CANCEL in bta/bta_gatt_api.h */
+    ESP_GATT_CONN_NONE = 0x0101                     /*!< No connection to cancel  */              /* relate to BTA_GATT_CONN_NONE in bta/bta_gatt_api.h */
 } esp_gatt_conn_reason_t;
 
 /**
@@ -248,42 +248,42 @@ typedef struct {
     bool            is_primary;             /*!< This service is primary or not */
 } __attribute__((packed)) esp_gatt_srvc_id_t;
 
-/* relate to BTA_GATT_AUTH_REQ_xxx in bta_gatt_api.h */
+/* relate to BTA_GATT_AUTH_REQ_xxx in bta/bta_gatt_api.h */
 /**
  * @brief Gatt authentication request type
  */
 typedef enum {
-    ESP_GATT_AUTH_REQ_NONE                  = 0,                                       /* relate to BTA_GATT_AUTH_REQ_NONE in bta_gatt_api.h */
-    ESP_GATT_AUTH_REQ_NO_MITM               = 1,   /* unauthenticated encryption */    /* relate to BTA_GATT_AUTH_REQ_NO_MITM in bta_gatt_api.h */
-    ESP_GATT_AUTH_REQ_MITM                  = 2,   /* authenticated encryption */      /* relate to BTA_GATT_AUTH_REQ_MITM in bta_gatt_api.h */
-    ESP_GATT_AUTH_REQ_SIGNED_NO_MITM        = 3,                                       /* relate to BTA_GATT_AUTH_REQ_SIGNED_NO_MITM in bta_gatt_api.h */
-    ESP_GATT_AUTH_REQ_SIGNED_MITM           = 4,                                       /* relate to BTA_GATT_AUTH_REQ_SIGNED_MITM in bta_gatt_api.h */
+    ESP_GATT_AUTH_REQ_NONE                  = 0,                                       /* relate to BTA_GATT_AUTH_REQ_NONE in bta/bta_gatt_api.h */
+    ESP_GATT_AUTH_REQ_NO_MITM               = 1,   /* unauthenticated encryption */    /* relate to BTA_GATT_AUTH_REQ_NO_MITM in bta/bta_gatt_api.h */
+    ESP_GATT_AUTH_REQ_MITM                  = 2,   /* authenticated encryption */      /* relate to BTA_GATT_AUTH_REQ_MITM in bta/bta_gatt_api.h */
+    ESP_GATT_AUTH_REQ_SIGNED_NO_MITM        = 3,                                       /* relate to BTA_GATT_AUTH_REQ_SIGNED_NO_MITM in bta/bta_gatt_api.h */
+    ESP_GATT_AUTH_REQ_SIGNED_MITM           = 4,                                       /* relate to BTA_GATT_AUTH_REQ_SIGNED_MITM in bta/bta_gatt_api.h */
 } esp_gatt_auth_req_t;
 
-/* relate to BTA_GATT_PERM_xxx in bta_gatt_api.h */
+/* relate to BTA_GATT_PERM_xxx in bta/bta_gatt_api.h */
 /**
  * @brief Attribute permissions
  */
-#define    ESP_GATT_PERM_READ                  (1 << 0)   /* bit 0 -  0x0001 */    /* relate to BTA_GATT_PERM_READ in bta_gatt_api.h */
-#define    ESP_GATT_PERM_READ_ENCRYPTED        (1 << 1)   /* bit 1 -  0x0002 */    /* relate to BTA_GATT_PERM_READ_ENCRYPTED in bta_gatt_api.h */
-#define    ESP_GATT_PERM_READ_ENC_MITM         (1 << 2)   /* bit 2 -  0x0004 */    /* relate to BTA_GATT_PERM_READ_ENC_MITM in bta_gatt_api.h */
-#define    ESP_GATT_PERM_WRITE                 (1 << 4)   /* bit 4 -  0x0010 */    /* relate to BTA_GATT_PERM_WRITE in bta_gatt_api.h */
-#define    ESP_GATT_PERM_WRITE_ENCRYPTED       (1 << 5)   /* bit 5 -  0x0020 */    /* relate to BTA_GATT_PERM_WRITE_ENCRYPTED in bta_gatt_api.h */
-#define    ESP_GATT_PERM_WRITE_ENC_MITM        (1 << 6)   /* bit 6 -  0x0040 */    /* relate to BTA_GATT_PERM_WRITE_ENC_MITM in bta_gatt_api.h */
-#define    ESP_GATT_PERM_WRITE_SIGNED          (1 << 7)   /* bit 7 -  0x0080 */    /* relate to BTA_GATT_PERM_WRITE_SIGNED in bta_gatt_api.h */
-#define    ESP_GATT_PERM_WRITE_SIGNED_MITM     (1 << 8)   /* bit 8 -  0x0100 */    /* relate to BTA_GATT_PERM_WRITE_SIGNED_MITM in bta_gatt_api.h */
+#define    ESP_GATT_PERM_READ                  (1 << 0)   /* bit 0 -  0x0001 */    /* relate to BTA_GATT_PERM_READ in bta/bta_gatt_api.h */
+#define    ESP_GATT_PERM_READ_ENCRYPTED        (1 << 1)   /* bit 1 -  0x0002 */    /* relate to BTA_GATT_PERM_READ_ENCRYPTED in bta/bta_gatt_api.h */
+#define    ESP_GATT_PERM_READ_ENC_MITM         (1 << 2)   /* bit 2 -  0x0004 */    /* relate to BTA_GATT_PERM_READ_ENC_MITM in bta/bta_gatt_api.h */
+#define    ESP_GATT_PERM_WRITE                 (1 << 4)   /* bit 4 -  0x0010 */    /* relate to BTA_GATT_PERM_WRITE in bta/bta_gatt_api.h */
+#define    ESP_GATT_PERM_WRITE_ENCRYPTED       (1 << 5)   /* bit 5 -  0x0020 */    /* relate to BTA_GATT_PERM_WRITE_ENCRYPTED in bta/bta_gatt_api.h */
+#define    ESP_GATT_PERM_WRITE_ENC_MITM        (1 << 6)   /* bit 6 -  0x0040 */    /* relate to BTA_GATT_PERM_WRITE_ENC_MITM in bta/bta_gatt_api.h */
+#define    ESP_GATT_PERM_WRITE_SIGNED          (1 << 7)   /* bit 7 -  0x0080 */    /* relate to BTA_GATT_PERM_WRITE_SIGNED in bta/bta_gatt_api.h */
+#define    ESP_GATT_PERM_WRITE_SIGNED_MITM     (1 << 8)   /* bit 8 -  0x0100 */    /* relate to BTA_GATT_PERM_WRITE_SIGNED_MITM in bta/bta_gatt_api.h */
 typedef uint16_t esp_gatt_perm_t;
 
-/* relate to BTA_GATT_CHAR_PROP_BIT_xxx in bta_gatt_api.h */
+/* relate to BTA_GATT_CHAR_PROP_BIT_xxx in bta/bta_gatt_api.h */
 /* definition of characteristic properties */
-#define    ESP_GATT_CHAR_PROP_BIT_BROADCAST    (1 << 0)       /* 0x01 */    /* relate to BTA_GATT_CHAR_PROP_BIT_BROADCAST in bta_gatt_api.h */
-#define    ESP_GATT_CHAR_PROP_BIT_READ         (1 << 1)       /* 0x02 */    /* relate to BTA_GATT_CHAR_PROP_BIT_READ in bta_gatt_api.h */
-#define    ESP_GATT_CHAR_PROP_BIT_WRITE_NR     (1 << 2)       /* 0x04 */    /* relate to BTA_GATT_CHAR_PROP_BIT_WRITE_NR in bta_gatt_api.h */
-#define    ESP_GATT_CHAR_PROP_BIT_WRITE        (1 << 3)       /* 0x08 */    /* relate to BTA_GATT_CHAR_PROP_BIT_WRITE in bta_gatt_api.h */
-#define    ESP_GATT_CHAR_PROP_BIT_NOTIFY       (1 << 4)       /* 0x10 */    /* relate to BTA_GATT_CHAR_PROP_BIT_NOTIFY in bta_gatt_api.h */
-#define    ESP_GATT_CHAR_PROP_BIT_INDICATE     (1 << 5)       /* 0x20 */    /* relate to BTA_GATT_CHAR_PROP_BIT_INDICATE in bta_gatt_api.h */
-#define    ESP_GATT_CHAR_PROP_BIT_AUTH         (1 << 6)       /* 0x40 */    /* relate to BTA_GATT_CHAR_PROP_BIT_AUTH in bta_gatt_api.h */
-#define    ESP_GATT_CHAR_PROP_BIT_EXT_PROP     (1 << 7)       /* 0x80 */    /* relate to BTA_GATT_CHAR_PROP_BIT_EXT_PROP in bta_gatt_api.h */
+#define    ESP_GATT_CHAR_PROP_BIT_BROADCAST    (1 << 0)       /* 0x01 */    /* relate to BTA_GATT_CHAR_PROP_BIT_BROADCAST in bta/bta_gatt_api.h */
+#define    ESP_GATT_CHAR_PROP_BIT_READ         (1 << 1)       /* 0x02 */    /* relate to BTA_GATT_CHAR_PROP_BIT_READ in bta/bta_gatt_api.h */
+#define    ESP_GATT_CHAR_PROP_BIT_WRITE_NR     (1 << 2)       /* 0x04 */    /* relate to BTA_GATT_CHAR_PROP_BIT_WRITE_NR in bta/bta_gatt_api.h */
+#define    ESP_GATT_CHAR_PROP_BIT_WRITE        (1 << 3)       /* 0x08 */    /* relate to BTA_GATT_CHAR_PROP_BIT_WRITE in bta/bta_gatt_api.h */
+#define    ESP_GATT_CHAR_PROP_BIT_NOTIFY       (1 << 4)       /* 0x10 */    /* relate to BTA_GATT_CHAR_PROP_BIT_NOTIFY in bta/bta_gatt_api.h */
+#define    ESP_GATT_CHAR_PROP_BIT_INDICATE     (1 << 5)       /* 0x20 */    /* relate to BTA_GATT_CHAR_PROP_BIT_INDICATE in bta/bta_gatt_api.h */
+#define    ESP_GATT_CHAR_PROP_BIT_AUTH         (1 << 6)       /* 0x40 */    /* relate to BTA_GATT_CHAR_PROP_BIT_AUTH in bta/bta_gatt_api.h */
+#define    ESP_GATT_CHAR_PROP_BIT_EXT_PROP     (1 << 7)       /* 0x80 */    /* relate to BTA_GATT_CHAR_PROP_BIT_EXT_PROP in bta/bta_gatt_api.h */
 typedef uint8_t esp_gatt_char_prop_t;
 
 /// GATT maximum attribute length
@@ -450,7 +450,8 @@ typedef struct {
   */
 typedef struct {
     uint16_t                   handle;                      /*!< The include service current attribute handle */
-    uint16_t                   incl_srvc_s_handle;          /*!< The start hanlde of the service which has been included */
+    uint16_t                   incl_srvc_s_handle;          /*!< The start handle of the service which has been included */
+    uint16_t                   incl_srvc_e_handle;          /*!< The end handle of the service which has been included */
     esp_bt_uuid_t              uuid;                        /*!< The include service uuid */
 } esp_gattc_incl_svc_elem_t;                                /*!< The gattc inclue service element */
 

tools/sdk/include/bluedroid/api/esp_gattc_api.h

@@ -65,6 +65,8 @@ typedef enum {
     ESP_GATTC_DISCONNECT_EVT          = 41,       /*!< When the ble physical connection disconnected, the event comes */
     ESP_GATTC_READ_MULTIPLE_EVT       = 42,       /*!< When the ble characteristic or descriptor multiple complete, the event comes */
     ESP_GATTC_QUEUE_FULL_EVT          = 43,       /*!< When the gattc command queue full, the event comes */
+    ESP_GATTC_SET_ASSOC_EVT           = 44,       /*!< When the ble gattc set the associated address complete, the event comes */
+    ESP_GATTC_GET_ADDR_LIST_EVT       = 45,       /*!< When the ble get gattc address list in cache finish, the event comes */
 } esp_gattc_cb_event_t;
 
 
@@ -125,6 +127,7 @@ typedef union {
         uint16_t start_handle;          /*!< Service start handle */
         uint16_t end_handle;            /*!< Service end handle */
         esp_gatt_id_t srvc_id;          /*!< Service id, include service uuid and other information */
+        bool      is_primary;           /*!< True if this is the primary service */
     } search_res;                       /*!< Gatt client callback param of ESP_GATTC_SEARCH_RES_EVT */
 
     /**
@@ -215,6 +218,20 @@ typedef union {
         uint16_t conn_id;               /*!< Connection id */
         esp_bd_addr_t remote_bda;       /*!< Remote bluetooth device address */
     } disconnect;                       /*!< Gatt client callback param of ESP_GATTC_DISCONNECT_EVT */
+    /**
+     * @brief ESP_GATTC_SET_ASSOC_EVT
+     */
+    struct gattc_set_assoc_addr_cmp_evt_param {
+        esp_gatt_status_t status;      /*!< Operation status */
+    } set_assoc_cmp;                     /*!< Gatt client callback param of ESP_GATTC_SET_ASSOC_EVT */
+    /**
+     * @brief ESP_GATTC_GET_ADDR_LIST_EVT
+     */
+    struct gattc_get_addr_list_evt_param {
+        esp_gatt_status_t status;      /*!< Operation status */
+        uint8_t num_addr;              /*!< The number of address in the gattc cache address list */
+        esp_bd_addr_t *addr_list;      /*!< The pointer to the address list which has been get from the gattc cache */
+    } get_addr_list;                   /*!< Gatt client callback param of ESP_GATTC_GET_ADDR_LIST_EVT */
 
     /**
      * @brief ESP_GATTC_QUEUE_FULL_EVT
@@ -784,6 +801,41 @@ esp_err_t esp_ble_gattc_unregister_for_notify (esp_gatt_if_t gattc_if,
 */
 esp_err_t esp_ble_gattc_cache_refresh(esp_bd_addr_t remote_bda);
 
+/**
+* @brief           Add or delete the associated address with the source address.
+*                  Note: The role of this API is mainly when the client side has stored a server-side database, 
+*                        when it needs to connect another device, but the device's attribute database is the same 
+*                        as the server database stored on the client-side, calling this API can use the database 
+*                        that the device has stored used as the peer server database to reduce the attribute 
+*                        database search and discovery process and speed up the connection time.
+*                        The associated address mains that device want to used the database has stored in the local cache.
+*                        The source address mains that device want to share the database to the associated address device.
+*
+* @param[in]       gattc_if: Gatt client access interface.
+* @param[in]       src_addr: the source address which provide the attribute table.
+* @param[in]       assoc_addr: the associated device address which went to share the attribute table with the source address.
+* @param[in]       is_assoc: true add the associated device address, false remove the associated device address.
+* @return
+*                  - ESP_OK: success
+*                  - other: failed
+*
+*/
+esp_err_t esp_ble_gattc_cache_assoc(esp_gatt_if_t gattc_if, esp_bd_addr_t src_addr, 
+                                      esp_bd_addr_t assoc_addr, bool is_assoc);
+/**
+* @brief           Get the address list which has store the attribute table in the gattc cache. There will
+*                  callback ESP_GATTC_GET_ADDR_LIST_EVT event when get address list complete.
+*
+* @param[in]       gattc_if: Gatt client access interface.
+* @return
+*                  - ESP_OK: success
+*                  - other: failed
+*
+*/
+esp_err_t esp_ble_gattc_cache_get_addr_list(esp_gatt_if_t gattc_if);
+
+
+
 #ifdef __cplusplus
 }
 #endif