Merge remote-tracking branch 'origin/master' into wifi-ap-32

mcspr · mcspr · commit a6d0fc3abc0a · 2021-04-02T01:40:21.000+03:00
diff --git a/cores/esp8266/HardwareSerial.h b/cores/esp8266/HardwareSerial.h
@@ -101,31 +101,31 @@ class HardwareSerial: public Stream
         return uart_get_rx_buffer_size(_uart);
     }
 
-    void swap()
+    bool swap()
     {
-        swap(1);
+        return swap(1);
     }
-    void swap(uint8_t tx_pin)    //toggle between use of GPIO13/GPIO15 or GPIO3/GPIO(1/2) as RX and TX
+    bool swap(uint8_t tx_pin)    //toggle between use of GPIO13/GPIO15 or GPIO3/GPIO(1/2) as RX and TX
     {
-        uart_swap(_uart, tx_pin);
+        return uart_swap(_uart, tx_pin);
     }
 
     /*
      * Toggle between use of GPIO1 and GPIO2 as TX on UART 0.
      * Note: UART 1 can't be used if GPIO2 is used with UART 0!
      */
-    void set_tx(uint8_t tx_pin)
+    bool set_tx(uint8_t tx_pin)
     {
-        uart_set_tx(_uart, tx_pin);
+        return uart_set_tx(_uart, tx_pin);
     }
 
     /*
      * UART 0 possible options are (1, 3), (2, 3) or (15, 13)
      * UART 1 allows only TX on 2 if UART 0 is not (2, 3)
      */
-    void pins(uint8_t tx, uint8_t rx)
+    bool pins(uint8_t tx, uint8_t rx)
     {
-        uart_set_pins(_uart, tx, rx);
+        return uart_set_pins(_uart, tx, rx);
     }
 
     int available(void) override;
diff --git a/cores/esp8266/StreamDev.h b/cores/esp8266/StreamDev.h
@@ -179,12 +179,14 @@ class StreamConstPtr: public StreamNull
 
     virtual int read() override
     {
-        return _peekPointer < _size ? _buffer[_peekPointer++] : -1;
+        // valid with dram, iram and flash
+        return _peekPointer < _size ? pgm_read_byte(&_buffer[_peekPointer++]) : -1;
     }
 
     virtual int peek() override
     {
-        return _peekPointer < _size ? _buffer[_peekPointer] : -1;
+        // valid with dram, iram and flash
+        return _peekPointer < _size ? pgm_read_byte(&_buffer[_peekPointer]) : -1;
     }
 
     virtual size_t readBytes(char* buffer, size_t len) override
diff --git a/cores/esp8266/uart.cpp b/cores/esp8266/uart.cpp
@@ -760,11 +760,11 @@ uart_uninit(uart_t* uart)
     free(uart);
 }
 
-void
+bool
 uart_swap(uart_t* uart, int tx_pin)
 {
     if(uart == NULL)
-        return;
+        return false;
 
     switch(uart->uart_nr)
     {
@@ -788,6 +788,7 @@ uart_swap(uart_t* uart, int tx_pin)
                 pinMode(uart->rx_pin, FUNCTION_4);    //RX
 
             IOSWAP |= (1 << IOSWAPU0);
+            return true;
         }
         else
         {
@@ -808,6 +809,7 @@ uart_swap(uart_t* uart, int tx_pin)
                 pinMode(3, SPECIAL);    //RX
 
             IOSWAP &= ~(1 << IOSWAPU0);
+            return true;
         }
         break;
     case UART1:
@@ -816,13 +818,14 @@ uart_swap(uart_t* uart, int tx_pin)
     default:
         break;
     }
+    return false;
 }
 
