v1.1.2

### Releases v1.1.2 1. Rename _lock and _unlock to avoid conflict with [**ESP32/ESP8266 AsyncWebServer**](https://github.com/me-no-dev/ESPAsyncWebServer) library. Check [**compatibility with ESPAsyncWebServer #11**](https://github.com/khoih-prog/AsyncHTTPRequest_Generic/issues/11) 2. Fix compiler warnings.
2021-02-11 14:48:08 -05:00
parent 87984ddf22
commit b691c1b98b
31 changed files with 561 additions and 171 deletions
@@ -17,7 +17,7 @@
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
  You should have received a copy of the GNU General Public License along with this program.  If not, see <https://www.gnu.org/licenses/>.  
 
-  Version: 1.1.1
+  Version: 1.1.2
  
  Version Modified By   Date      Comments
  ------- -----------  ---------- -----------
@@ -26,10 +26,14 @@
  1.0.2    K Hoang     09/11/2020 Make Mutex Lock and delete more reliable and error-proof
  1.1.0    K Hoang     23/12/2020 Add HTTP PUT, PATCH, DELETE and HEAD methods
  1.1.1    K Hoang     24/12/2020 Prevent crash if request and/or method not correct.
+  1.1.2    K Hoang     11/02/2021 Rename _lock and _unlock to avoid conflict with AsyncWebServer library
 *****************************************************************************************************************************/

 #pragma once

+#ifndef ASYNC_HTTP_REQUEST_DEBUG_GENERIC_H
+#define ASYNC_HTTP_REQUEST_DEBUG_GENERIC_H
+
 #ifdef ASYNC_HTTP_DEBUG_PORT
  #define A_DBG_PORT      ASYNC_HTTP_DEBUG_PORT
 #else
@@ -71,3 +75,5 @@
 #define AHTTP_LOGDEBUG2(x,y,z)    if(_ASYNC_HTTP_LOGLEVEL_>3) { A_DBG_PORT.print("[AHTTP] "); A_DBG_PORT.print(x); A_DBG_PORT.print(" "); A_DBG_PORT.print(y); A_DBG_PORT.print(" "); A_DBG_PORT.println(z); }
 #define AHTTP_LOGDEBUG3(x,y,z,w)  if(_ASYNC_HTTP_LOGLEVEL_>3) { A_DBG_PORT.print("[AHTTP] "); A_DBG_PORT.print(x); A_DBG_PORT.print(" "); A_DBG_PORT.print(y); A_DBG_PORT.print(" "); A_DBG_PORT.print(z); A_DBG_PORT.print(" "); A_DBG_PORT.println(w); }

+#endif    // ASYNC_HTTP_REQUEST_DEBUG_GENERIC_H
+
@@ -17,7 +17,7 @@
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
  You should have received a copy of the GNU General Public License along with this program.  If not, see <https://www.gnu.org/licenses/>.  
 
-  Version: 1.1.1
+  Version: 1.1.2
  
  Version Modified By   Date      Comments
  ------- -----------  ---------- -----------
@@ -26,11 +26,15 @@
  1.0.2    K Hoang     09/11/2020 Make Mutex Lock and delete more reliable and error-proof
  1.1.0    K Hoang     23/12/2020 Add HTTP PUT, PATCH, DELETE and HEAD methods
  1.1.1    K Hoang     24/12/2020 Prevent crash if request and/or method not correct.
+  1.1.2    K Hoang     11/02/2021 Rename _lock and _unlock to avoid conflict with AsyncWebServer library
 *****************************************************************************************************************************/

 #pragma once

-#define ASYNC_HTTP_REQUEST_GENERIC_VERSION   "AsyncHTTPRequest_Generic v1.1.1"
+#ifndef ASYNC_HTTP_REQUEST_GENERIC_H
+#define ASYNC_HTTP_REQUEST_GENERIC_H
+
+#define ASYNC_HTTP_REQUEST_GENERIC_VERSION   "AsyncHTTPRequest_Generic v1.1.2"

 #include <Arduino.h>

