- Rework ExpiringTimeTracker to be based on PolledTimeout.

- Ensure espnowDelay and floodingMeshDelay always performs maintenance.

- Rework MutexTracker to use shared_ptr.

- Change enums to enum class.

- Change typedef to using.

- Add HeapMonitor class.

- Make _messageIDs be a map instead of an unordered_map to reduce heap usage.

- Use the possibly broken wifi_country ESP8266 API to check for legal WiFi channels when setting WiFi channels.

- Make MessageData, RequestData and ResponseData contain a TimeTracker rather than inherit from TimeTracker.

- Add deprecated attribute to TransmissionResult.

- Remove superfluous elses.

- Reduce cyclomatic complexity.

- Change postfix ++ and -- to prefix.

- Generalize getEncryptedConnectionIterator method.

- Increase code NRVO compatibility.

- Change _connectionAttemptTimeoutMs type from int32_t to uint32_t.

- Add deprecated attribute to ESP8266WiFiMesh.

- Add some constness to TypeConversionFunctions.

- Move base36 arrays to PROGMEM in TypeConversionFunctions.cpp.

- Add deprecated atttribute to SHA1 and MD5 hashes.

- Remove _warningsEnabled in CryptoInterface since this has been replaced by the deprecated attribute.

- Prefix all TypeConversion getters with "get".

- Improve comments.

- Fix merge conflict.

Author: aerlon

libraries/ESP8266WiFiMesh/examples/HelloEspnow/HelloEspnow.ino

@@ -5,7 +5,7 @@
    That way you will get instant confirmation of the mesh communication without checking the Serial Monitor.
 */
 
-#define ESP8266WIFIMESH_DISABLE_COMPATIBILITY // Excludes redundant compatibility code. Should be used for new code until the compatibility code is removed with release 3.0.0 of the Arduino core.
+#define ESP8266WIFIMESH_DISABLE_COMPATIBILITY // Excludes redundant compatibility code. TODO: Should be used for new code until the compatibility code is removed with release 3.0.0 of the Arduino core.
 
 #include <ESP8266WiFi.h>
 #include <TypeConversionFunctions.h>