-void
+bool
 uart_set_tx(uart_t* uart, int tx_pin)
 {
     if(uart == NULL)
-        return;
+        return false;
 
     switch(uart->uart_nr)
     {
@@ -834,12 +837,14 @@ uart_set_tx(uart_t* uart, int tx_pin)
                 pinMode(uart->tx_pin, INPUT);
                 uart->tx_pin = 2;
                 pinMode(uart->tx_pin, FUNCTION_4);
+                return true;
             }
             else if (uart->tx_pin == 2 && tx_pin != 2)
             {
                 pinMode(uart->tx_pin, INPUT);
                 uart->tx_pin = 1;
                 pinMode(uart->tx_pin, SPECIAL);
+                return true;
             }
         }
 
@@ -850,33 +855,54 @@ uart_set_tx(uart_t* uart, int tx_pin)
     default:
         break;
     }
+    return false;
 }
 
-void
+bool
 uart_set_pins(uart_t* uart, int tx, int rx)
 {
     if(uart == NULL)
-        return;
+        return false;
+
+    if(uart->uart_nr != UART0) // Only UART0 allows pin changes
+        return false;
 
-    if(uart->uart_nr == UART0) // Only UART0 allows pin changes
+    if(uart->tx_enabled && uart->tx_pin != tx)
     {
-        if(uart->tx_enabled && uart->tx_pin != tx)
+        if( rx == 13 && tx == 15)
+        {
+            if (!uart_swap(uart, 15))
+                return false;
+        }
+        else if (rx == 3 && (tx == 1 || tx == 2))
         {
-            if( rx == 13 && tx == 15)
+            if (uart->rx_pin != rx)
             {
-                uart_swap(uart, 15);
+                if (!uart_swap(uart, tx))
+                    return false;
             }
-            else if (rx == 3 && (tx == 1 || tx == 2))
+            else
             {
-                if (uart->rx_pin != rx)
-                    uart_swap(uart, tx);
-                else
-                    uart_set_tx(uart, tx);
+                if (!uart_set_tx(uart, tx))
+                    return false;
             }
         }
-        if(uart->rx_enabled && uart->rx_pin != rx && rx == 13 && tx == 15)
-            uart_swap(uart, 15);
+        else
+            return false;
     }
+
+    if (uart->rx_enabled && uart->rx_pin != rx)
+    {
+        if (rx == 13 && tx == 15)
+        {
+            if (!uart_swap(uart, 15))
+                return false;
+        }
+        else
+            return false;
+    }
+
+    return true;
 }
 
 
diff --git a/cores/esp8266/uart.h b/cores/esp8266/uart.h
@@ -116,9 +116,9 @@ typedef struct uart_ uart_t;
 uart_t* uart_init(int uart_nr, int baudrate, int config, int mode, int tx_pin, size_t rx_size, bool invert);
 void uart_uninit(uart_t* uart);
 
-void uart_swap(uart_t* uart, int tx_pin);
-void uart_set_tx(uart_t* uart, int tx_pin);
-void uart_set_pins(uart_t* uart, int tx, int rx);
+bool uart_swap(uart_t* uart, int tx_pin);
+bool uart_set_tx(uart_t* uart, int tx_pin);
+bool uart_set_pins(uart_t* uart, int tx, int rx);
 bool uart_tx_enabled(uart_t* uart);
 bool uart_rx_enabled(uart_t* uart);
 
diff --git a/doc/reference.rst b/doc/reference.rst
@@ -441,7 +441,7 @@ Stream extensions
 
     Two additional classes are provided.
 
-    - ``StreamPtr::`` is designed to hold a constant buffer (in ram or flash).
+    - ``StreamConstPtr::`` is designed to hold a constant buffer (in ram or flash).
 
       With this class, a ``Stream::`` can be made from ``const char*``,
       ``F("some words in flash")`` or ``PROGMEM`` strings.  This class makes
@@ -451,7 +451,7 @@ Stream extensions
 
       .. code:: cpp
 
-        StreamPtr css(F("my long css data")); // CSS data not copied to RAM
+        StreamConstPtr css(F("my long css data")); // CSS data not copied to RAM
         server.sendAll(css);
 
     - ``S2Stream::`` is designed to make a ``Stream::`` out of a ``String::`` without copy.
