fix(cpp): Fixes for cpp code scanning alerts

Author: lucasssvaz

cores/esp32/esp32-hal-time.c

@@ -22,24 +22,24 @@
 #endif
 
 static void setTimeZone(long offset, int daylight) {
-  char cst[17] = {0};
-  char cdt[17] = "DST";
-  char tz[33] = {0};
+  char cst[21] = {0};
+  char cdt[21] = "DST";
+  char tz[41] = {0};
 
   if (offset % 3600) {
-    sprintf(cst, "UTC%ld:%02u:%02u", offset / 3600, abs((offset % 3600) / 60), abs(offset % 60));
+    snprintf(cst, sizeof(cst), "UTC%ld:%02u:%02u", offset / 3600, abs((offset % 3600) / 60), abs(offset % 60));
   } else {
-    sprintf(cst, "UTC%ld", offset / 3600);
+    snprintf(cst, sizeof(cst), "UTC%ld", offset / 3600);
   }
   if (daylight != 3600) {
     long tz_dst = offset - daylight;
     if (tz_dst % 3600) {
-      sprintf(cdt, "DST%ld:%02u:%02u", tz_dst / 3600, abs((tz_dst % 3600) / 60), abs(tz_dst % 60));
+      snprintf(cdt, sizeof(cdt), "DST%ld:%02u:%02u", tz_dst / 3600, abs((tz_dst % 3600) / 60), abs(tz_dst % 60));
     } else {
-      sprintf(cdt, "DST%ld", tz_dst / 3600);
+      snprintf(cdt, sizeof(cdt), "DST%ld", tz_dst / 3600);
     }
   }
-  sprintf(tz, "%s%s", cst, cdt);
+  snprintf(tz, sizeof(tz), "%s%s", cst, cdt);
   setenv("TZ", tz, 1);
   tzset();
 }

libraries/AsyncUDP/src/AsyncUDP.cpp

@@ -317,6 +317,33 @@ AsyncUDPPacket::AsyncUDPPacket(AsyncUDPPacket &packet) {
   pbuf_ref(_pb);
 }
 