@@ -59,8 +63,8 @@
  #define MUTEX_LOCK_NR           if (xSemaphoreTakeRecursive(threadLock,portMAX_DELAY) != pdTRUE) { return;}
  #define MUTEX_LOCK(returnVal)   if (xSemaphoreTakeRecursive(threadLock,portMAX_DELAY) != pdTRUE) { return returnVal;}
  
-  #define _lock       xSemaphoreTakeRecursive(threadLock,portMAX_DELAY)
-  #define _unlock     xSemaphoreGiveRecursive(threadLock)
+  #define _AHTTP_lock       xSemaphoreTakeRecursive(threadLock,portMAX_DELAY)
+  #define _AHTTP_unlock     xSemaphoreGiveRecursive(threadLock)
  
 #elif ESP8266

@@ -69,8 +73,8 @@
  #define MUTEX_LOCK_NR
  #define MUTEX_LOCK(returnVal)
  
-  #define _lock
-  #define _unlock
+  #define _AHTTP_lock
+  #define _AHTTP_unlock
  
 #elif ( defined(STM32F0) || defined(STM32F1) || defined(STM32F2) || defined(STM32F3)  ||defined(STM32F4) || defined(STM32F7) || \
       defined(STM32L0) || defined(STM32L1) || defined(STM32L4) || defined(STM32H7)  ||defined(STM32G0) || defined(STM32G4) || \
@@ -80,8 +84,8 @@
  
  #define MUTEX_LOCK_NR
  #define MUTEX_LOCK(returnVal)
-  #define _lock
-  #define _unlock
+  #define _AHTTP_lock
+  #define _AHTTP_unlock
  
 #endif

@@ -220,8 +224,11 @@ class AsyncHTTPRequest
    size_t      responseLength();                                       // indicated response length or sum of chunks to date
    int         responseHTTPcode();                                     // HTTP response code or (negative) error code
    String      responseText();                                         // response (whole* or partial* as string)
+    
+    char*       responseLongText();                                     // response long (whole* or partial* as string)
+    
    size_t      responseRead(uint8_t* buffer, size_t len);              // Read response into buffer
-    uint32_t    elapsedTime();                                         // Elapsed time of in progress transaction or last completed (ms)
+    uint32_t    elapsedTime();                                          // Elapsed time of in progress transaction or last completed (ms)
    String      version();                                              // Version of AsyncHTTPRequest
    //___________________________________________________________________________________________________________________________________

@@ -299,4 +306,4 @@ class AsyncHTTPRequest

 #include "AsyncHTTPRequest_Impl_Generic.h"

-
+#endif    // ASYNC_HTTP_REQUEST_GENERIC_H
@@ -17,7 +17,7 @@
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
  You should have received a copy of the GNU General Public License along with this program.  If not, see <https://www.gnu.org/licenses/>.  
 
-  Version: 1.1.1
+  Version: 1.1.2
  
  Version Modified By   Date      Comments
  ------- -----------  ---------- -----------
@@ -26,10 +26,14 @@
  1.0.2    K Hoang     09/11/2020 Make Mutex Lock and delete more reliable and error-proof
  1.1.0    K Hoang     23/12/2020 Add HTTP PUT, PATCH, DELETE and HEAD methods
  1.1.1    K Hoang     24/12/2020 Prevent crash if request and/or method not correct.
+  1.1.2    K Hoang     11/02/2021 Rename _lock and _unlock to avoid conflict with AsyncWebServer library
 *****************************************************************************************************************************/
 
 #pragma once

+#ifndef ASYNC_HTTP_REQUEST_GENERIC_IMPL_H
+#define ASYNC_HTTP_REQUEST_GENERIC_IMPL_H
+
 #define CANT_SEND_BAD_REQUEST       F("Can't send() bad request")

 //**************************************************************************************************************