diff --git a/libraries/ESP8266WiFi/src/ESP8266WiFiGeneric.cpp b/libraries/ESP8266WiFi/src/ESP8266WiFiGeneric.cpp
@@ -105,7 +105,7 @@ WiFiEventHandler ESP8266WiFiGenericClass::onStationModeConnected(std::function<v
     WiFiEventHandler handler = std::make_shared<WiFiEventHandlerOpaque>(WIFI_EVENT_STAMODE_CONNECTED, [f](System_Event_t* e) {
         auto& src = e->event_info.connected;
         WiFiEventStationModeConnected dst;
-        dst.ssid = String(reinterpret_cast<char*>(src.ssid));
+        dst.ssid.concat(reinterpret_cast<char*>(src.ssid), src.ssid_len);
         memcpy(dst.bssid, src.bssid, 6);
         dst.channel = src.channel;
         f(dst);
@@ -119,7 +119,7 @@ WiFiEventHandler ESP8266WiFiGenericClass::onStationModeDisconnected(std::functio
     WiFiEventHandler handler = std::make_shared<WiFiEventHandlerOpaque>(WIFI_EVENT_STAMODE_DISCONNECTED, [f](System_Event_t* e){
         auto& src = e->event_info.disconnected;
         WiFiEventStationModeDisconnected dst;
-        dst.ssid = String(reinterpret_cast<char*>(src.ssid));
+        dst.ssid.concat(reinterpret_cast<char*>(src.ssid), src.ssid_len);
         memcpy(dst.bssid, src.bssid, 6);
         dst.reason = static_cast<WiFiDisconnectReason>(src.reason);
         f(dst);
diff --git a/libraries/ESP8266WiFi/src/WiFiClientSecureBearSSL.cpp b/libraries/ESP8266WiFi/src/WiFiClientSecureBearSSL.cpp
@@ -263,6 +263,27 @@ uint8_t WiFiClientSecureCtx::connected() {
   return false;
 }
 
+int WiFiClientSecureCtx::availableForWrite () {
+  // code taken from ::_write()
+  if (!connected() || !_handshake_done) {
+    return 0;
+  }
+  // Get BearSSL to a state where we can send
+  if (_run_until(BR_SSL_SENDAPP) < 0) {
+    return 0;
+  }
+  if (br_ssl_engine_current_state(_eng) & BR_SSL_SENDAPP) {
+    size_t sendapp_len;
+    (void)br_ssl_engine_sendapp_buf(_eng, &sendapp_len);
+    // We want to call br_ssl_engine_sendapp_ack(0) but 0 is forbidden (bssl doc).
+    // After checking br_ssl_engine_sendapp_buf() src code,
+    // it seems that it is OK to not call ack when the buffer is left untouched.
+    //forbidden: br_ssl_engine_sendapp_ack(_eng, 0);
+    return (int)sendapp_len;
+  }
+  return 0;
+}
+
 size_t WiFiClientSecureCtx::_write(const uint8_t *buf, size_t size, bool pmem) {
   size_t sent_bytes = 0;
 
diff --git a/libraries/ESP8266WiFi/src/WiFiClientSecureBearSSL.h b/libraries/ESP8266WiFi/src/WiFiClientSecureBearSSL.h
@@ -58,6 +58,8 @@ class WiFiClientSecureCtx : public WiFiClient {
     void flush() override { (void)flush(0); }
     void stop() override { (void)stop(0); }
 
+    int availableForWrite() override;
+
     // Allow sessions to be saved/restored automatically to a memory area
     void setSession(Session *session) { _session = session; }
 
@@ -249,6 +251,7 @@ class WiFiClientSecure : public WiFiClient {
     size_t write(Stream& stream) /* Note this is not virtual */ { return _ctx->write(stream); }
     int read(uint8_t *buf, size_t size) override { return _ctx->read(buf, size); }
     int available() override { return _ctx->available(); }
+    int availableForWrite() override { return _ctx->availableForWrite(); }
     int read() override { return _ctx->read(); }
     int peek() override { return _ctx->peek(); }
     size_t peekBytes(uint8_t *buffer, size_t length) override { return _ctx->peekBytes(buffer, length); }
diff --git a/libraries/SoftwareSerial b/libraries/SoftwareSerial
@@ -1 +1 @@
-Subproject commit 7fdef9be711f703a3e0bd520fc434ce112900f9f
+Subproject commit 45437b05f7eddd8ee4486474004cc095dc2b4f7b
diff --git a/tests/host/common/MockUART.cpp b/tests/host/common/MockUART.cpp
@@ -407,26 +407,29 @@ uart_uninit(uart_t* uart)
 	free(uart);
 }
 
-void
+bool
 uart_swap(uart_t* uart, int tx_pin)
 {
 	(void) uart;
 	(void) tx_pin;
+	return true;
 }
 
-void
+bool
 uart_set_tx(uart_t* uart, int tx_pin)
 {
 	(void) uart;
 	(void) tx_pin;
+	return true;
 }
 
-void
+bool
 uart_set_pins(uart_t* uart, int tx, int rx)
 {
 	(void) uart;
 	(void) tx;
 	(void) rx;
+	return true;
 }
 
 bool

Original file line number	Diff line number	Diff line change
`@@ -101,31 +101,31 @@ class HardwareSerial: public Stream`
`101`	`101`	`return uart_get_rx_buffer_size(_uart);`
`102`	`102`	`}`
`103`	`103`
`104`		`- void swap()`
	`104`	`+ bool swap()`
`105`	`105`	`{`
`106`		`- swap(1);`
	`106`	`+ return swap(1);`
`107`	`107`	`}`
`108`		`- void swap(uint8_t tx_pin) //toggle between use of GPIO13/GPIO15 or GPIO3/GPIO(1/2) as RX and TX`
	`108`	`+ bool swap(uint8_t tx_pin) //toggle between use of GPIO13/GPIO15 or GPIO3/GPIO(1/2) as RX and TX`
`109`	`109`	`{`
`110`		`- uart_swap(_uart, tx_pin);`
	`110`	`+ return uart_swap(_uart, tx_pin);`
`111`	`111`	`}`
`112`	`112`
`113`	`113`	`/*`
`114`	`114`	`* Toggle between use of GPIO1 and GPIO2 as TX on UART 0.`
`115`	`115`	`* Note: UART 1 can't be used if GPIO2 is used with UART 0!`
`116`	`116`	`*/`
`117`		`- void set_tx(uint8_t tx_pin)`
	`117`	`+ bool set_tx(uint8_t tx_pin)`
`118`	`118`	`{`
`119`		`- uart_set_tx(_uart, tx_pin);`
	`119`	`+ return uart_set_tx(_uart, tx_pin);`
`120`	`120`	`}`
`121`	`121`
`122`	`122`	`/*`
`123`	`123`	`* UART 0 possible options are (1, 3), (2, 3) or (15, 13)`
`124`	`124`	`* UART 1 allows only TX on 2 if UART 0 is not (2, 3)`
`125`	`125`	`*/`
`126`		`- void pins(uint8_t tx, uint8_t rx)`
	`126`	`+ bool pins(uint8_t tx, uint8_t rx)`
`127`	`127`	`{`
`128`		`- uart_set_pins(_uart, tx, rx);`
	`128`	`+ return uart_set_pins(_uart, tx, rx);`
`129`	`129`	`}`
`130`	`130`
`131`	`131`	`int available(void) override;`
Original file line number	Diff line number	Diff line change
`@@ -179,12 +179,14 @@ class StreamConstPtr: public StreamNull`
`179`	`179`
`180`	`180`	`virtual int read() override`
`181`	`181`	`{`
`182`		`- return _peekPointer < _size ? _buffer[_peekPointer++] : -1;`
	`182`	`+ // valid with dram, iram and flash`
	`183`	`+ return _peekPointer < _size ? pgm_read_byte(&_buffer[_peekPointer++]) : -1;`
`183`	`184`	`}`
`184`	`185`
`185`	`186`	`virtual int peek() override`
`186`	`187`	`{`
`187`		`- return _peekPointer < _size ? _buffer[_peekPointer] : -1;`
	`188`	`+ // valid with dram, iram and flash`
	`189`	`+ return _peekPointer < _size ? pgm_read_byte(&_buffer[_peekPointer]) : -1;`
`188`	`190`	`}`
`189`	`191`
`190`	`192`	`virtual size_t readBytes(char* buffer, size_t len) override`
Original file line number	Diff line number	Diff line change
`@@ -760,11 +760,11 @@ uart_uninit(uart_t* uart)`
`760`	`760`	`free(uart);`
`761`	`761`	`}`
`762`	`762`
`763`		`-void`
	`763`	`+bool`
`764`	`764`	`uart_swap(uart_t* uart, int tx_pin)`
`765`	`765`	`{`
`766`	`766`	`if(uart == NULL)`
`767`		`- return;`
	`767`	`+ return false;`
`768`	`768`
`769`	`769`	`switch(uart->uart_nr)`
`770`	`770`	`{`
`@@ -788,6 +788,7 @@ uart_swap(uart_t* uart, int tx_pin)`
`788`	`788`	`pinMode(uart->rx_pin, FUNCTION_4); //RX`
`789`	`789`
`790`	`790`	`IOSWAP \|= (1 << IOSWAPU0);`
	`791`	`+ return true;`
`791`	`792`	`}`
`792`	`793`	`else`
`793`	`794`	`{`
`@@ -808,6 +809,7 @@ uart_swap(uart_t* uart, int tx_pin)`
`808`	`809`	`pinMode(3, SPECIAL); //RX`
`809`	`810`
`810`	`811`	`IOSWAP &= ~(1 << IOSWAPU0);`
	`812`	`+ return true;`
`811`	`813`	`}`
`812`	`814`	`break;`
`813`	`815`	`case UART1:`
`@@ -816,13 +818,14 @@ uart_swap(uart_t* uart, int tx_pin)`
`816`	`818`	`default:`
`817`	`819`	`break;`
`818`	`820`	`}`
	`821`	`+ return false;`
`819`	`822`	`}`
`820`	`823`
`821`		`-void`
	`824`	`+bool`
`822`	`825`	`uart_set_tx(uart_t* uart, int tx_pin)`
`823`	`826`	`{`
`824`	`827`	`if(uart == NULL)`
`825`		`- return;`
	`828`	`+ return false;`
`826`	`829`
`827`	`830`	`switch(uart->uart_nr)`
`828`	`831`	`{`
`@@ -834,12 +837,14 @@ uart_set_tx(uart_t* uart, int tx_pin)`
`834`	`837`	`pinMode(uart->tx_pin, INPUT);`
`835`	`838`	`uart->tx_pin = 2;`
`836`	`839`	`pinMode(uart->tx_pin, FUNCTION_4);`
	`840`	`+ return true;`
`837`	`841`	`}`
`838`	`842`	`else if (uart->tx_pin == 2 && tx_pin != 2)`
`839`	`843`	`{`
`840`	`844`	`pinMode(uart->tx_pin, INPUT);`
`841`	`845`	`uart->tx_pin = 1;`
`842`	`846`	`pinMode(uart->tx_pin, SPECIAL);`
	`847`	`+ return true;`
`843`	`848`	`}`
`844`	`849`	`}`
`845`	`850`
`@@ -850,33 +855,54 @@ uart_set_tx(uart_t* uart, int tx_pin)`
`850`	`855`	`default:`
`851`	`856`	`break;`
`852`	`857`	`}`
	`858`	`+ return false;`
`853`	`859`	`}`
`854`	`860`
`855`		`-void`
	`861`	`+bool`
`856`	`862`	`uart_set_pins(uart_t* uart, int tx, int rx)`
`857`	`863`	`{`
`858`	`864`	`if(uart == NULL)`
`859`		`- return;`
	`865`	`+ return false;`
	`866`	`+`
	`867`	`+ if(uart->uart_nr != UART0) // Only UART0 allows pin changes`
	`868`	`+ return false;`
`860`	`869`
`861`		`- if(uart->uart_nr == UART0) // Only UART0 allows pin changes`
	`870`	`+ if(uart->tx_enabled && uart->tx_pin != tx)`
`862`	`871`	`{`
`863`		`- if(uart->tx_enabled && uart->tx_pin != tx)`
	`872`	`+ if( rx == 13 && tx == 15)`
	`873`	`+ {`
	`874`	`+ if (!uart_swap(uart, 15))`
	`875`	`+ return false;`
	`876`	`+ }`
	`877`	`+ else if (rx == 3 && (tx == 1 \|\| tx == 2))`
`864`	`878`	`{`
`865`		`- if( rx == 13 && tx == 15)`
	`879`	`+ if (uart->rx_pin != rx)`
`866`	`880`	`{`
`867`		`- uart_swap(uart, 15);`
	`881`	`+ if (!uart_swap(uart, tx))`
	`882`	`+ return false;`
`868`	`883`	`}`
`869`		`- else if (rx == 3 && (tx == 1 \|\| tx == 2))`
	`884`	`+ else`
`870`	`885`	`{`
`871`		`- if (uart->rx_pin != rx)`
`872`		`- uart_swap(uart, tx);`
`873`		`- else`
`874`		`- uart_set_tx(uart, tx);`
	`886`	`+ if (!uart_set_tx(uart, tx))`
	`887`	`+ return false;`
`875`	`888`	`}`
`876`	`889`	`}`
`877`		`- if(uart->rx_enabled && uart->rx_pin != rx && rx == 13 && tx == 15)`
`878`		`- uart_swap(uart, 15);`
	`890`	`+ else`
	`891`	`+ return false;`
`879`	`892`	`}`
	`893`	`+`
	`894`	`+ if (uart->rx_enabled && uart->rx_pin != rx)`
	`895`	`+ {`
	`896`	`+ if (rx == 13 && tx == 15)`
	`897`	`+ {`
	`898`	`+ if (!uart_swap(uart, 15))`
	`899`	`+ return false;`
	`900`	`+ }`
	`901`	`+ else`
	`902`	`+ return false;`
	`903`	`+ }`
	`904`	`+`
	`905`	`+ return true;`
`880`	`906`	`}`
`881`	`907`
`882`	`908`
Original file line number	Diff line number	Diff line change
`@@ -407,26 +407,29 @@ uart_uninit(uart_t* uart)`
`407`	`407`	`free(uart);`
`408`	`408`	`}`
`409`	`409`
`410`		`-void`
	`410`	`+bool`
`411`	`411`	`uart_swap(uart_t* uart, int tx_pin)`
`412`	`412`	`{`
`413`	`413`	`(void) uart;`
`414`	`414`	`(void) tx_pin;`
	`415`	`+ return true;`
`415`	`416`	`}`
`416`	`417`
`417`		`-void`
	`418`	`+bool`
`418`	`419`	`uart_set_tx(uart_t* uart, int tx_pin)`
`419`	`420`	`{`
`420`	`421`	`(void) uart;`
`421`	`422`	`(void) tx_pin;`
	`423`	`+ return true;`
`422`	`424`	`}`
`423`	`425`
`424`		`-void`
	`426`	`+bool`
`425`	`427`	`uart_set_pins(uart_t* uart, int tx, int rx)`
`426`	`428`	`{`
`427`	`429`	`(void) uart;`
`428`	`430`	`(void) tx;`
`429`	`431`	`(void) rx;`
	`432`	`+ return true;`
`430`	`433`	`}`
`431`	`434`
`432`	`435`	`bool`