Update to FPP v2.1.0a10

FppTest/dp/test/ut/Tester.cpp

@@ -331,8 +331,7 @@ Fw::Time Tester::randomizeTestTime() {
 }
 
 void Tester::generateRandomString(Fw::StringBase& str) {
-    // Reserve enough space for max length plus null terminator
-    char buffer[MAX_STRING_LENGTH + 1];
+    char buffer[Fw::StringBase::BUFFER_SIZE(MAX_STRING_LENGTH)];
     // Pick a random string length
     const FwSizeType length = STest::Pick::lowerUpper(0, MAX_STRING_LENGTH);
     // Fill buffer with a random null-terminated string with that length

Fw/Cmd/CmdString.hpp

@@ -19,7 +19,7 @@
     enum {
         SERIALIZED_TYPE_ID = FW_TYPEID_CMD_STR,
         STRING_SIZE = FW_CMD_STRING_MAX_SIZE,
-        SERIALIZED_SIZE = STRING_SIZE + sizeof(FwSizeStoreType)
+        SERIALIZED_SIZE = STATIC_SERIALIZED_SIZE(STRING_SIZE),
     };
 
     CmdStringArg() : StringBase() { *this = ""; }
@@ -52,7 +52,7 @@
     StringBase::SizeType getCapacity() const { return sizeof this->m_buf; }
 
   private:
-    char m_buf[CmdStringArg::STRING_SIZE];
+    char m_buf[BUFFER_SIZE(STRING_SIZE)];
 };
 }  // namespace Fw
 

Fw/Log/LogString.hpp

@@ -19,7 +19,7 @@
     enum {
         SERIALIZED_TYPE_ID = FW_TYPEID_LOG_STR,
         STRING_SIZE = FW_LOG_STRING_MAX_SIZE,
-        SERIALIZED_SIZE = STRING_SIZE + sizeof(FwSizeStoreType)
+        SERIALIZED_SIZE = STATIC_SERIALIZED_SIZE(STRING_SIZE)
     };
 
     LogStringArg() : StringBase() { *this = ""; }
@@ -52,7 +52,7 @@
     StringBase::SizeType getCapacity() const { return sizeof this->m_buf; }
 
   private:
-    char m_buf[LogStringArg::STRING_SIZE];
+    char m_buf[BUFFER_SIZE(STRING_SIZE)];
 };
 }  // namespace Fw
 

Fw/Log/TextLogString.hpp

@@ -19,7 +19,7 @@
     enum {
         SERIALIZED_TYPE_ID = FW_TYPEID_LOG_STR,
         STRING_SIZE = FW_LOG_TEXT_BUFFER_SIZE,
-        SERIALIZED_SIZE = STRING_SIZE + sizeof(FwSizeStoreType)
+        SERIALIZED_SIZE = STATIC_SERIALIZED_SIZE(STRING_SIZE)
     };
 
     TextLogString() : StringBase() { *this = ""; }
@@ -52,7 +52,7 @@
     StringBase::SizeType getCapacity() const { return sizeof this->m_buf; }
 
   private:
-    char m_buf[TextLogString::STRING_SIZE];
+    char m_buf[BUFFER_SIZE(STRING_SIZE)];
 };
 }  // namespace Fw
 

Fw/Prm/PrmBuffer.hpp

@@ -16,8 +16,14 @@
 #include <Fw/Types/Serializable.hpp>
 #include <Fw/Cfg/SerIds.hpp>
 
+#include "Fw/Types/StringBase.hpp"
+
+
 namespace Fw {
 
+    static_assert(FW_PARAM_BUFFER_MAX_SIZE >= StringBase::BUFFER_SIZE(FW_PARAM_STRING_MAX_SIZE),
+                  "param string must fit into param buffer");
+
     class ParamBuffer : public SerializeBufferBase {
         public:
 

Fw/Prm/PrmString.hpp

@@ -19,7 +19,7 @@ class ParamString : public StringBase {
     enum {
         SERIALIZED_TYPE_ID = FW_TYPEID_PRM_STR,
         STRING_SIZE = FW_PARAM_STRING_MAX_SIZE,
-        SERIALIZED_SIZE = STRING_SIZE + sizeof(FwSizeStoreType)
+        SERIALIZED_SIZE = STATIC_SERIALIZED_SIZE(STRING_SIZE)
     };
 
     ParamString() : StringBase() { *this = ""; }
@@ -52,7 +52,7 @@ class ParamString : public StringBase {
     StringBase::SizeType getCapacity() const { return sizeof this->m_buf; }
 
   private:
-    char m_buf[ParamString::STRING_SIZE];
+    char m_buf[BUFFER_SIZE(STRING_SIZE)];
 };
 }  // namespace Fw
 

Fw/Test/String.hpp

@@ -18,7 +18,7 @@
   public:
     enum {
         STRING_SIZE = 256,
-        SERIALIZED_SIZE = STRING_SIZE + sizeof(FwSizeStoreType)
+        SERIALIZED_SIZE = STATIC_SERIALIZED_SIZE(STRING_SIZE),
     };
 
     String() : StringBase() { *this = ""; }
@@ -49,7 +49,7 @@
     StringBase::SizeType getCapacity() const { return sizeof this->m_buf; }
 
   private:
-    char m_buf[String::STRING_SIZE];
+    char m_buf[BUFFER_SIZE(STRING_SIZE)];
 };
 }  // namespace Fw
 

