Remove warnings, errors during host tests in CI (esp8266#8358)

earlephilhower · hasenradball · commit fb512b6b2e45 · 2024-11-18T17:40:52.000+01:00
* Remove warnings, errors during host tests in CI

Debug strings often included format parameters which did not exactly match
the passed in format parameters, resulting in warnings in the host test build
process like
````
/home/runner/work/Arduino/Arduino/libraries/ESP8266WiFi/src/ESP8266WiFiAP.cpp:107:20: warning: format ‘%u’ expects argument of type ‘unsigned int’, but argument 3 has type ‘size_t’ {aka ‘long unsigned int’} [-Wformat=]
  107 |         DEBUG_WIFI("[AP] SSID length %u, too long or missing!\n", ssid_len);
      |                                                                   ~~~~~~~~
      |                                                                   |
      |                                                                   size_t {aka long unsigned int}
````

Fix by applying casting or PRxxx macros as appropriate.

Also, fix one debug message which was trying to use a `String` as a `char *`:
````
/home/runner/work/Arduino/Arduino/libraries/ESP8266WiFi/src/ESP8266WiFiMulti.cpp: In member function ‘wl_status_t ESP8266WiFiMulti::connectWiFiMulti(uint32_t)’:
/home/runner/work/Arduino/Arduino/libraries/ESP8266WiFi/src/ESP8266WiFiMulti.cpp:331:34: warning: format ‘%s’ expects argument of type ‘char*’, but argument 3 has type ‘String’ [-Wformat=]
  331 |                 DEBUG_WIFI_MULTI("[WIFIM] Connecting %s\n", ssid);
````

* Clean up SpeedTest.ino host build
diff --git a/libraries/ESP8266HTTPClient/src/ESP8266HTTPClient.cpp b/libraries/ESP8266HTTPClient/src/ESP8266HTTPClient.cpp
@@ -556,7 +556,7 @@ int HTTPClient::sendRequest(const char * type, Stream * stream, size_t size)
     size_t transferred = stream->sendSize(_client.get(), size);
     if (transferred != size)
     {
-        DEBUG_HTTPCLIENT("[HTTP-Client][sendRequest] short write, asked for %d but got %d failed.\n", size, transferred);
+        DEBUG_HTTPCLIENT("[HTTP-Client][sendRequest] short write, asked for %zu but got %zu failed.\n", size, transferred);
         esp_yield();
         return returnError(HTTPC_ERROR_SEND_PAYLOAD_FAILED);
     }
diff --git a/libraries/ESP8266WebServer/src/ESP8266WebServer-impl.h b/libraries/ESP8266WebServer/src/ESP8266WebServer-impl.h
@@ -515,7 +515,7 @@ void ESP8266WebServerTemplate<ServerType>::sendContent(Stream* content, ssize_t
   ssize_t sent = content->sendSize(&_currentClient, content_length);
   if (sent != content_length)
   {
-    DBGWS("HTTPServer: error: short send after timeout (%d<%d)\n", sent, content_length);
+    DBGWS("HTTPServer: error: short send after timeout (%zu < %zu)\n", sent, content_length);
   }
   if(_chunked) {
     _currentClient.printf_P(PSTR("\r\n"));
diff --git a/libraries/ESP8266WiFi/src/ESP8266WiFi.cpp b/libraries/ESP8266WiFi/src/ESP8266WiFi.cpp
@@ -75,12 +75,12 @@ void ESP8266WiFiClass::printDiag(Print& p) {
     char ssid[33]; //ssid can be up to 32chars, => plus null term
     memcpy(ssid, conf.ssid, sizeof(conf.ssid));
     ssid[32] = 0; //nullterm in case of 32 char ssid
-    p.printf_P(PSTR("SSID (%d): %s\n"), strlen(ssid), ssid);
+    p.printf_P(PSTR("SSID (%zu): %s\n"), strlen(ssid), ssid);
 
     char passphrase[65];
     memcpy(passphrase, conf.password, sizeof(conf.password));
     passphrase[64] = 0;
-    p.printf_P(PSTR("Passphrase (%d): %s\n"), strlen(passphrase), passphrase);
+    p.printf_P(PSTR("Passphrase (%zu): %s\n"), strlen(passphrase), passphrase);
 
     p.print(F("BSSID set: "));
     p.println(conf.bssid_set);
diff --git a/libraries/ESP8266WiFi/src/ESP8266WiFiAP.cpp b/libraries/ESP8266WiFi/src/ESP8266WiFiAP.cpp
@@ -104,13 +104,13 @@ bool ESP8266WiFiAPClass::softAP(const char* ssid, const char* psk, int channel,
 
     size_t ssid_len = ssid ? strlen(ssid) : 0;
     if(ssid_len == 0 || ssid_len > 32) {
-        DEBUG_WIFI("[AP] SSID length %u, too long or missing!\n", ssid_len);
+        DEBUG_WIFI("[AP] SSID length %zu, too long or missing!\n", ssid_len);
         return false;
     }
 
     size_t psk_len = psk ? strlen(psk) : 0;
     if(psk_len > 0 && (psk_len > 64 || psk_len < 8)) {
-        DEBUG_WIFI("[AP] fail psk length %u, too long or short!\n", psk_len);
+        DEBUG_WIFI("[AP] fail psk length %zu, too long or short!\n", psk_len);
         return false;
     }
 
diff --git a/libraries/ESP8266WiFi/src/ESP8266WiFiMulti.cpp b/libraries/ESP8266WiFi/src/ESP8266WiFiMulti.cpp
@@ -328,7 +328,7 @@ wl_status_t ESP8266WiFiMulti::connectWiFiMulti(uint32_t connectTimeoutMs)
 
             // Check SSID
             if (ssid == entry.ssid) {
-                DEBUG_WIFI_MULTI("[WIFIM] Connecting %s\n", ssid);
+                DEBUG_WIFI_MULTI("[WIFIM] Connecting %s\n", ssid.c_str());
 
                 // Connect to WiFi
                 WiFi.begin(ssid, entry.passphrase, channel, bssid);
@@ -361,7 +361,7 @@ wl_status_t ESP8266WiFiMulti::connectWiFiMulti(uint32_t connectTimeoutMs)
         }
     }
 
-    DEBUG_WIFI_MULTI("[WIFIM] Could not connect\n", ssid);
+    DEBUG_WIFI_MULTI("[WIFIM] Could not connect\n");
 
     // Could not connect to any WiFi network
     return WL_CONNECT_FAILED;
diff --git a/libraries/ESP8266mDNS/src/LEAmDNS_Helpers.cpp b/libraries/ESP8266mDNS/src/LEAmDNS_Helpers.cpp
@@ -768,7 +768,7 @@ bool MDNSResponder::_printRRAnswer(const MDNSResponder::stcMDNS_RRAnswer& p_RRAn
         if (pTxts)
         {
             ((/*const c_str()!!*/stcMDNS_RRAnswerTXT*)&p_RRAnswer)->m_Txts.c_str(pTxts);
-            DEBUG_OUTPUT.printf_P(PSTR("TXT(%u) %s"), stTxtLength, pTxts);
+            DEBUG_OUTPUT.printf_P(PSTR("TXT(%zu) %s"), stTxtLength, pTxts);
             delete[] pTxts;
         }
         break;
diff --git a/libraries/ESP8266mDNS/src/LEAmDNS_Structs.cpp b/libraries/ESP8266mDNS/src/LEAmDNS_Structs.cpp
@@ -1666,19 +1666,19 @@ bool MDNSResponder::stcMDNSServiceQuery::stcAnswer::stcTTL::finalTimeoutLevel(vo
 unsigned long MDNSResponder::stcMDNSServiceQuery::stcAnswer::stcTTL::timeout(void) const
 {
 
-    uint32_t    u32Timeout = esp8266::polledTimeout::oneShotMs::neverExpires;
+    unsigned long   timeout = esp8266::polledTimeout::oneShotMs::neverExpires;
 
     if (TIMEOUTLEVEL_BASE == m_timeoutLevel)            // 80%
     {
-        u32Timeout = (m_u32TTL * 800);                  // to milliseconds
+        timeout = (m_u32TTL * 800L);                  // to milliseconds
     }
     else if ((TIMEOUTLEVEL_BASE < m_timeoutLevel) &&    // >80% AND
              (TIMEOUTLEVEL_FINAL >= m_timeoutLevel))    // <= 100%
     {
 
-        u32Timeout = (m_u32TTL * 50);
+        timeout = (m_u32TTL * 50L);
     }   // else: invalid
-    return u32Timeout;
+    return timeout;
 }
 
 
diff --git a/libraries/ESP8266mDNS/src/LEAmDNS_Transfer.cpp b/libraries/ESP8266mDNS/src/LEAmDNS_Transfer.cpp
@@ -532,7 +532,7 @@ bool MDNSResponder::_readRRAnswer(MDNSResponder::stcMDNS_RRAnswer*& p_rpRRAnswer
                 if (pTxts)
                 {
                     ((stcMDNS_RRAnswerTXT*&)p_rpRRAnswer)->m_Txts.c_str(pTxts);
-                    DEBUG_OUTPUT.printf_P(PSTR("TXT(%u) %s"), stTxtLength, pTxts);
+                    DEBUG_OUTPUT.printf_P(PSTR("TXT(%zu) %s"), stTxtLength, pTxts);
                     delete[] pTxts;
                 }
                 break;
diff --git a/libraries/LittleFS/examples/SpeedTest/SpeedTest.ino b/libraries/LittleFS/examples/SpeedTest/SpeedTest.ino
@@ -65,7 +65,7 @@ void DoTest(FS *fs) {
   Serial.printf("==> Time to write %dKB in 256b chunks = %lu milliseconds\n", TESTSIZEKB, stop - start);
 
   f = fs->open("/testwrite.bin", "r");
-  Serial.printf("==> Created file size = %d\n", f.size());
+  Serial.printf("==> Created file size = %zu\n", f.size());
   f.close();
 
   Serial.printf("Reading %dKB file sequentially in 256b chunks\n", TESTSIZEKB);
diff --git a/libraries/LittleFS/src/LittleFS.h b/libraries/LittleFS/src/LittleFS.h
@@ -467,14 +467,14 @@ class LittleFSFileImpl : public FileImpl
                 if (_creation) {
                     int rc = lfs_setattr(_fs->getFS(), _name.get(), 'c', (const void *)&_creation, sizeof(_creation));
                     if (rc < 0) {
-                        DEBUGV("Unable to set creation time on '%s' to %d\n", _name.get(), _creation);
+                        DEBUGV("Unable to set creation time on '%s' to %ld\n", _name.get(), (long)_creation);
                     }
                 }
                 // Add metadata with last write time
                 time_t now = _timeCallback();
                 int rc = lfs_setattr(_fs->getFS(), _name.get(), 't', (const void *)&now, sizeof(now));
                 if (rc < 0) {
-                    DEBUGV("Unable to set last write time on '%s' to %d\n", _name.get(), now);
+                    DEBUGV("Unable to set last write time on '%s' to %ld\n", _name.get(), (long)now);
                 }
             }
         }
diff --git a/libraries/SD/src/SD.h b/libraries/SD/src/SD.h
@@ -135,8 +135,8 @@ class SDClass {
     size_t size() {
         uint64_t sz = size64();
 #ifdef DEBUG_ESP_PORT
-	if (sz > (uint64_t)SIZE_MAX) {
-            DEBUG_ESP_PORT.printf_P(PSTR("WARNING: SD card size overflow (%lld>= 4GB).  Please update source to use size64().\n"), sz);
+	if (sz > std::numeric_limits<uint32_t>::max()) {
+            DEBUG_ESP_PORT.printf_P(PSTR("WARNING: SD card size overflow (%lld >= 4GB).  Please update source to use size64().\n"), (long long)sz);
         }
 #endif
         return (size_t)sz;
diff --git a/libraries/SDFS/src/SDFS.h b/libraries/SDFS/src/SDFS.h
@@ -115,9 +115,9 @@ class SDFSImpl : public FSImpl
         info.maxOpenFiles  = i.maxOpenFiles;
         info.maxPathLength = i.maxPathLength;
 #ifdef DEBUG_ESP_PORT
-        if (i.totalBytes > (uint64_t)SIZE_MAX) {
+        if (i.totalBytes > std::numeric_limits<uint32_t>::max()) {
             // This catches both total and used cases, since used must always be < total.
-            DEBUG_ESP_PORT.printf_P(PSTR("WARNING: SD card size overflow (%lld>= 4GB).  Please update source to use info64().\n"), i.totalBytes);
+            DEBUG_ESP_PORT.printf_P(PSTR("WARNING: SD card size overflow (%lld >= 4GB).  Please update source to use info64().\n"), (long long)i.totalBytes);
         }
 #endif
         info.totalBytes    = (size_t)i.totalBytes;

Original file line number	Diff line number	Diff line change
`@@ -556,7 +556,7 @@ int HTTPClient::sendRequest(const char * type, Stream * stream, size_t size)`
`556`	`556`	`size_t transferred = stream->sendSize(_client.get(), size);`
`557`	`557`	`if (transferred != size)`
`558`	`558`	`{`
`559`		`- DEBUG_HTTPCLIENT("[HTTP-Client][sendRequest] short write, asked for %d but got %d failed.\n", size, transferred);`
	`559`	`+ DEBUG_HTTPCLIENT("[HTTP-Client][sendRequest] short write, asked for %zu but got %zu failed.\n", size, transferred);`
`560`	`560`	`esp_yield();`
`561`	`561`	`return returnError(HTTPC_ERROR_SEND_PAYLOAD_FAILED);`
`562`	`562`	`}`
Original file line number	Diff line number	Diff line change
`@@ -515,7 +515,7 @@ void ESP8266WebServerTemplate<ServerType>::sendContent(Stream* content, ssize_t`
`515`	`515`	`ssize_t sent = content->sendSize(&_currentClient, content_length);`
`516`	`516`	`if (sent != content_length)`
`517`	`517`	`{`
`518`		`- DBGWS("HTTPServer: error: short send after timeout (%d<%d)\n", sent, content_length);`
	`518`	`+ DBGWS("HTTPServer: error: short send after timeout (%zu < %zu)\n", sent, content_length);`
`519`	`519`	`}`
`520`	`520`	`if(_chunked) {`
`521`	`521`	`_currentClient.printf_P(PSTR("\r\n"));`
Original file line number	Diff line number	Diff line change
`@@ -104,13 +104,13 @@ bool ESP8266WiFiAPClass::softAP(const char* ssid, const char* psk, int channel,`
`104`	`104`
`105`	`105`	`size_t ssid_len = ssid ? strlen(ssid) : 0;`
`106`	`106`	`if(ssid_len == 0 \|\| ssid_len > 32) {`
`107`		`- DEBUG_WIFI("[AP] SSID length %u, too long or missing!\n", ssid_len);`
	`107`	`+ DEBUG_WIFI("[AP] SSID length %zu, too long or missing!\n", ssid_len);`
`108`	`108`	`return false;`
`109`	`109`	`}`
`110`	`110`
`111`	`111`	`size_t psk_len = psk ? strlen(psk) : 0;`
`112`	`112`	`if(psk_len > 0 && (psk_len > 64 \|\| psk_len < 8)) {`
`113`		`- DEBUG_WIFI("[AP] fail psk length %u, too long or short!\n", psk_len);`
	`113`	`+ DEBUG_WIFI("[AP] fail psk length %zu, too long or short!\n", psk_len);`
`114`	`114`	`return false;`
`115`	`115`	`}`
`116`	`116`
Original file line number	Diff line number	Diff line change
`@@ -328,7 +328,7 @@ wl_status_t ESP8266WiFiMulti::connectWiFiMulti(uint32_t connectTimeoutMs)`
`328`	`328`
`329`	`329`	`// Check SSID`
`330`	`330`	`if (ssid == entry.ssid) {`
`331`		`- DEBUG_WIFI_MULTI("[WIFIM] Connecting %s\n", ssid);`
	`331`	`+ DEBUG_WIFI_MULTI("[WIFIM] Connecting %s\n", ssid.c_str());`
`332`	`332`
`333`	`333`	`// Connect to WiFi`
`334`	`334`	`WiFi.begin(ssid, entry.passphrase, channel, bssid);`
`@@ -361,7 +361,7 @@ wl_status_t ESP8266WiFiMulti::connectWiFiMulti(uint32_t connectTimeoutMs)`
`361`	`361`	`}`
`362`	`362`	`}`
`363`	`363`
`364`		`- DEBUG_WIFI_MULTI("[WIFIM] Could not connect\n", ssid);`
	`364`	`+ DEBUG_WIFI_MULTI("[WIFIM] Could not connect\n");`
`365`	`365`
`366`	`366`	`// Could not connect to any WiFi network`
`367`	`367`	`return WL_CONNECT_FAILED;`
Original file line number	Diff line number	Diff line change
`@@ -768,7 +768,7 @@ bool MDNSResponder::_printRRAnswer(const MDNSResponder::stcMDNS_RRAnswer& p_RRAn`
`768`	`768`	`if (pTxts)`
`769`	`769`	`{`
`770`	`770`	`((/const c_str()!!/stcMDNS_RRAnswerTXT*)&p_RRAnswer)->m_Txts.c_str(pTxts);`
`771`		`- DEBUG_OUTPUT.printf_P(PSTR("TXT(%u) %s"), stTxtLength, pTxts);`
	`771`	`+ DEBUG_OUTPUT.printf_P(PSTR("TXT(%zu) %s"), stTxtLength, pTxts);`
`772`	`772`	`delete[] pTxts;`
`773`	`773`	`}`
`774`	`774`	`break;`
Original file line number	Diff line number	Diff line change
`@@ -1666,19 +1666,19 @@ bool MDNSResponder::stcMDNSServiceQuery::stcAnswer::stcTTL::finalTimeoutLevel(vo`
`1666`	`1666`	`unsigned long MDNSResponder::stcMDNSServiceQuery::stcAnswer::stcTTL::timeout(void) const`
`1667`	`1667`	`{`
`1668`	`1668`
`1669`		`- uint32_t u32Timeout = esp8266::polledTimeout::oneShotMs::neverExpires;`
	`1669`	`+ unsigned long timeout = esp8266::polledTimeout::oneShotMs::neverExpires;`
`1670`	`1670`
`1671`	`1671`	`if (TIMEOUTLEVEL_BASE == m_timeoutLevel) // 80%`
`1672`	`1672`	`{`
`1673`		`- u32Timeout = (m_u32TTL * 800); // to milliseconds`
	`1673`	`+ timeout = (m_u32TTL * 800L); // to milliseconds`
`1674`	`1674`	`}`
`1675`	`1675`	`else if ((TIMEOUTLEVEL_BASE < m_timeoutLevel) && // >80% AND`
`1676`	`1676`	`(TIMEOUTLEVEL_FINAL >= m_timeoutLevel)) // <= 100%`
`1677`	`1677`	`{`
`1678`	`1678`
`1679`		`- u32Timeout = (m_u32TTL * 50);`
	`1679`	`+ timeout = (m_u32TTL * 50L);`
`1680`	`1680`	`} // else: invalid`
`1681`		`- return u32Timeout;`
	`1681`	`+ return timeout;`
`1682`	`1682`	`}`
`1683`	`1683`
`1684`	`1684`
Original file line number	Diff line number	Diff line change
`@@ -532,7 +532,7 @@ bool MDNSResponder::_readRRAnswer(MDNSResponder::stcMDNS_RRAnswer*& p_rpRRAnswer`
`532`	`532`	`if (pTxts)`
`533`	`533`	`{`
`534`	`534`	`((stcMDNS_RRAnswerTXT*&)p_rpRRAnswer)->m_Txts.c_str(pTxts);`
`535`		`- DEBUG_OUTPUT.printf_P(PSTR("TXT(%u) %s"), stTxtLength, pTxts);`
	`535`	`+ DEBUG_OUTPUT.printf_P(PSTR("TXT(%zu) %s"), stTxtLength, pTxts);`
`536`	`536`	`delete[] pTxts;`
`537`	`537`	`}`
`538`	`538`	`break;`
Original file line number	Diff line number	Diff line change
`@@ -467,14 +467,14 @@ class LittleFSFileImpl : public FileImpl`
`467`	`467`	`if (_creation) {`
`468`	`468`	`int rc = lfs_setattr(_fs->getFS(), _name.get(), 'c', (const void *)&_creation, sizeof(_creation));`
`469`	`469`	`if (rc < 0) {`
`470`		`- DEBUGV("Unable to set creation time on '%s' to %d\n", _name.get(), _creation);`
	`470`	`+ DEBUGV("Unable to set creation time on '%s' to %ld\n", _name.get(), (long)_creation);`
`471`	`471`	`}`
`472`	`472`	`}`
`473`	`473`	`// Add metadata with last write time`
`474`	`474`	`time_t now = _timeCallback();`
`475`	`475`	`int rc = lfs_setattr(_fs->getFS(), _name.get(), 't', (const void *)&now, sizeof(now));`
`476`	`476`	`if (rc < 0) {`
`477`		`- DEBUGV("Unable to set last write time on '%s' to %d\n", _name.get(), now);`
	`477`	`+ DEBUGV("Unable to set last write time on '%s' to %ld\n", _name.get(), (long)now);`
`478`	`478`	`}`
`479`	`479`	`}`
`480`	`480`	`}`