@@ -93,6 +97,8 @@ bool  AsyncHTTPRequest::open(const char* method, const char* URL)

  if (_readyState != readyStateUnsent && _readyState != readyStateDone)
  {
+    AHTTP_LOGDEBUG("open: not ready");
+    
    return false;
  }

@@ -145,17 +151,23 @@ bool  AsyncHTTPRequest::open(const char* method, const char* URL)
  //////
  else
  {
+    AHTTP_LOGDEBUG("open: Bad method");
+    
    return false;
  }


  if (!_parseURL(URL))
  {
+    AHTTP_LOGDEBUG("open: error parsing URL");
+    
    return false;
  }
  
  if ( _client && _client->connected() && (strcmp(_URL->host, _connectedHost) != 0 || _URL->port != _connectedPort))
  {
+    AHTTP_LOGDEBUG("open: not connected");
+    
    return false;
  }

@@ -173,11 +185,17 @@ bool  AsyncHTTPRequest::open(const char* method, const char* URL)
    // New in v1.1.1
    _requestReadyToSend = true;
    //////
+    
+    AHTTP_LOGDEBUG1("open: conneting to hostname =", hostName);

    return _connect();
  }
  else
+  {
+    AHTTP_LOGDEBUG("open: error alloc");
+    
    return false;
+  }
 }
 //**************************************************************************************************************
 void AsyncHTTPRequest::onReadyStateChange(readyStateChangeCB cb, void* arg) 
@@ -216,7 +234,7 @@ bool  AsyncHTTPRequest::send()
    
  _send();
  
-  _unlock;
+  _AHTTP_unlock;
  
  return true;
 }
@@ -242,7 +260,7 @@ bool AsyncHTTPRequest::send(String body)
  
  if ( ! _buildRequest()) 
  {
-    _unlock;
+    _AHTTP_unlock;
    
    return false;
  }
@@ -250,7 +268,7 @@ bool AsyncHTTPRequest::send(String body)
  _request->write(body);
  _send();
  
-  _unlock;
+  _AHTTP_unlock;
  
  return true;
 }
@@ -276,7 +294,7 @@ bool  AsyncHTTPRequest::send(const char* body)
  
  if ( ! _buildRequest()) 
  {
-    _unlock;
+    _AHTTP_unlock;
    
    return false;
  }
@@ -284,7 +302,7 @@ bool  AsyncHTTPRequest::send(const char* body)
  _request->write(body);
  _send();
  
-  _unlock;
+  _AHTTP_unlock;
  
  return true;
 }
@@ -310,7 +328,7 @@ bool  AsyncHTTPRequest::send(const uint8_t* body, size_t len)
  
  if ( ! _buildRequest()) 
  {
-    _unlock;
+    _AHTTP_unlock;
    
    return false;
  }
@@ -318,7 +336,7 @@ bool  AsyncHTTPRequest::send(const uint8_t* body, size_t len)
  _request->write(body, len);
  _send();
  
-  _unlock;
+  _AHTTP_unlock;
  
  return true;
 }
@@ -344,7 +362,7 @@ bool AsyncHTTPRequest::send(xbuf* body, size_t len)
  
  if ( ! _buildRequest()) 
  {
-    _unlock;
+    _AHTTP_unlock;
    
    return false;
  }
@@ -352,7 +370,7 @@ bool AsyncHTTPRequest::send(xbuf* body, size_t len)
  _request->write(body, len);
  _send();
  
-  _unlock;
+  _AHTTP_unlock;
  
  return true;
 }
@@ -371,7 +389,7 @@ void AsyncHTTPRequest::abort()
    
  _client->abort();
  
-  _unlock;
+  _AHTTP_unlock;
 }
 //**************************************************************************************************************
 reqStates   AsyncHTTPRequest::readyState()