Fw/Tlm/TlmString.hpp

@@ -19,7 +19,7 @@
     enum {
         SERIALIZED_TYPE_ID = FW_TYPEID_TLM_STR,
         STRING_SIZE = FW_TLM_STRING_MAX_SIZE,
-        SERIALIZED_SIZE = STRING_SIZE + sizeof(FwSizeStoreType)
+        SERIALIZED_SIZE = STATIC_SERIALIZED_SIZE(STRING_SIZE)
     };
 
     TlmString() : StringBase() { *this = ""; }
@@ -52,7 +52,7 @@
     StringBase::SizeType getCapacity() const { return sizeof this->m_buf; }
 
   private:
-    char m_buf[TlmString::STRING_SIZE];
+    char m_buf[BUFFER_SIZE(STRING_SIZE)];
 };
 }  // namespace Fw
 

Fw/Types/FileNameString.hpp

@@ -20,7 +20,7 @@
     enum {
         SERIALIZED_TYPE_ID = FW_TYPEID_FILE_NAME_STRING,
         STRING_SIZE = FileNameStringSize,
-        SERIALIZED_SIZE = STRING_SIZE + sizeof(FwSizeStoreType)
+        SERIALIZED_SIZE = STATIC_SERIALIZED_SIZE(STRING_SIZE)
     };
 
     FileNameString() : StringBase() { *this = ""; }
@@ -53,7 +53,7 @@
     StringBase::SizeType getCapacity() const { return sizeof this->m_buf; }
 
   private:
-    char m_buf[FileNameString::STRING_SIZE];
+    char m_buf[BUFFER_SIZE(STRING_SIZE)];
 };
 }  // namespace Fw
 

Fw/Types/InternalInterfaceString.hpp

@@ -20,7 +20,7 @@
     enum {
         SERIALIZED_TYPE_ID = FW_TYPEID_INTERNAL_INTERFACE_STRING,
         STRING_SIZE = FW_INTERNAL_INTERFACE_STRING_MAX_SIZE,
-        SERIALIZED_SIZE = STRING_SIZE + sizeof(FwSizeStoreType)
+        SERIALIZED_SIZE = STATIC_SERIALIZED_SIZE(STRING_SIZE)
     };
 
     InternalInterfaceString() : StringBase() { *this = ""; }
@@ -53,7 +53,7 @@
     StringBase::SizeType getCapacity() const { return sizeof this->m_buf; }
 
   private:
-    char m_buf[InternalInterfaceString::STRING_SIZE];
+    char m_buf[BUFFER_SIZE(STRING_SIZE)];
 };
 }  // namespace Fw
 

Fw/Types/ObjectName.hpp

@@ -19,7 +19,7 @@
     enum {
         SERIALIZED_TYPE_ID = FW_TYPEID_OBJECT_NAME,
         STRING_SIZE = FW_OBJ_NAME_MAX_SIZE,
-        SERIALIZED_SIZE = STRING_SIZE + sizeof(FwSizeStoreType)
+        SERIALIZED_SIZE = STATIC_SERIALIZED_SIZE(STRING_SIZE)
     };
 
     ObjectName() : StringBase() { *this = ""; }
@@ -52,7 +52,7 @@
     StringBase::SizeType getCapacity() const { return sizeof this->m_buf; }
 
   private:
-    char m_buf[ObjectName::STRING_SIZE];
+    char m_buf[BUFFER_SIZE(STRING_SIZE)];
 };
 }  // namespace Fw
 

