Fix chunked data decoding issue

Author: mobizt

examples/FirestoreDatabase/Documents/Commit/AppendArray/AppendArray.ino

@@ -25,8 +25,8 @@
 #define FIREBASE_PROJECT_ID "PROJECT_ID"
 
 void processData(AsyncResult &aResult);
-void append_array_async();
-void append_array_async2();
+void append_array_async(Writes &writes);
+void append_array_async2(Writes &writes);
 void append_array_await();
 
 SSL_CLIENT ssl_client;

examples/FirestoreDatabase/Documents/Commit/AppendMapValue/AppendMapValue.ino

@@ -149,7 +149,7 @@ void append_map_value_async(Writes &writes)
     Docs.commit(aClient, Firestore::Parent(FIREBASE_PROJECT_ID), writes, processData, "commitTask");
 }
 
-void append_map_value_async(Writes &writes)
+void append_map_value_async2(Writes &writes)
 {
     Serial.println("Appending the map value in the document... ");
 

src/core/AsyncClient/AsyncClient.h

@@ -204,6 +204,11 @@ class AsyncClientClass PUBLIC_DATABASE_RESULT_IMPL_BASE
     // Handles raw data sending process.
     function_return_type sendImpl(async_data *sData, const uint8_t *data, size_t len, size_t size, async_state state = astate_send_payload)
     {
+        if (state == astate_send_header && (sData->response.respCtx.stage == res_handler::response_stage_undefined || sData->response.respCtx.stage == res_handler::response_stage_finished))
+        {
+            initResponse(sData);
+        }
+
         sys_idle();
         sData->state = state;
         if (data && len && sman.client)
@@ -456,11 +461,18 @@ class AsyncClientClass PUBLIC_DATABASE_RESULT_IMPL_BASE
 
             String *payload = &sData->response.val[resns::payload];
 
-            if (sData->auth_used)
-                sData->response.auth_data_available = true;
-
-            if (!sData->response.flags.sse)
+            if (!sData->response.flags.sse && payload->length())
+            {
                 sData->aResult.setPayload(*payload);
+                if (sData->auth_used)
+                    sData->response.auth_data_available = true;
+                else
+                {
+                    clear(*payload);
+                    sData->response.flags.payload_available = true;
+                    sman.returnResult(sData, true);
+                }
+            }
 
             if (sData->aResult.download_data.total > 0)
                 sData->aResult.data_log.reset();
@@ -487,7 +499,6 @@ class AsyncClientClass PUBLIC_DATABASE_RESULT_IMPL_BASE
 
                     if (((*payload)[len - 1] == '\n' && sData->response.tcpAvailable() == 0) || partial)
                     {
-
                         setRefPayload(&sData->aResult.rtdbResult, payload);
                         parseSSE(&sData->aResult.rtdbResult);
 
@@ -946,8 +957,6 @@ class AsyncClientClass PUBLIC_DATABASE_RESULT_IMPL_BASE
                 sData->request.val[reqns::header] += "access_token_auth: true\r\n";
         }
 
-        initResponse(sData);
-
         if (method == reqns::http_get || method == reqns::http_delete)
             sData->request.addNewLine();
     }
@@ -966,6 +975,14 @@ class AsyncClientClass PUBLIC_DATABASE_RESULT_IMPL_BASE
         sData->response.respCtx.isSSE = sData->sse;
         sData->response.respCtx.isUpload = sData->upload;
         sData->response.respCtx.location = location;
+        sData->response.httpCode = 0;
+        sData->response.payloadLen = 0;
+        sData->response.payloadRead = 0;
+        sData->response.flags.reset();
+        sData->response.toFill = nullptr;
+        sData->response.toFillIndex = 0;
+        sData->response.toFillLen = 0;
+        sData->response.auth_data_available = false;
     }
 
     void returnResult(async_data *sData) { *sData->refResult = sData->aResult; }
@@ -1017,15 +1034,13 @@ class AsyncClientClass PUBLIC_DATABASE_RESULT_IMPL_BASE
             {
                 sman.stop();
                 sData->state = astate_send_header;
-                initResponse(sData);
             }
 
             // Resume incomplete async task from previously stopped.
             if (!sman.conn.async && sData->async && !sData->complete)
             {
                 sData->state = astate_send_header;
                 sman.conn.async = sData->async;
-                initResponse(sData);
             }
 
             bool sending = false;
@@ -1104,8 +1119,7 @@ class AsyncClientClass PUBLIC_DATABASE_RESULT_IMPL_BASE
 
                     handleReadTimeout(sData);
 
-                    bool allRead = sData->response.httpCode > 0 && sData->response.httpCode != FIREBASE_ERROR_HTTP_CODE_OK && sData->response.respCtx.stage == res_handler::response_stage_finished;
-                    if (allRead && sData->response.httpCode >= FIREBASE_ERROR_HTTP_CODE_BAD_REQUEST)
+                    if (sData->response.respCtx.stage == res_handler::response_stage_finished && sData->response.httpCode >= FIREBASE_ERROR_HTTP_CODE_BAD_REQUEST)
                     {
                         if (sData->sse)
                         {
@@ -1115,9 +1129,10 @@ class AsyncClientClass PUBLIC_DATABASE_RESULT_IMPL_BASE
 #endif
                         }
                         sData->return_type = ret_failure;
+                        sman.setAsyncError(sData, sData->state, sData->response.httpCode, !sData->sse, false);
                     }
 
-                    if (sData->async || allRead || sData->return_type == ret_failure)
+                    if (sData->async || sData->return_type == ret_failure)
                         break;
                 }
             }

src/core/AsyncClient/ResponseHandler.h

@@ -66,7 +66,7 @@ struct res_handler
     {
     public:
         const int bufSize = 512; // Maximum size of the buffer (including null terminator).
-        uint8_t *buf = nullptr;   //  Byte array to store the read data.
+        uint8_t *buf = nullptr;  //  Byte array to store the read data.
         const int hdrSize = 512;
         char *hdr = nullptr;
         String *location = nullptr;
@@ -453,10 +453,13 @@ struct res_handler
                 }
                 else
                 {
-                    payloadRead += len;
-                    respCtx.buf[len] = '\0';
-                    reserveString();
-                    val[resns::payload] += (const char *)respCtx.buf;
+                    if (len > 0)
+                    {
+                        payloadRead += len;
+                        respCtx.buf[len] = '\0';
+                        reserveString();
+                        val[resns::payload] += (const char *)respCtx.buf;
+                    }
 
                     if (!respCtx.isChunked || (respCtx.isChunked && len == 0))
                     {