@@ -175,7 +175,7 @@ void loop() {
   floodingMeshDelay(1);
 
   // If you wish to transmit only to a single node, try using one of the following methods (requires the node to be within range and know the MAC of the recipient):
-  // Unencrypted: transmission_status_t floodingMesh.getEspnowMeshBackend().attemptTransmission(message, EspnowNetworkInfo(recipientMac));
+  // Unencrypted: TransmissionStatusType floodingMesh.getEspnowMeshBackend().attemptTransmission(message, EspnowNetworkInfo(recipientMac));
   // Encrypted (slow): floodingMesh.getEspnowMeshBackend().attemptAutoEncryptingTransmission(message, EspnowNetworkInfo(recipientMac));
 
   if (theOne) {

libraries/ESP8266WiFiMesh/examples/HelloMesh/HelloMesh.ino

@@ -1,4 +1,4 @@
-#define ESP8266WIFIMESH_DISABLE_COMPATIBILITY // Excludes redundant compatibility code. Should be used for new code until the compatibility code is removed with release 3.0.0 of the Arduino core.
+#define ESP8266WIFIMESH_DISABLE_COMPATIBILITY // Excludes redundant compatibility code. TODO: Should be used for new code until the compatibility code is removed with release 3.0.0 of the Arduino core.
 
 #include <ESP8266WiFi.h>
 #include <TcpIpMeshBackend.h>
@@ -25,7 +25,7 @@ unsigned int requestNumber = 0;
 unsigned int responseNumber = 0;
 
 String manageRequest(const String &request, MeshBackendBase &meshInstance);
-transmission_status_t manageResponse(const String &response, MeshBackendBase &meshInstance);
+TransmissionStatusType manageResponse(const String &response, MeshBackendBase &meshInstance);
 void networkFilter(int numberOfNetworks, MeshBackendBase &meshInstance);
 
 /* Create the mesh node object */
@@ -68,8 +68,8 @@ String manageRequest(const String &request, MeshBackendBase &meshInstance) {
    @param meshInstance The MeshBackendBase instance that called the function.
    @return The status code resulting from the response, as an int
 */
-transmission_status_t manageResponse(const String &response, MeshBackendBase &meshInstance) {
-  transmission_status_t statusCode = TS_TRANSMISSION_COMPLETE;
+TransmissionStatusType manageResponse(const String &response, MeshBackendBase &meshInstance) {
+  TransmissionStatusType statusCode = TransmissionStatusType::TRANSMISSION_COMPLETE;
 
   // To get the actual class of the polymorphic meshInstance, do as follows (meshBackendCast replaces dynamic_cast since RTTI is disabled)
   if (EspnowMeshBackend *espnowInstance = TypeCast::meshBackendCast<EspnowMeshBackend *>(&meshInstance)) {
@@ -142,7 +142,7 @@ bool exampleTransmissionOutcomesUpdateHook(MeshBackendBase &meshInstance) {
   // The default hook only returns true and does nothing else.
 
   if (TcpIpMeshBackend *tcpIpInstance = TypeCast::meshBackendCast<TcpIpMeshBackend *>(&meshInstance)) {
-    if (tcpIpInstance->latestTransmissionOutcomes().back().transmissionStatus() == TS_TRANSMISSION_COMPLETE) {
+    if (tcpIpInstance->latestTransmissionOutcomes().back().transmissionStatus() == TransmissionStatusType::TRANSMISSION_COMPLETE) {
       // Our last request got a response, so time to create a new request.
       meshInstance.setMessage(String(F("Hello world request #")) + String(++requestNumber) + F(" from ")
                               + meshInstance.getMeshName() + meshInstance.getNodeID() + String('.'));
@@ -209,11 +209,11 @@ void loop() {
       Serial.println(F("No mesh AP found."));
     } else {
       for (TransmissionOutcome &transmissionOutcome : tcpIpNode.latestTransmissionOutcomes()) {
-        if (transmissionOutcome.transmissionStatus() == TS_TRANSMISSION_FAILED) {
+        if (transmissionOutcome.transmissionStatus() == TransmissionStatusType::TRANSMISSION_FAILED) {
           Serial.println(String(F("Transmission failed to mesh AP ")) + transmissionOutcome.SSID());
-        } else if (transmissionOutcome.transmissionStatus() == TS_CONNECTION_FAILED) {
+        } else if (transmissionOutcome.transmissionStatus() == TransmissionStatusType::CONNECTION_FAILED) {
           Serial.println(String(F("Connection failed to mesh AP ")) + transmissionOutcome.SSID());
-        } else if (transmissionOutcome.transmissionStatus() == TS_TRANSMISSION_COMPLETE) {
+        } else if (transmissionOutcome.transmissionStatus() == TransmissionStatusType::TRANSMISSION_COMPLETE) {
           // No need to do anything, transmission was successful.
         } else {
           Serial.println(String(F("Invalid transmission status for ")) + transmissionOutcome.SSID() + String('!'));

libraries/ESP8266WiFiMesh/examples/HelloTcpIp/HelloTcpIp.ino

@@ -12,7 +12,7 @@ ESP8266WiFiMesh	KEYWORD3
 # Datatypes (KEYWORD1)
 #######################################
 
-transmission_status_t	KEYWORD1
+TransmissionStatusType	KEYWORD1
 
 #######################################
 # Methods and Functions (KEYWORD2)

libraries/ESP8266WiFiMesh/keywords.txt

@@ -34,8 +34,6 @@ namespace
 {
   size_t _ctMinDataLength = 0;
   size_t _ctMaxDataLength = 1024;
-
-  bool _warningsEnabled = true;
 
   br_hkdf_context _storedHkdfContext;
   bool _hkdfContextStored = false;
@@ -186,52 +184,61 @@ namespace
     createBearsslHmacCT(hashType, message.c_str(), message.length(), hashKey, hashKeyLength, hmac, hmacLength);
     return TypeCast::uint8ArrayToHexString(hmac, hmacLength);
   }
+
+  
+  // Helper function to avoid deprecated warnings.
+  void *md5HashHelper(const void *data, const size_t dataLength, void *resultArray)
+  {
+    br_md5_context context;
+    br_md5_init(&context);
+    br_md5_update(&context, data, dataLength);
+    br_md5_out(&context, resultArray);
+    return resultArray;
+  }
+
+  // Helper function to avoid deprecated warnings.
+  void *sha1HashHelper(const void *data, const size_t dataLength, void *resultArray)
+  {    
+    br_sha1_context context;
+    br_sha1_init(&context);
+    br_sha1_update(&context, data, dataLength);
+    br_sha1_out(&context, resultArray);
+    return resultArray;
+  }
 }
 
 namespace CryptoInterface 
 {
   void setCtMinDataLength(const size_t ctMinDataLength) 
   {
-    assert(ctMaxDataLength() - ctMinDataLength <= CT_MAX_DIFF);
+    assert(getCtMaxDataLength() - ctMinDataLength <= CT_MAX_DIFF);
     _ctMinDataLength = ctMinDataLength; 
   }
-  size_t ctMinDataLength() {return _ctMinDataLength;}
+  size_t getCtMinDataLength() {return _ctMinDataLength;}
 
   void setCtMaxDataLength(const size_t ctMaxDataLength) 
   { 
-    assert(ctMaxDataLength - ctMinDataLength() <= CT_MAX_DIFF);
+    assert(ctMaxDataLength - getCtMinDataLength() <= CT_MAX_DIFF);
     _ctMaxDataLength = ctMaxDataLength; 
   }
-  size_t ctMaxDataLength() {return _ctMaxDataLength;}
-
-  void setWarningsEnabled(bool warningsEnabled) { _warningsEnabled = warningsEnabled; }
-  bool warningsEnabled() { return _warningsEnabled; }
+  size_t getCtMaxDataLength() {return _ctMaxDataLength;}
 
   void setNonceGenerator(nonceGeneratorType nonceGenerator) { _nonceGenerator = nonceGenerator; }
   nonceGeneratorType getNonceGenerator() { return _nonceGenerator; }
 
 
   // #################### MD5 ####################
-    
+  
   // resultArray must have size MD5_NATURAL_LENGTH or greater
   void *md5Hash(const void *data, const size_t dataLength, void *resultArray)
   {
-    if(warningsEnabled())
-      Serial.println(F("\nWARNING! The MD5 hash is broken in terms of attacker resistance.\n" 
-                       "Only use it in those cases where attacker resistance is not important. Prefer SHA-256 or higher otherwise.\n"
-                       "Use CryptoInterface::setWarningsEnabled(false) to turn off this warning.\n"));
-    
-    br_md5_context context;
-    br_md5_init(&context);
-    br_md5_update(&context, data, dataLength);
-    br_md5_out(&context, resultArray);
-    return resultArray;
+    return md5HashHelper(data, dataLength, resultArray);
   }
 
   String md5Hash(const String &message)
   {
     uint8_t hash[MD5_NATURAL_LENGTH];
-    md5Hash(message.c_str(), message.length(), hash);
+    md5HashHelper(message.c_str(), message.length(), hash);
     return TypeCast::uint8ArrayToHexString(hash, MD5_NATURAL_LENGTH);
   }
 
@@ -260,23 +267,14 @@ namespace CryptoInterface
 
   // resultArray must have size SHA1_NATURAL_LENGTH or greater
   void *sha1Hash(const void *data, const size_t dataLength, void *resultArray)
-  {
-    if(warningsEnabled())
-      Serial.println(F("\nWARNING! The SHA-1 hash is broken in terms of attacker resistance.\n" 
-                       "Only use it in those cases where attacker resistance is not important. Prefer SHA-256 or higher otherwise.\n"
-                       "Use CryptoInterface::setWarningsEnabled(false) to turn off this warning.\n"));
-    
-    br_sha1_context context;
-    br_sha1_init(&context);
-    br_sha1_update(&context, data, dataLength);
-    br_sha1_out(&context, resultArray);
-    return resultArray;
+  {    
+    return sha1HashHelper(data, dataLength, resultArray);
   }
 
   String sha1Hash(const String &message)
   {
     uint8_t hash[SHA1_NATURAL_LENGTH];
-    sha1Hash(message.c_str(), message.length(), hash);
+    sha1HashHelper(message.c_str(), message.length(), hash);
     return TypeCast::uint8ArrayToHexString(hash, SHA1_NATURAL_LENGTH);
   }