!3 增加新的接口，修复字符串参数校验内存溢出风险

Merge pull request !3 from 大橙子疯/develop

cot_param.c

@@ -3,8 +3,8 @@
   * @file    cot_param.c
   * @brief   该文件提供参数管理框架功能
   * @author  const_zpc  any question please send mail to const_zpc@163.com
-  * @version V2.0
+  * @version V2.1
-  * @date    2023-12-10
+  * @date    2024-1-31
   *
   * @details  功能详细说明：
   *           + 参数修改和重置管理
@@ -33,7 +33,7 @@ typedef union
     int64_t s64val;
     double fVal;
 #if COT_PARAM_USE_STRING_TYPE
-    char str[COT_PARAM_STRING_MAX_LENGTH + 2];
+    char str[COT_PARAM_STRING_MAX_LENGTH];
 #endif
 } Value_u;
 
@@ -446,7 +446,7 @@ const cotParamInfo_t *cotParam_FindParamByParamPtr(const cotParamManager_t *pMan
 {
     cotParamInfo_t *pInfo;
 
-    if (pManager != NULL)
+    if (pManager != NULL || pCurParam != NULL)
     {
         pInfo = FindParamByParamPtr(pManager, pCurParam);
 
@@ -603,6 +603,8 @@ static cotParamCheckRet_e ValidateRangeByVoid(const cotParamInfo_t *pParam, cons
 {
     Value_u uValue;
 
+    memset(&uValue, 0, sizeof(uValue));
+
     switch (pParam->type)
     {
     case COT_PARAM_INT8:
@@ -647,8 +649,7 @@ static cotParamCheckRet_e ValidateRangeByVoid(const cotParamInfo_t *pParam, cons
 #endif
 #if COT_PARAM_USE_STRING_TYPE
     case COT_PARAM_STRING:
-        memcpy(uValue.str, pval, strlen(pval) > COT_PARAM_STRING_MAX_LENGTH ? COT_PARAM_STRING_MAX_LENGTH + 2 : strlen(pval) + 1);
+        memcpy(uValue.str, pval, strlen(pval) >= COT_PARAM_STRING_MAX_LENGTH ? COT_PARAM_STRING_MAX_LENGTH - 1 : strlen(pval));
-        uValue.str[COT_PARAM_STRING_MAX_LENGTH + 2] = '\0';
         break;
 #endif
     default:
@@ -1354,4 +1355,135 @@ int cotParam_Deserialization(const cotParamManager_t* pManager, const uint8_t *p
     return 0;
 }
 
+/**
+  * @brief      修改参数值，新值校验不通过则不修改
+  * 
+  * @note       该函数主要是方便进行二次函数封装，隐藏参数表管理句柄入参，可参考 cotParam_SingleParamChange 的实现
+  * @param      pManager   参数表管理句柄
+  * @param      pCurParam  当前参数数据指针
+  * @param      paramList  可变参数列表
+  * @return     0,成功; -1,失败; 
+  */
+int cotParam_SingleParamChangeImpl(const cotParamManager_t* pManager, const void *pCurParam, va_list paramList)
+{
+    const cotParamInfo_t *pParam = cotParam_FindParamByParamPtr(pManager, pCurParam);
+
+    if (pParam == NULL)
+    {
+        return -1;
+    }
+
+    switch (pParam->type)
+    {
+    case COT_PARAM_INT8:
+    {
+        COT_PARAM_INT8_T val = (COT_PARAM_INT8_T)va_arg(paramList, COT_PARAM_INT32_T);
+        cotParam_SingleParamUpdate(pParam, &val, COT_PARAM_RESET_NONE);
+    }
+        break;
+
+    case COT_PARAM_INT16:
+    {
+        COT_PARAM_INT16_T val = (COT_PARAM_INT16_T)va_arg(paramList, COT_PARAM_INT32_T);
+        cotParam_SingleParamUpdate(pParam, &val, COT_PARAM_RESET_NONE);
+    }
+        break;
+
+    case COT_PARAM_INT32:
+    {
+        COT_PARAM_INT32_T val = (COT_PARAM_INT32_T)va_arg(paramList, COT_PARAM_INT32_T);
+        cotParam_SingleParamUpdate(pParam, &val, COT_PARAM_RESET_NONE);
+    }
+        break;
+#if COT_PARAM_USE_64_BIT_LENGTH
+    case COT_PARAM_INT64:
+    {
+        COT_PARAM_INT64_T val = (COT_PARAM_INT64_T)va_arg(paramList, COT_PARAM_INT64_T);
+        cotParam_SingleParamUpdate(pParam, &val, COT_PARAM_RESET_NONE);
+    }
+        break;
+#endif
+    case COT_PARAM_UINT8:
+    {
+        COT_PARAM_UINT8_T val = (COT_PARAM_UINT8_T)va_arg(paramList, COT_PARAM_UINT32_T);
+        cotParam_SingleParamUpdate(pParam, &val, COT_PARAM_RESET_NONE);
+    }
+        break;
+
+    case COT_PARAM_UINT16:
+    {
+        COT_PARAM_UINT16_T val = (COT_PARAM_UINT16_T)va_arg(paramList, COT_PARAM_UINT32_T);
+        cotParam_SingleParamUpdate(pParam, &val, COT_PARAM_RESET_NONE);
+    }
+        break;
+
+    case COT_PARAM_UINT32:
+    {
+        COT_PARAM_UINT32_T val = (COT_PARAM_UINT32_T)va_arg(paramList, COT_PARAM_UINT32_T);
+        cotParam_SingleParamUpdate(pParam, &val, COT_PARAM_RESET_NONE);
+    }
+        break;
+#if COT_PARAM_USE_64_BIT_LENGTH
+    case COT_PARAM_UINT64:
+    {
+        COT_PARAM_UINT64_T val = (COT_PARAM_UINT64_T)va_arg(paramList, COT_PARAM_UINT64_T);
+        cotParam_SingleParamUpdate(pParam, &val, COT_PARAM_RESET_NONE);
+    }
+        break;
+#endif
+    case COT_PARAM_FLOAT:
+    {
+        COT_PARAM_FLOAT_T val = (COT_PARAM_FLOAT_T)va_arg(paramList, COT_PARAM_DOUBLE_T);
+        cotParam_SingleParamUpdate(pParam, &val, COT_PARAM_RESET_NONE);
+    }
+        break;
+#if COT_PARAM_USE_64_BIT_LENGTH
+    case COT_PARAM_DOUBLE:
+    {
+        COT_PARAM_DOUBLE_T val = (COT_PARAM_DOUBLE_T)va_arg(paramList, COT_PARAM_DOUBLE_T);
+        cotParam_SingleParamUpdate(pParam, &val, COT_PARAM_RESET_NONE);
+    }
+        break;
+#endif
+#if COT_PARAM_USE_STRING_TYPE
+    case COT_PARAM_STRING:
+        {
+            char *pszString = (char *)va_arg(paramList, char *);
+            char szString[COT_PARAM_STRING_MAX_LENGTH] = {0};
+
+            memcpy(szString, pszString, strlen(pszString) >= COT_PARAM_STRING_MAX_LENGTH ? 
+                            (COT_PARAM_STRING_MAX_LENGTH - 1) : strlen(pszString));
+            cotParam_SingleParamUpdate(pParam, szString, COT_PARAM_RESET_NONE);
+        }
+        break;
+#endif
+    default:
+        return -1;
+    }
+    
+    return 0;
+}
+
+/**
+  * @brief      修改参数值，新值校验不通过则不修改
+  * 
+  * @code       如：cotParam_SingleParamChange(&sg_tParamManager, &g_test_u16, 60)
+  * @param      pManager   参数表管理句柄
+  * @param      pCurParam  当前参数数据指针
+  * @param      ... 新值（只有一个参数）
+  * @return     0,成功; -1,失败; 
+  */
+int cotParam_SingleParamChange(const cotParamManager_t* pManager, const void *pCurParam, ...)
+{
+    int ret = 0;
+    va_list paramList;
+
+    va_start(paramList, pCurParam);
+
+    ret = cotParam_SingleParamChangeImpl(pManager, pCurParam, paramList);
+
+    va_end(paramList);
+
+    return ret;
+}
 

cot_param.h

@@ -16,6 +16,8 @@
 /* Includes ----------------------------------------------------------------------------------------------------------*/
 #include "cot_param_type.h"
 
+#include <stdarg.h>
+
 #ifdef __cplusplus
  extern "C" {
 #endif 
@@ -159,6 +161,9 @@ extern int cotParam_SingleParamResetDefValue(const cotParamInfo_t *pParam);
 extern int cotParam_SingleParamResetMinValue(const cotParamInfo_t *pParam);
 extern int cotParam_SingleParamResetMaxValue(const cotParamInfo_t *pParam);
 
+extern int cotParam_SingleParamChangeImpl(const cotParamManager_t* pManager, const void *pCurParam, va_list paramList);
+extern int cotParam_SingleParamChange(const cotParamManager_t* pManager, const void *pCurParam, ...);
+
 #ifdef __cplusplus
  }
 #endif

examples/cmd_shell/demo.c

@@ -30,6 +30,13 @@ int main()
     // g_test_3 = -20.5;
     sprintf(g_szString, "sd");
 
+    SingleParamChange(&g_tTestVal.uiValue, 1500);
+
+    SingleParamChange(&g_tTestVal.uiValue, 800); // 修改无效
+
+    SingleParamChange(g_tTestVal.szString_1, "wwww.bau");
+    SingleParamChange(g_tTestVal.szString_1, "ww");  // 修改无效
+
     SaveParam(true);
     ReloadParam(true);
 

examples/cmd_shell/param_demo.c

@@ -509,3 +509,14 @@ void ShowAllParam(void)
     printf("\n");
 }
 
+void SingleParamChange(const void *pCurParam, ...)
+{
+    va_list paramList;
+
+    va_start(paramList, pCurParam);
+
+    cotParam_SingleParamChangeImpl(&sg_tParamManager, pCurParam, paramList);
+
+    va_end(paramList);
+}
+

examples/cmd_shell/param_demo.h

@@ -35,6 +35,7 @@ cotParamCheckRet_e SingleParamCheck(const void *pCurParam, const void *pCheckVal
 cotParamCheckRet_e SingleParamSelfCheck(const void *pCurParam);
 
 void SingleParamResetResetDefValue(const void *pCurParam);
+void SingleParamChange(const void *pCurParam, ...);
 
 void ShowAllParam(void);
 #endif

test/param_test.c

@@ -566,6 +566,27 @@ void test_ResetValue(void)
     TEST_ASSERT_EQUAL_UINT(3000, g_test_u16);
 }
 
+void test_ChangeValue(void)
+{
+    g_test_u16 = 200;
+    TEST_ASSERT_EQUAL_INT(0, cotParam_SingleParamChange(&sg_tParamManager, &g_test_u16, 60));
+    TEST_ASSERT_EQUAL_UINT(200, g_test_u16);
+    TEST_ASSERT_EQUAL_INT(0, cotParam_SingleParamChange(&sg_tParamManager, &g_test_u16, 120));
+    TEST_ASSERT_EQUAL_UINT(120, g_test_u16);
+    TEST_ASSERT_EQUAL_INT(0, cotParam_SingleParamChange(&sg_tParamManager, &g_test_u16, 4000));
+    TEST_ASSERT_EQUAL_UINT(120, g_test_u16);
+
+#if COT_PARAM_USE_STRING_TYPE
+    strcpy(g_test_str, "123456");
+    TEST_ASSERT_EQUAL_INT(0, cotParam_SingleParamChange(&sg_tParamManager, g_test_str, "ABCDEF"));
+    TEST_ASSERT_EQUAL_STRING("ABCDEF", g_test_str);
+    TEST_ASSERT_EQUAL_INT(0, cotParam_SingleParamChange(&sg_tParamManager, g_test_str, "ABCD"));
+    TEST_ASSERT_EQUAL_STRING("ABCDEF", g_test_str);
+    TEST_ASSERT_EQUAL_INT(0, cotParam_SingleParamChange(&sg_tParamManager, g_test_str, "ABCDEF123456"));
+    TEST_ASSERT_EQUAL_STRING("ABCDEF", g_test_str);
+#endif
+}
+
 // Run the test suite
 int main(void)
 {
@@ -580,6 +601,7 @@ int main(void)
     RUN_TEST(test_CheckCustomWay);
     RUN_TEST(test_SetNewValue);
     RUN_TEST(test_ResetValue);
+    RUN_TEST(test_ChangeValue);
 
     UNITY_END();