@@ -396,7 +414,7 @@ String AsyncHTTPRequest::responseText()
  {
    AHTTP_LOGDEBUG("responseText() no data");

-    _unlock;
+    _AHTTP_unlock;
    
    return String();
  }
@@ -411,7 +429,7 @@ String AsyncHTTPRequest::responseText()
    _HTTPcode = HTTPCODE_TOO_LESS_RAM;
    _client->abort();
    
-    _unlock;
+    _AHTTP_unlock;
    
    return String();
  }
@@ -419,13 +437,61 @@ String AsyncHTTPRequest::responseText()
  localString   = _response->readString(avail);
  _contentRead += localString.length();

-  AHTTP_LOGDEBUG3("responseText(char)", localString.substring(0, 16).c_str(), ", avail =", avail);
+  //AHTTP_LOGDEBUG3("responseText(char)", localString.substring(0, 16).c_str(), ", avail =", avail);
+  AHTTP_LOGDEBUG3("responseText(char)", localString, ", avail =", avail);

-  _unlock;
+  _AHTTP_unlock;
  
  return localString;
 }

+//**************************************************************************************************************
+
+#if 1
+
+#if (ESP32)
+  #define GLOBAL_STR_LEN      (32 * 1024)
+#elif (ESP8266)
+  #define GLOBAL_STR_LEN      (16 * 1024) 
+#else
+  #define GLOBAL_STR_LEN      (4 * 1024)
+#endif
+
+char globalLongString[GLOBAL_STR_LEN + 1];
+
+char* AsyncHTTPRequest::responseLongText()
+{
+  AHTTP_LOGDEBUG("responseLongText()");
+
+  MUTEX_LOCK(NULL)
+  
+  if ( ! _response || _readyState < readyStateLoading || ! available())
+  {
+    AHTTP_LOGDEBUG("responseText() no data");
+
+    _AHTTP_unlock;
+    
+    //return String();
+    return NULL;
+  }
+
+  // String localString;
+  size_t avail = available();
+  size_t lenToCopy = (avail <= GLOBAL_STR_LEN) ? avail : GLOBAL_STR_LEN;
+
+  strncpy(globalLongString, _response->readString(avail).c_str(), lenToCopy );
+  globalLongString[ lenToCopy + 1 ] = 0;
+  
+  _contentRead += _response->readString(avail).length();
+  
+  AHTTP_LOGDEBUG3("responseLongText(char)", globalLongString, ", avail =", avail);
+  
+  _AHTTP_unlock;
+  
+  return globalLongString;
+}
+#endif
+
 //**************************************************************************************************************
 size_t AsyncHTTPRequest::responseRead(uint8_t* buf, size_t len)
 {
@@ -445,7 +511,7 @@ size_t AsyncHTTPRequest::responseRead(uint8_t* buf, size_t len)

  _contentRead += avail;
  
-  _unlock;
+  _AHTTP_unlock;

  return avail;
 }
@@ -847,11 +913,18 @@ void  AsyncHTTPRequest::_onConnect(AsyncClient* client)
  _client = client;
  _setReadyState(readyStateOpened);
  
+  // KH test
  _response = new xbuf;
+  //_response = new xbuf(256);
+  //////
  
  if (!_response)
  {
-    _unlock;
+    _AHTTP_unlock;
+    
+    // KH, to remove
+    AHTTP_LOGDEBUG("_onConnect: Can't new _responser");
+    ///////
    
    return;
  }
@@ -862,11 +935,17 @@ void  AsyncHTTPRequest::_onConnect(AsyncClient* client)
  
  _client->onAck([](void* obj, AsyncClient * client, size_t len, uint32_t time) 
  {
+    (void) client;
+    (void) len;
+    (void) time;
+    
    ((AsyncHTTPRequest*)(obj))->_send();
  }, this);
  
  _client->onData([](void* obj, AsyncClient * client, void* data, size_t len) 
  {
+    (void) client;
+    
    ((AsyncHTTPRequest*)(obj))->_onData(data, len);
  }, this);