Fw/Types/String.hpp

@@ -19,7 +19,7 @@
     enum {
         SERIALIZED_TYPE_ID = FW_TYPEID_FIXED_LENGTH_STRING,
         STRING_SIZE = FW_FIXED_LENGTH_STRING_SIZE,
-        SERIALIZED_SIZE = STRING_SIZE + sizeof(FwSizeStoreType)
+        SERIALIZED_SIZE = STATIC_SERIALIZED_SIZE(STRING_SIZE),
     };
 
     String() : StringBase() { *this = ""; }
@@ -52,7 +52,7 @@
     StringBase::SizeType getCapacity() const { return sizeof this->m_buf; }
 
   private:
-    char m_buf[String::STRING_SIZE];
+    char m_buf[BUFFER_SIZE(STRING_SIZE)];
 };
 }  // namespace Fw
 

Fw/Types/StringBase.cpp

@@ -114,7 +114,16 @@
 }
 
 StringBase::SizeType StringBase::length() const {
-    return static_cast<SizeType>(StringUtils::string_length(this->toChar(), this->getCapacity()));
+    const SizeType length = static_cast<SizeType>(StringUtils::string_length(this->toChar(), this->getCapacity()));
+    FW_ASSERT(length <= this->maxLength(), static_cast<FwAssertArgType>(length),
+              static_cast<FwAssertArgType>(this->maxLength()));
+    return length;
+}
+
+StringBase::SizeType StringBase::maxLength() const {
+    const SizeType capacity = this->getCapacity();
+    FW_ASSERT(capacity > 0, static_cast<FwAssertArgType>(capacity));
+    return capacity - 1;
 }
 
 StringBase::SizeType StringBase::serializedSize() const {
@@ -130,16 +139,34 @@
 }
 
 SerializeStatus StringBase::serialize(SerializeBufferBase& buffer, SizeType maxLength) const {
-    SizeType len = FW_MIN(maxLength, this->length());
-    return buffer.serialize(reinterpret_cast<const U8*>(this->toChar()), len);
+    const FwSizeType len = FW_MIN(maxLength, this->length());
+    // Serialize length and then bytes
+    return buffer.serialize(reinterpret_cast<const U8*>(this->toChar()), len, Serialization::INCLUDE_LENGTH);
 }
 
 SerializeStatus StringBase::deserialize(SerializeBufferBase& buffer) {
-    SizeType maxSize = this->getCapacity() - 1;
+    // Get the max size of the deserialized string
+    const FwSizeType maxSize = this->maxLength();
+    // Initial estimate of actual size is max size
+    // This estimate is refined when calling the deserialize function below
+    SizeType actualSize = maxSize;
+    // Public interface returns const char*, but implementation needs char*
+    // So use const_cast
     CHAR* raw = const_cast<CHAR*>(this->toChar());
-    SerializeStatus stat = buffer.deserialize(reinterpret_cast<U8*>(raw), maxSize);
-    // Null terminate deserialized string
-    raw[maxSize] = 0;
+    // Deserialize length
+    // Fail if length exceeds max size (the initial value of actualSize)
+    // Otherwise deserialize length bytes and set actualSize to length
+    SerializeStatus stat = buffer.deserialize(reinterpret_cast<U8*>(raw), actualSize, Serialization::INCLUDE_LENGTH);
+    if (stat == FW_SERIALIZE_OK) {
+        // Deserialization succeeded: null-terminate string at actual size
+        FW_ASSERT(actualSize <= maxSize, static_cast<FwAssertArgType>(actualSize),
+                  static_cast<FwAssertArgType>(maxSize));
+        raw[actualSize] = 0;
+    } else {
+        // Deserialization failed: leave string unmodified, but ensure that it
+        // is null-terminated
+        raw[0] = maxSize;
+    }
     return stat;
 }
 }  // namespace Fw

Fw/Types/StringBase.hpp

@@ -26,9 +26,31 @@
     virtual const CHAR* toChar() const = 0;    //<! Convert to a C-style char*
     virtual SizeType getCapacity() const = 0;  //!< return size of buffer
     SizeType length() const;                   //!< Get length of string