+AsyncUDPPacket& AsyncUDPPacket::operator=(const AsyncUDPPacket& packet) {
+  if (this != &packet) {
+    if (_pb) {
+      // Free existing pbuf reference
+      pbuf_free(_pb);
+    }
+
+    // Copy all members
+    _udp = packet._udp;
+    _pb = packet._pb;
+    _if = packet._if;
+    _data = packet._data;
+    _len = packet._len;
+    _index = 0;
+
+    memcpy(&_remoteIp, &packet._remoteIp, sizeof(ip_addr_t));
+    memcpy(&_localIp, &packet._localIp, sizeof(ip_addr_t));
+    _localPort = packet._localPort;
+    _remotePort = packet._remotePort;
+    memcpy(_remoteMac, packet._remoteMac, 6);
+
+    // Increment reference count for the new pbuf
+    pbuf_ref(_pb);
+  }
+  return *this;
+}
+
 AsyncUDPPacket::AsyncUDPPacket(AsyncUDP *udp, pbuf *pb, const ip_addr_t *raddr, uint16_t rport, struct netif *ntif) {
   _udp = udp;
   _pb = pb;

libraries/AsyncUDP/src/AsyncUDP.h

@@ -100,6 +100,9 @@ class AsyncUDPPacket : public Stream {
 
   size_t write(const uint8_t *data, size_t len);
   size_t write(uint8_t data);
+
+  // Copy assignment operator
+  AsyncUDPPacket& operator=(const AsyncUDPPacket& packet);
 };
 
 class AsyncUDP : public Print {

libraries/EEPROM/src/EEPROM.cpp

@@ -27,6 +27,7 @@
 #include <nvs.h>
 #include <esp_partition.h>
 #include <esp_log.h>
+#include <new>
 
 EEPROMClass::EEPROMClass(void) : _handle(0), _data(0), _size(0), _dirty(false), _name("eeprom") {}
 
@@ -59,31 +60,31 @@ bool EEPROMClass::begin(size_t size) {
   }
   if (size < key_size) {  // truncate
     log_w("truncating EEPROM from %d to %d", key_size, size);
-    uint8_t *key_data = (uint8_t *)malloc(key_size);
+    uint8_t *key_data = new(std::nothrow) uint8_t[key_size];
     if (!key_data) {
       log_e("Not enough memory to truncate EEPROM!");
       return false;
     }
     nvs_get_blob(_handle, _name, key_data, &key_size);
     nvs_set_blob(_handle, _name, key_data, size);
     nvs_commit(_handle);
-    free(key_data);
+    delete[] key_data;
   } else if (size > key_size) {  // expand or new
     size_t expand_size = size - key_size;
-    uint8_t *expand_key = (uint8_t *)malloc(expand_size);
+    uint8_t *expand_key = new(std::nothrow) uint8_t[expand_size];
     if (!expand_key) {
       log_e("Not enough memory to expand EEPROM!");
       return false;
     }
     // check for adequate free space
     if (nvs_set_blob(_handle, "expand", expand_key, expand_size)) {
       log_e("Not enough space to expand EEPROM from %d to %d", key_size, size);
-      free(expand_key);
+      delete[] expand_key;
       return false;
     }
-    free(expand_key);
+    delete[] expand_key;
     nvs_erase_key(_handle, "expand");
-    uint8_t *key_data = (uint8_t *)malloc(size);
+    uint8_t *key_data = new(std::nothrow) uint8_t[size];
     if (!key_data) {
       log_e("Not enough memory to expand EEPROM!");
       return false;
@@ -99,15 +100,15 @@ bool EEPROMClass::begin(size_t size) {
     }
     nvs_commit(_handle);
     nvs_set_blob(_handle, _name, key_data, size);
-    free(key_data);
+    delete[] key_data;
     nvs_commit(_handle);
   }
 
   if (_data) {
     delete[] _data;
   }
 
-  _data = (uint8_t *)malloc(size);
+  _data = new(std::nothrow) uint8_t[size];
   if (!_data) {
     log_e("Not enough memory for %d bytes in EEPROM", size);
     return false;
@@ -212,7 +213,7 @@ uint16_t EEPROMClass::convert(bool clear, const char *EEPROMname, const char *nv
   }
 
   size_t size = mypart->size;
-  uint8_t *data = (uint8_t *)malloc(size);
+  uint8_t *data = new(std::nothrow) uint8_t[size];
   if (!data) {
     log_e("Not enough memory to convert EEPROM!");
     goto exit;
@@ -255,7 +256,7 @@ uint16_t EEPROMClass::convert(bool clear, const char *EEPROMname, const char *nv
     }
   }
 exit:
-  free(data);
+  delete[] data;
   return result;
 }
 
@@ -509,9 +510,9 @@ size_t EEPROMClass::writeBytes(int address, const void *value, size_t len) {
   return len;
 }
 
-template<class T> T EEPROMClass::writeAll(int address, const T &value) {
+template<class T> size_t EEPROMClass::writeAll(int address, const T &value) {
   if (address < 0 || address + sizeof(T) > _size) {
-    return value;
+    return 0;
   }
 
   memcpy(_data + address, (const uint8_t *)&value, sizeof(T));

libraries/EEPROM/src/EEPROM.h

@@ -105,7 +105,7 @@ class EEPROMClass {
   size_t writeString(int address, const char *value);
   size_t writeString(int address, String value);
   size_t writeBytes(int address, const void *value, size_t len);
-  template<class T> T writeAll(int address, const T &);
+  template<class T> size_t writeAll(int address, const T &);
 
 protected:
   nvs_handle _handle;

libraries/ESP32/examples/FreeRTOS/Mutex/Mutex.ino

@@ -71,17 +71,17 @@ void Task(void *pvParameters) {  // This is a task.
 #endif
         int new_value = random(1000);
 
-        char str0[32];
-        sprintf(str0, " %d <- %d      |", shared_variable, new_value);
-        char str1[32];
-        sprintf(str1, "                 | %d <- %d", shared_variable, new_value);
+        char str0[35]; // Maximum possible length of the string
+        snprintf(str0, sizeof(str0), " %d <- %d      |", shared_variable, new_value);
+        char str1[46]; // Maximum possible length of the string
+        snprintf(str1, sizeof(str1), "                 | %d <- %d", shared_variable, new_value);
         Serial.printf("%s\n", task_num ? str0 : str1);
 
         shared_variable = new_value;
         delay(random(100));  // wait random time of max 100 ms - simulating some computation
 
-        sprintf(str0, " R: %d          |", shared_variable);
-        sprintf(str1, "                 | R: %d", shared_variable);
+        snprintf(str0, sizeof(str0), " R: %d          |", shared_variable);
+        snprintf(str1, sizeof(str1), "                 | R: %d", shared_variable);
         Serial.printf("%s\n", task_num ? str0 : str1);
         //Serial.printf("Task %d after write: reading %d\n", task_num, shared_variable);
 

libraries/ESP_NOW/examples/ESP_NOW_Network/ESP_NOW_Network.ino

@@ -32,6 +32,7 @@
 #include <esp_mac.h>  // For the MAC2STR and MACSTR macros
 
 #include <vector>
+#include <new>  //std::nothrow
 
 /* Definitions */
 
@@ -235,7 +236,7 @@ void register_new_peer(const esp_now_recv_info_t *info, const uint8_t *data, int
 
   if (current_peer_count < ESPNOW_PEER_COUNT) {
     Serial.printf("New peer found: " MACSTR " with priority %d\n", MAC2STR(info->src_addr), priority);
-    ESP_NOW_Network_Peer *new_peer = new ESP_NOW_Network_Peer(info->src_addr, priority);
+    ESP_NOW_Network_Peer *new_peer = new (std::nothrow) ESP_NOW_Network_Peer(info->src_addr, priority);
     if (new_peer == nullptr || !new_peer->begin()) {
       Serial.println("Failed to create or register the new peer");
       delete new_peer;

libraries/ESP_NOW/src/ESP32_NOW.h

@@ -87,6 +87,8 @@ class ESP_NOW_Peer {
   friend bool ESP_NOW_Class::removePeer(ESP_NOW_Peer &);
 };
 
+#if !defined(NO_GLOBAL_INSTANCES) && !defined(NO_GLOBAL_ESP_NOW)
 extern ESP_NOW_Class ESP_NOW;
+#endif
 
 #endif

libraries/ESP_SR/src/ESP_SR.h

@@ -33,6 +33,8 @@ class ESP_SR_Class {
   esp_err_t _fill(void *out, size_t len, size_t *bytes_read, uint32_t timeout_ms);
 };
 
+#if !defined(NO_GLOBAL_INSTANCES) && !defined(NO_GLOBAL_ESP_SR)
 extern ESP_SR_Class ESP_SR;
+#endif
 
 #endif  // CONFIG_IDF_TARGET_ESP32S3

libraries/ESPmDNS/src/ESPmDNS.h

@@ -127,7 +127,9 @@ class MDNSResponder {
   mdns_txt_item_t *_getResultTxt(int idx, int txtIdx);
 };
 
+#if !defined(NO_GLOBAL_INSTANCES) && !defined(NO_GLOBAL_MDNS)
 extern MDNSResponder MDNS;
+#endif
 
 #endif  /* CONFIG_MDNS_MAX_INTERFACES */
 #endif  //ESP32MDNS_H