@@ -877,12 +956,14 @@ void  AsyncHTTPRequest::_onConnect(AsyncClient* client)

  _lastActivity = millis();
  
-  _unlock;
+  _AHTTP_unlock;
 }

 //**************************************************************************************************************
 void  AsyncHTTPRequest::_onPoll(AsyncClient* client)
 {
+  (void) client;
+  
  MUTEX_LOCK_NR

  if (_timeout && (millis() - _lastActivity) > (_timeout * 1000))
@@ -898,12 +979,14 @@ void  AsyncHTTPRequest::_onPoll(AsyncClient* client)
    _onDataCB(_onDataCBarg, this, available());
  }

-  _unlock;
+  _AHTTP_unlock;
 }

 //**************************************************************************************************************
 void  AsyncHTTPRequest::_onError(AsyncClient* client, int8_t error)
 {
+  (void) client;
+  
  AHTTP_LOGDEBUG1("_onError handler error =", error);

  _HTTPcode = error;
@@ -912,6 +995,8 @@ void  AsyncHTTPRequest::_onError(AsyncClient* client, int8_t error)
 //**************************************************************************************************************
 void  AsyncHTTPRequest::_onDisconnect(AsyncClient* client)
 {
+  (void) client;
+  
  AHTTP_LOGDEBUG("\n_onDisconnect handler");

  MUTEX_LOCK_NR
@@ -939,7 +1024,7 @@ void  AsyncHTTPRequest::_onDisconnect(AsyncClient* client)
  _lastActivity   = 0;
  _setReadyState(readyStateDone);
  
-  _unlock;
+  _AHTTP_unlock;
 }

 //**************************************************************************************************************
@@ -955,6 +1040,11 @@ void  AsyncHTTPRequest::_onData(void* Vbuf, size_t len)
  if (_chunks)
  {
    _chunks->write((uint8_t*)Vbuf, len);
+    
+    // KH, to remove
+    AHTTP_LOGDEBUG("_onData: _processChunks");
+    ///////
+    
    _processChunks();
  }
  else
@@ -967,7 +1057,11 @@ void  AsyncHTTPRequest::_onData(void* Vbuf, size_t len)
  {
    if ( ! _collectHeaders())
    {
-      _unlock;
+      _AHTTP_unlock;
+      
+      // KH, to remove
+      AHTTP_LOGDEBUG("_onData: headers not complete");
+      ///////
      
      return;
    }
@@ -1007,7 +1101,7 @@ void  AsyncHTTPRequest::_onData(void* Vbuf, size_t len)
    _onDataCB(_onDataCBarg, this, available());
  }

-  _unlock;
+  _AHTTP_unlock;

 }

@@ -1292,7 +1386,7 @@ String AsyncHTTPRequest::headers()

  _response += "\r\n";
  
-  _unlock;
+  _AHTTP_unlock;

  return _response;
 }
@@ -1352,7 +1446,7 @@ AsyncHTTPRequest::header*  AsyncHTTPRequest::_addHeader(const char* name, const
    return nullptr;
  }
  
-  _unlock;
+  _AHTTP_unlock;

  return hdr->next;
 }
@@ -1372,7 +1466,7 @@ AsyncHTTPRequest::header* AsyncHTTPRequest::_getHeader(const char* name)
    hdr = hdr->next;
  }

-  _unlock;
+  _AHTTP_unlock;

  return hdr;
 }
@@ -1392,7 +1486,7 @@ AsyncHTTPRequest::header* AsyncHTTPRequest::_getHeader(int ndx)
    hdr = hdr->next;
  }

-  _unlock;
+  _AHTTP_unlock;

  return hdr;
 }
@@ -1417,3 +1511,5 @@ char* AsyncHTTPRequest::_charstar(const __FlashStringHelper * str)
 }

 #endif