-    SizeType serializedSize() const;           //!< Get length of string plus size of stored size
-    SizeType serializedTruncatedSize(
-        FwSizeType maxLength) const;  //!< Get truncated length of string plus size of stored size
+
+    //! Get the maximum length of a string that the buffer can hold
+    SizeType maxLength() const;
+    //! Get the static serialized size of a string
+    //! This is the max length of the string plus the size of the stored size
+    static constexpr FwSizeType STATIC_SERIALIZED_SIZE(FwSizeType maxLength  //!< The maximum string length
+    ) {
+        return sizeof(FwSizeStoreType) + maxLength;
+    }
+
+    //! Get the size of a null-terminated string buffer
+    static constexpr FwSizeType BUFFER_SIZE(FwSizeType maxLength  //!< The maximum string length
+    ) {
+        // Reserve one byte for each character plus one for the null terminator
+        return maxLength + 1;
+    }
+
+    //! Get the dynamic serialized size of a string
+    //! This is the length of the string plus the size of the stored size
+    SizeType serializedSize() const;
+
+    //! Get the serialized truncated size of a string
+    //! This is the minimum of the dynamic serialized size and the max length
+    SizeType serializedTruncatedSize(FwSizeType maxLength  //!< The max string length
+    ) const;
 
     const CHAR* operator+=(const CHAR* src);              //!< Concatenate a CHAR*
     const StringBase& operator+=(const StringBase& src);  //!< Concatenate a StringBase

Os/QueueString.hpp

@@ -15,7 +15,7 @@
 
 class QueueString final : public Fw::StringBase {
   public:
-    enum { STRING_SIZE = FW_QUEUE_NAME_MAX_SIZE, SERIALIZED_SIZE = STRING_SIZE + sizeof(FwSizeStoreType) };
+    enum { STRING_SIZE = FW_QUEUE_NAME_MAX_SIZE, SERIALIZED_SIZE = STATIC_SERIALIZED_SIZE(STRING_SIZE) };
 
     QueueString() : StringBase() { *this = ""; }
 
@@ -47,7 +47,7 @@
     StringBase::SizeType getCapacity() const { return sizeof this->m_buf; }
 
   private:
-    char m_buf[QueueString::STRING_SIZE];
+    char m_buf[BUFFER_SIZE(STRING_SIZE)];
 };
 }  // namespace Os
 

Os/TaskString.hpp

@@ -15,7 +15,7 @@
 
 class TaskString final : public Fw::StringBase {
   public:
-    enum { STRING_SIZE = FW_TASK_NAME_MAX_SIZE, SERIALIZED_SIZE = STRING_SIZE + sizeof(FwSizeStoreType) };
+    enum { STRING_SIZE = FW_TASK_NAME_MAX_SIZE, SERIALIZED_SIZE = STATIC_SERIALIZED_SIZE(STRING_SIZE) };
 
     TaskString() : StringBase() { *this = ""; }
 
@@ -47,7 +47,7 @@
     StringBase::SizeType getCapacity() const { return sizeof this->m_buf; }
 
   private:
-    char m_buf[TaskString::STRING_SIZE];
+    char m_buf[BUFFER_SIZE(STRING_SIZE)];
 };
 }  // namespace Os
 

Svc/BufferLogger/test/ut/Logging.cpp

@@ -96,7 +96,7 @@ namespace Svc {
         //! Run a test
         void test(
             const U32 numFiles, //!< The number of files to create
-            const char *const baseName //!< The baseName to use
+            const Fw::CmdStringArg& baseName //!< The baseName to use
         ) {
           this->sendCmd_BL_OpenFile(0, 0, baseName);
           this->dispatchOne();
@@ -105,7 +105,7 @@ namespace Svc {
           currentFileName.format(
               "%s%s%s",
               this->component.m_file.m_prefix.toChar(),
-              baseName,
+              baseName.toChar(),
               this->component.m_file.m_suffix.toChar()
           );
           this->sendBuffers(1);
@@ -123,7 +123,7 @@ namespace Svc {
             currentFileName.format(
                 "%s%s%d%s",
                 this->component.m_file.m_prefix.toChar(),
-                baseName,
+                baseName.toChar(),
                 i,
                 this->component.m_file.m_suffix.toChar()
             );
@@ -147,15 +147,15 @@ namespace Svc {
                 fileName.format(
                     "%s%s%s",
                     this->component.m_file.m_prefix.toChar(),
-                    baseName,
+                    baseName.toChar(),
                     this->component.m_file.m_suffix.toChar()
                 );
             }
             else {
                 fileName.format(
                     "%s%s%d%s",
                     this->component.m_file.m_prefix.toChar(),
-                    baseName,
+                    baseName.toChar(),
                     i,
                     this->component.m_file.m_suffix.toChar()
                 );