Cherry picked commits from origin/master (1.0.0-RC2).

Author: everslick

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 @@ class String
     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-i2c.c

@@ -990,15 +990,6 @@ i2c_err_t i2cProcQueue(i2c_t * i2c, uint32_t *readCount, uint16_t timeOutMillis)
     }
 
     if(eBits&EVENT_DONE) { // no gross timeout
-#if ARDUHAL_LOG_LEVEL >= ARDUHAL_LOG_LEVEL_DEBUG
-        uint32_t expected =(totalBytes*10*1000)/i2cGetFrequency(i2c);
-        if((tAfter-tBefore)>(expected+1)) { //used some of the timeout Period
-            // expected can be zero due to small packets
-            log_e("TimeoutRecovery: expected=%ums, actual=%ums",expected,(tAfter-tBefore));
-            i2cDumpI2c(i2c);
-            i2cDumpInts(i2c->num);
-        }
-#endif
         switch(i2c->error) {
         case I2C_OK :
             reason = I2C_ERROR_OK;

cores/esp32/esp32-hal-uart.c

@@ -315,11 +315,14 @@ void uartFlush(uart_t* uart)
     UART_MUTEX_LOCK();
     while(uart->dev->status.txfifo_cnt);
 
-    uart->dev->conf0.txfifo_rst = 1;
-    uart->dev->conf0.txfifo_rst = 0;
+    // Due to hardware issue, we can not use fifo_rst to reset uart fifo.
+    // See description about UART_TXFIFO_RST and UART_RXFIFO_RST in <<esp32_technical_reference_manual>> v2.6 or later.
+
+    // we read the data out and make `fifo_len == 0 && rd_addr == wr_addr`.
+    while(uart->dev->status.rxfifo_cnt != 0 || (uart->dev->mem_rx_status.wr_addr != uart->dev->mem_rx_status.rd_addr)) {
+        READ_PERI_REG(UART_FIFO_REG(uart->num));
+    }
 
-    uart->dev->conf0.rxfifo_rst = 1;
-    uart->dev->conf0.rxfifo_rst = 0;
     UART_MUTEX_UNLOCK();
 }
 

libraries/ArduinoOTA/src/ArduinoOTA.cpp

@@ -149,13 +149,13 @@ int ArduinoOTAClass::parseInt(){
 
 String ArduinoOTAClass::readStringUntil(char end){
     String res = "";
-    char value;
+    int value;
     while(true){
         value = _udp_ota.read();
-        if(value == '\0' || value == end){
+        if(value <= 0 || value == end){
             return res;
         }
-        res += value;
+        res += (char)value;
     }
     return res;
 }

libraries/FS/src/FS.h

@@ -47,7 +47,9 @@ enum SeekMode {
 class File : public Stream
 {
 public:
-    File(FileImplPtr p = FileImplPtr()) : _p(p) {}
+    File(FileImplPtr p = FileImplPtr()) : _p(p) {
+      _timeout = 0;
+    }
 
     size_t write(uint8_t) override;
     size_t write(const uint8_t *buf, size_t size) override;

libraries/HTTPClient/src/HTTPClient.cpp

@@ -252,7 +252,7 @@ void HTTPClient::end(void)
 bool HTTPClient::connected()
 {
     if(_tcp) {
-        return (_tcp->connected() || (_tcp->available() > 0));
+        return ((_tcp->available() > 0) || _tcp->connected());
     }
     return false;
 }

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>
@@ -30,6 +31,118 @@
 #undef write
 #undef read
 
+class WiFiClientRxBuffer {
+private:
+        size_t _size;
+        uint8_t *_buffer;
+        size_t _pos;
+        size_t _fill;
+        int _fd;
+        bool _failed;
+
+        size_t r_available()
+        {
+            if(_fd < 0){
+                return 0;
+            }
+            int count;
+            int res = lwip_ioctl_r(_fd, FIONREAD, &count);
+            if(res < 0) {
+                _failed = true;
+                return 0;
+            }
+            return count;
+        }
+
+        size_t fillBuffer()
+        {
+            if(!_buffer){
+                _buffer = (uint8_t *)malloc(_size);
+            }
+            if(_fill && _pos == _fill){
+                _fill = 0;
+                _pos = 0;
+            }
+            if(!_buffer || _size <= _fill || !r_available()) {
+                return 0;
+            }
+            int res = recv(_fd, _buffer + _fill, _size - _fill, MSG_DONTWAIT);
+            if (res < 0 && errno != EWOULDBLOCK) {
+                _failed = true;
+                return 0;
+            }
+            _fill += res;
+            return res;
+        }
+
+public:
+    WiFiClientRxBuffer(int fd, size_t size=1436)
+        :_size(size)
+        ,_buffer(NULL)
+        ,_pos(0)
+        ,_fill(0)
+        ,_fd(fd)
+        ,_failed(false)
+    {
+        //_buffer = (uint8_t *)malloc(_size);
+    }
+
+    ~WiFiClientRxBuffer()
+    {
+        free(_buffer);
+    }
+
+    bool failed(){
+        return _failed;
+    }
+
+    int read(uint8_t * dst, size_t len){
+        if(!dst || !len || (_pos == _fill && !fillBuffer())){
+            return -1;
+        }
+        size_t a = _fill - _pos;
+        if(len <= a || ((len - a) <= (_size - _fill) && fillBuffer() >= (len - a))){
+            if(len == 1){
+                *dst = _buffer[_pos];
+            } else {
+                memcpy(dst, _buffer + _pos, len);
+            }
+            _pos += len;
+            return len;
+        }
+        size_t left = len;
+        size_t toRead = a;
+        uint8_t * buf = dst;
+        memcpy(buf, _buffer + _pos, toRead);
+        _pos += toRead;
+        left -= toRead;
+        buf += toRead;
+        while(left){
+            if(!fillBuffer()){
+                return len - left;
+            }
+            a = _fill - _pos;
+            toRead = (a > left)?left:a;
+            memcpy(buf, _buffer + _pos, toRead);
+            _pos += toRead;
+            left -= toRead;
+            buf += toRead;
+        }
+        return len;
+    }
+
+    int peek(){
+        if(_pos == _fill && !fillBuffer()){
+            return -1;
+        }
+        return _buffer[_pos];
+    }
+
+    size_t available(){
+        return _fill - _pos + r_available();
+    }
+};
+
 class WiFiClientSocketHandle {
 private:
     int sockfd;
@@ -57,6 +170,7 @@ WiFiClient::WiFiClient():_connected(false),next(NULL)
 WiFiClient::WiFiClient(int fd):_connected(true),next(NULL)
 {
     clientSocketHandle.reset(new WiFiClientSocketHandle(fd));
+    _rxBuffer.reset(new WiFiClientRxBuffer(fd));
 }
 
 WiFiClient::~WiFiClient()
@@ -68,13 +182,15 @@ WiFiClient & WiFiClient::operator=(const WiFiClient &other)
 {
     stop();
     clientSocketHandle = other.clientSocketHandle;
+    _rxBuffer = other._rxBuffer;
     _connected = other._connected;
     return *this;
 }
 
 void WiFiClient::stop()
 {
     clientSocketHandle = NULL;
+    _rxBuffer = NULL;
     _connected = false;
 }
 
@@ -99,18 +215,17 @@ int WiFiClient::connect(IPAddress ip, uint16_t port)
         return 0;
     }
     clientSocketHandle.reset(new WiFiClientSocketHandle(sockfd));
+    _rxBuffer.reset(new WiFiClientRxBuffer(sockfd));
     _connected = true;
     return 1;
 }
 
 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,13 +356,29 @@ size_t WiFiClient::write_P(PGM_P buf, size_t size)
     return write(buf, size);
 }
 
-int WiFiClient::read(uint8_t *buf, size_t size)
+size_t WiFiClient::write(Stream &stream)
 {
-    if(!available()) {
-        return -1;
+    uint8_t * buf = (uint8_t *)malloc(1360);
+    if(!buf){
+        return 0;
     }
-    int res = recv(fd(), buf, size, MSG_DONTWAIT);
-    if(res < 0 && errno != EWOULDBLOCK) {
+    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)
+{
+    int res = -1;
+    res = _rxBuffer->read(buf, size);
+    if(_rxBuffer->failed()) {
         log_e("%d", errno);
         stop();
     }
@@ -256,31 +387,25 @@ int WiFiClient::read(uint8_t *buf, size_t size)
 
 int WiFiClient::peek()
 {
-    if(!available()) {
-        return -1;
-    }
-    uint8_t data = 0;
-    int res = recv(fd(), &data, 1, MSG_PEEK);
-    if(res < 0 && errno != EWOULDBLOCK) {
+    int res = _rxBuffer->peek();
+    if(_rxBuffer->failed()) {
         log_e("%d", errno);
         stop();
     }
-    return data;
+    return res;
 }
 
 int WiFiClient::available()
 {
     if(!_connected) {
         return 0;
     }
-    int count;
-    int res = lwip_ioctl_r(fd(), FIONREAD, &count);
-    if(res < 0) {
+    int res = _rxBuffer->available();
+    if(_rxBuffer->failed()) {
         log_e("%d", errno);
         stop();
-        return 0;
     }
-    return count;
+    return res;
 }
 
 // Though flushing means to send all pending data,
@@ -313,22 +438,9 @@ uint8_t WiFiClient::connected()
     if (_connected) {
         uint8_t dummy;
         int res = recv(fd(), &dummy, 0, MSG_DONTWAIT);
-        if (res <= 0) {
-            switch (errno) {
-                case ENOTCONN:
-                case EPIPE:
-                case ECONNRESET:
-                case ECONNREFUSED:
-                case ECONNABORTED:
-                    _connected = false;
-                    break;
-                default:
-                    _connected = true;
-                    break;
-            }
-        }
-        else {
-            _connected = true;
+        if (res <= 0 && errno != EWOULDBLOCK) {
+            _connected = false;
+            log_i("Disconnected: RES: %d, ERR: %d", res, errno);
         }
     }
     return _connected;