Only decompress zip after a succsessfully contenet download

lib/obp60task/NetworkClient.cpp

@@ -105,7 +105,6 @@ bool NetworkClient::httpGetGzip(const String& url, uint8_t*& outData, size_t& ou
         return false;
     }
     else{       
-        
         if (DEBUGING) {
             String ce = http.header("Content-Encoding");
             String te = http.header("Transfer-Encoding");
@@ -132,9 +131,18 @@ bool NetworkClient::httpGetGzip(const String& url, uint8_t*& outData, size_t& ou
     String ce = http.header("Content-Encoding");
     bool isGzip = ce.equalsIgnoreCase("gzip");
 
+    // NEW: read expected body size if provided by server (prevents waiting forever for missing bytes)
+    int total = http.getSize();  // returns Content-Length, or -1 if unknown/chunked
+
+    // NEW: fail fast if server claims something larger than our buffer
+    if (total > 0 && (size_t)total > capacity) {
+        Serial.println("Response exceeds READLIMIT.");
+        aborting = true;
+    }
+
     // NEW: if not gzip, we will not try to decompress (prevents false "Decompress OK" / random success)
     // You can either handle plain JSON here or just fail-fast.
-    if (!isGzip) {
+    if (!isGzip && !aborting) {
         if (DEBUGING) {
             Serial.println("Server response is NOT gzip (Content-Encoding != gzip).");
             Serial.println("Either disable Accept-Encoding: gzip or add plain-body handling here.");
@@ -142,7 +150,6 @@ bool NetworkClient::httpGetGzip(const String& url, uint8_t*& outData, size_t& ou
 
         // --- Plain-body handling (recommended): read full body into outData as-is ---
         // NEW: try to read Content-Length bytes if available (more robust)
-        int total = http.getSize();  // returns Content-Length, or -1 if unknown/chunked
         if (total > 0 && (size_t)total > capacity) {
             Serial.println("Plain response exceeds READLIMIT.");
             aborting = true;
@@ -175,6 +182,7 @@ bool NetworkClient::httpGetGzip(const String& url, uint8_t*& outData, size_t& ou
                     lastData = millis();
                 }
 
+                // NEW: stop reading as soon as we have the full response
                 if (total > 0 && (int)len >= total) {
                     break; // we got full body
                 }
@@ -208,13 +216,21 @@ bool NetworkClient::httpGetGzip(const String& url, uint8_t*& outData, size_t& ou
     }
 
     // --- GZIP path (only if Content-Encoding is gzip) ---
-    while ((http.connected() || (stream && stream->available())) && !complete) {
+    if (!aborting) {
+
+        // NEW: read exactly Content-Length bytes when available (prevents partial-body timeout loops)
+        while ((http.connected() || (stream && stream->available())) && !complete && !aborting) {
 
             size_t avail = stream ? stream->available() : 0;
 
             if (avail == 0) {
+                // NEW: if Content-Length is known and we already read it all, stop immediately
+                if (total > 0 && (int)len >= total) {
+                    break;
+                }
+
                 if (millis() - lastData > READ_TIMEOUT) {
-                Serial.println("TIMEOUT waiting for data!");
+                    if (DEBUGING) {Serial.println("TIMEOUT waiting for data!");}
                     aborting = true;   // NEW: mark abnormal exit
                     break;
                 }
@@ -229,6 +245,12 @@ bool NetworkClient::httpGetGzip(const String& url, uint8_t*& outData, size_t& ou
                 break;
             }
 
+            // NEW: if Content-Length is known, do not read beyond it
+            if (total > 0) {
+                size_t remaining = (size_t)total - len;
+                if (avail > remaining) avail = remaining;
+            }
+
             if (len + avail > capacity)
                 avail = capacity - len;
 
@@ -244,34 +266,45 @@ bool NetworkClient::httpGetGzip(const String& url, uint8_t*& outData, size_t& ou
 
             if (DEBUGING) {Serial.printf("Read chunk: %d (total: %d)\n", read, (int)len);}
 
-        if (len < 20) continue;  // Not enough data for header
+            // NEW: if Content-Length is known and fully received, we can stop reading
+            if (total > 0 && (int)len >= total) {
+                break;
+            }
+        }
 
+        // NEW: only attempt gzip parse/decompress after we have a complete body (when Content-Length is known)
+        // This avoids wasting heap with repeated malloc/free and reduces fragmentation over long runtimes.
+        if (!aborting) {
+            if (len < 20) {
+                aborting = true;
+            } else {
                 int headerOffset = skipGzipHeader(buffer, len);
-        if (headerOffset < 0) continue;
+                if (headerOffset < 0) {
-
+                    aborting = true;
+                } else {
                     unsigned long testLen = len * 8; // Dynamic expansion
                     uint8_t* test = (uint8_t*)malloc(testLen);
 
                     if (!test) {
-            // NEW: abort if allocation fails to prevent endless retry loop
                         Serial.println("Malloc failed test buffer, aborting.");
                         aborting = true;
-            break;
+                    } else {
-        }
+                        unsigned long srcLen = (unsigned long)(len - (size_t)headerOffset);
-
-        unsigned long srcLen = len - headerOffset;
-
                         int res = puff(test, &testLen, buffer + headerOffset, &srcLen);
+
                         if (res == 0) {
                             if (DEBUGING) {Serial.printf("Decompress OK! Size: %lu bytes\n", testLen);}
                             outData = test;
                             outLen = (size_t)testLen;
                             complete = true;
-            break;
+                        } else {
-        }
-
                             free(test);
                         }
+                    }
+                }
+            }
+        }
+    }
 
     // --- Added: Force-close connection only if aborted to avoid TCP RST storms ---
     if (aborting && stream) stream->stop();   // NEW: stop() only on abnormal termination