Centralizing usages of strlen and memcpy

lib/LinkMobile.hpp

@@ -62,7 +62,6 @@
 
 #include "_link_common.hpp"
 
-#include <cstring>
 #include "LinkGPIO.hpp"
 #include "LinkSPI.hpp"
 
@@ -369,7 +368,7 @@ class LinkMobile {
     auto request = UserRequest{.type = UserRequest::Type::PPP_LOGIN};
     copyString(request.password, password, LINK_MOBILE_MAX_PASSWORD_LENGTH);
 
-    if (std::strlen(loginId) > 0)
+    if (LINK_STRLEN(loginId) > 0)
       copyString(request.loginId, loginId, LINK_MOBILE_MAX_LOGIN_ID_LENGTH);
     else if (adapterConfiguration.isValid())
       copyString(request.loginId, adapterConfiguration.fields._ispNumber1,
@@ -399,7 +398,7 @@ class LinkMobile {
 
     result->completed = false;
     result->success = false;
-    u32 size = std::strlen(domainName);
+    u32 size = LINK_STRLEN(domainName);
     if (size > LINK_MOBILE_MAX_DOMAIN_NAME_LENGTH)
       size = LINK_MOBILE_MAX_DOMAIN_NAME_LENGTH;
 
@@ -1364,7 +1363,7 @@ class LinkMobile {
 
   void cmdDialTelephone(const char* phoneNumber) {
     addData(DIAL_PHONE_FIRST_BYTE[adapterType], true);
-    for (u32 i = 0; i < std::strlen(phoneNumber); i++)
+    for (u32 i = 0; i < LINK_STRLEN(phoneNumber); i++)
       addData(phoneNumber[i]);
     sendCommandAsync(buildCommand(COMMAND_DIAL_TELEPHONE, true));
   }
@@ -1400,12 +1399,12 @@ class LinkMobile {
   }
 
   void cmdISPLogin(const char* loginId, const char* password) {
-    u32 loginIdLength = std::strlen(loginId);
+    u32 loginIdLength = LINK_STRLEN(loginId);
     addData(loginIdLength, true);
     for (u32 i = 0; i < loginIdLength; i++)
       addData(loginId[i]);
 
-    u32 passwordLength = std::strlen(password);
+    u32 passwordLength = LINK_STRLEN(password);
     addData(passwordLength);
     for (u32 i = 0; i < passwordLength; i++)
       addData(password[i]);
@@ -1506,7 +1505,7 @@ class LinkMobile {
   }
 
   void copyString(char* target, const char* source, u32 length) {
-    u32 len = std::strlen(source);
+    u32 len = LINK_STRLEN(source);
 
     for (u32 i = 0; i < length + 1; i++)
       if (i < len)

lib/LinkRawWireless.hpp

@@ -15,7 +15,6 @@
 #include "_link_common.hpp"
 
 #include <array>
-#include <cstring>
 #include "LinkGPIO.hpp"
 #include "LinkSPI.hpp"
 
@@ -221,12 +220,12 @@ class LinkRawWireless {
                  u16 gameId = LINK_RAW_WIRELESS_MAX_GAME_ID,
                  bool _validateNames = true) {
     if (_validateNames &&
-        std::strlen(gameName) > LINK_RAW_WIRELESS_MAX_GAME_NAME_LENGTH) {
+        LINK_STRLEN(gameName) > LINK_RAW_WIRELESS_MAX_GAME_NAME_LENGTH) {
       LRWLOG("! game name too long");
       return false;
     }
     if (_validateNames &&
-        std::strlen(userName) > LINK_RAW_WIRELESS_MAX_USER_NAME_LENGTH) {
+        LINK_STRLEN(userName) > LINK_RAW_WIRELESS_MAX_USER_NAME_LENGTH) {
       LRWLOG("! user name too long");
       return false;
     }
@@ -850,7 +849,7 @@ class LinkRawWireless {
    * @param length Number of characters.
    */
   void copyName(char* target, const char* source, u32 length) {
-    u32 len = std::strlen(source);
+    u32 len = LINK_STRLEN(source);
 
     for (u32 i = 0; i < length + 1; i++)
       if (i < len)

lib/LinkWireless.hpp

@@ -347,9 +347,9 @@ class LinkWireless {
     if (linkRawWireless->getState() != LinkWireless::State::AUTHENTICATED &&
         linkRawWireless->getState() != LinkWireless::State::SERVING)
       return badRequest(WRONG_STATE);
-    if (std::strlen(gameName) > LINK_WIRELESS_MAX_GAME_NAME_LENGTH)
+    if (LINK_STRLEN(gameName) > LINK_WIRELESS_MAX_GAME_NAME_LENGTH)
       return badRequest(GAME_NAME_TOO_LONG);
-    if (std::strlen(userName) > LINK_WIRELESS_MAX_USER_NAME_LENGTH)
+    if (LINK_STRLEN(userName) > LINK_WIRELESS_MAX_USER_NAME_LENGTH)
       return badRequest(USER_NAME_TOO_LONG);
 
     isSendingSyncCommand = true;
@@ -484,9 +484,9 @@ class LinkWireless {
       Server server;
       server.id = foundServers[i].id;
       server.gameId = foundServers[i].gameId;
-      std::memcpy(server.gameName, foundServers[i].gameName,
+      LINK_MEMCPY(server.gameName, foundServers[i].gameName,
                   LINK_WIRELESS_MAX_GAME_NAME_LENGTH + 1);
-      std::memcpy(server.userName, foundServers[i].userName,
+      LINK_MEMCPY(server.userName, foundServers[i].userName,
                   LINK_WIRELESS_MAX_USER_NAME_LENGTH + 1);
       u8 nextClientNumber = foundServers[i].nextClientNumber;
       server.currentPlayerCount =

lib/_link_common.hpp

@@ -12,6 +12,22 @@
 #define LINK_ENABLE_DEBUG_LOGS 0
 #endif
 
+/**
+ * @brief strlen(...) implementation (by default, std::strlen)
+ */
+#ifndef LINK_STRLEN
+#include <cstring>
+#define LINK_STRLEN std::strlen
+#endif
+
+/**
+ * @brief memcpy(...) implementation (by default, std::memcpy)
+ */
+#ifndef LINK_MEMCPY
+#include <cstring>
+#define LINK_MEMCPY std::memcpy
+#endif
+
 #if LINK_ENABLE_DEBUG_LOGS != 0
 #include <stdarg.h>
 #include <stdio.h>

lib/c_bindings/C_LinkRawWireless.cpp

@@ -105,10 +105,10 @@ bool C_LinkRawWireless_broadcastReadPoll(
   for (u32 i = 0; i < response->serversSize; i++) {
     response->servers[i].id = nativeResponse.servers[i].id;
     response->servers[i].gameId = nativeResponse.servers[i].gameId;
-    std::memcpy(response->servers[i].gameName,
+    LINK_MEMCPY(response->servers[i].gameName,
                 nativeResponse.servers[i].gameName,
                 LINK_RAW_WIRELESS_MAX_GAME_NAME_LENGTH + 1);
-    std::memcpy(response->servers[i].userName,
+    LINK_MEMCPY(response->servers[i].userName,
                 nativeResponse.servers[i].userName,
                 LINK_RAW_WIRELESS_MAX_USER_NAME_LENGTH + 1);
     response->servers[i].nextClientNumber =
@@ -146,7 +146,7 @@ bool C_LinkRawWireless_sendData(C_LinkRawWirelessHandle handle,
                                 u32 dataSize,
                                 u32 _bytes) {
   std::array<u32, LINK_RAW_WIRELESS_MAX_COMMAND_TRANSFER_LENGTH> dataArray;
-  std::memcpy(dataArray.data(), data, dataSize * sizeof(u32));
+  LINK_MEMCPY(dataArray.data(), data, dataSize * sizeof(u32));
   return static_cast<LinkRawWireless*>(handle)->sendData(dataArray, dataSize,
                                                          _bytes);
 }
@@ -159,13 +159,13 @@ bool C_LinkRawWireless_sendDataAndWait(
     u32 _bytes) {
   std::array<u32, LINK_RAW_WIRELESS_MAX_COMMAND_TRANSFER_LENGTH> dataArray;
   LinkRawWireless::RemoteCommand nativeRemoteCommand;
-  std::memcpy(dataArray.data(), data, dataSize * sizeof(u32));
+  LINK_MEMCPY(dataArray.data(), data, dataSize * sizeof(u32));
   bool success = static_cast<LinkRawWireless*>(handle)->sendDataAndWait(
       dataArray, dataSize, nativeRemoteCommand, _bytes);
   remoteCommand->success = nativeRemoteCommand.success;
   remoteCommand->commandId = nativeRemoteCommand.commandId;
   remoteCommand->paramsSize = nativeRemoteCommand.paramsSize;
-  std::memcpy(remoteCommand->params, nativeRemoteCommand.params,
+  LINK_MEMCPY(remoteCommand->params, nativeRemoteCommand.params,
               LINK_RAW_WIRELESS_MAX_COMMAND_TRANSFER_LENGTH * sizeof(u32));
   return success;
 }
@@ -194,7 +194,7 @@ bool C_LinkRawWireless_wait(C_LinkRawWirelessHandle handle,
   remoteCommand->success = nativeRemoteCommand.success;
   remoteCommand->commandId = nativeRemoteCommand.commandId;
   remoteCommand->paramsSize = nativeRemoteCommand.paramsSize;
-  std::memcpy(remoteCommand->params, nativeRemoteCommand.params,
+  LINK_MEMCPY(remoteCommand->params, nativeRemoteCommand.params,
               LINK_RAW_WIRELESS_MAX_COMMAND_TRANSFER_LENGTH * sizeof(u32));
   return success;
 }