+
+#endif    // ASYNC_HTTP_REQUEST_GENERIC_IMPL_H
@@ -17,7 +17,7 @@
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
  You should have received a copy of the GNU General Public License along with this program.  If not, see <https://www.gnu.org/licenses/>.  
 
-  Version: 1.1.1
+  Version: 1.1.2
  
  Version Modified By   Date      Comments
  ------- -----------  ---------- -----------
@@ -26,6 +26,7 @@
  1.0.2    K Hoang     09/11/2020 Make Mutex Lock and delete more reliable and error-proof
  1.1.0    K Hoang     23/12/2020 Add HTTP PUT, PATCH, DELETE and HEAD methods
  1.1.1    K Hoang     24/12/2020 Prevent crash if request and/or method not correct.
+  1.1.2    K Hoang     11/02/2021 Rename _lock and _unlock to avoid conflict with AsyncWebServer library
 *****************************************************************************************************************************/
 
 /********************************************************************************************
@@ -48,6 +49,9 @@
 ********************************************************************************************/
 #pragma once

+#ifndef XBUF_H
+#define XBUF_H
+
 #include <Arduino.h>

 struct xseg 
@@ -151,3 +155,5 @@ class xbuf: public Print

 #include "utility/xbuf_Impl.h"

+#endif    // XBUF_H
+
@@ -17,7 +17,7 @@
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
  You should have received a copy of the GNU General Public License along with this program.  If not, see <https://www.gnu.org/licenses/>.  
 
-  Version: 1.1.1
+  Version: 1.1.2
  
  Version Modified By   Date      Comments
  ------- -----------  ---------- -----------
@@ -26,10 +26,14 @@
  1.0.2    K Hoang     09/11/2020 Make Mutex Lock and delete more reliable and error-proof
  1.1.0    K Hoang     23/12/2020 Add HTTP PUT, PATCH, DELETE and HEAD methods
  1.1.1    K Hoang     24/12/2020 Prevent crash if request and/or method not correct.
+  1.1.2    K Hoang     11/02/2021 Rename _lock and _unlock to avoid conflict with AsyncWebServer library
 *****************************************************************************************************************************/

 #pragma once

+#ifndef XBUF_IMPL_H
+#define XBUF_IMPL_H
+
 xbuf::xbuf(const uint16_t segSize) : _head(nullptr), _tail(nullptr), _used(0), _free(0), _offset(0) 
 {
  _segSize = (segSize + 3) & -4;//((segSize + 3) >> 2) << 2;
@@ -291,9 +295,17 @@ String xbuf::readString(int endPos)
  
  if ( ! result.reserve(endPos + 1)) 
  {
+    // KH, to remove
+    AHTTP_LOGDEBUG1("xbuf::readString: can't reserve size = ", endPos + 1);
+    ///////
+      
    return result;
  }
  
+  // KH, to remove
+    AHTTP_LOGDEBUG1("xbuf::readString: Reserved size = ", endPos + 1);
+    ///////
+  
  if (endPos > _used) 
  {
    endPos = _used;
@@ -365,6 +377,9 @@ void xbuf::addSeg()
  {
    _tail->next = (xseg*) new uint32_t[_segSize / 4 + 1];
    
+    if (_tail->next == NULL)
+      AHTTP_LOGERROR("xbuf::addSeg: error new 1");
+    
    // KH, Must check NULL here
    _tail = _tail->next;
  }
@@ -372,6 +387,9 @@ void xbuf::addSeg()
  {
    // KH, Must check NULL here
    _tail = _head = (xseg*) new uint32_t[_segSize / 4 + 1];
+    
+    if (_tail == NULL)
+      AHTTP_LOGERROR("xbuf::addSeg: error new 2");
  }
  
  // KH, Must check NULL here
@@ -399,3 +417,5 @@ void xbuf::remSeg()
  _offset = 0;
 }

+#endif    // XBUF_IMPL_H
+