From 0c7c0abf3bdb227d947ec6b34222c24a660e51fd Mon Sep 17 00:00:00 2001
From: pm2qzlfkv <3316749729@qq.com>
Date: Mon, 4 Dec 2023 19:21:59 +0800
Subject: [PATCH] ADD file via upload

---
 sample_usr_lms.c | 258 +++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 258 insertions(+)
 create mode 100644 sample_usr_lms.c

diff --git a/sample_usr_lms.c b/sample_usr_lms.c
new file mode 100644
index 00000000..dc34d2a8
--- /dev/null
+++ b/sample_usr_lms.c
@@ -0,0 +1,258 @@
+/*
+ * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
+ * Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this list of
+ * conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice, this list
+ * of conditions and the following disclaimer in the documentation and/or other materials
+ * provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors may be used
+ * to endorse or promote products derived from this software without specific prior written
+ * permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+//函数BufWriteTest用于向给定的缓冲区中写入字符'a'，从指定的start位置开始，一直到end位置。
+static void BufWriteTest(void *buf, int start, int end)
+{
+    for (int i = start; i <= end; i++) {
+        ((char *)buf)[i] = 'a';
+    }
+}
+//函数BufReadTest则是读取给定的缓冲区中的内容，从start位置开始，一直到end位置，但是读取的内容并未被使用。
+static void BufReadTest(void *buf, int start, int end)
+{
+    char tmp;
+    for (int i = start; i <= end; i++) {
+        tmp = ((char *)buf)[i];
+    }
+}
+//函数LmsMallocTest首先分配了一个大小为TEST_SIZE的内存块，然后尝试在[-1, TEST_SIZE]的范围内进行读写操作，预期是触发读写溢出的错误。然后它释放了这块内存。
+static void LmsMallocTest(void)
+{
+#define TEST_SIZE 16
+    printf("\n-------- LmsMallocTest Start --------\n");
+    char *buf = (char *)malloc(TEST_SIZE);
+    if (buf == NULL) {
+        return;
+    }
+    printf("[LmsMallocTest] read overflow & underflow error should be triggered, read range[-1, TEST_SIZE]\n");
+    BufReadTest(buf, -1, TEST_SIZE);
+    printf("[LmsMallocTest] write overflow error should be triggered, write range[0, TEST_SIZE]\n");
+    BufWriteTest(buf, 0, TEST_SIZE);
+
+    free(buf);
+    printf("\n-------- LmsMallocTest End --------\n");
+}
+//函数LmsReallocTest首先分配了一个大小为TEST_SIZE的内存块，然后在[-1, TEST_SIZE]的范围内进行读操作，预期是触发读写溢出的错误。然后它尝试将这块内存的大小调整为TEST_SIZE_MIN，并再次在[-1, TEST_SIZE_MIN]的范围内进行读操作，预期同样是触发读写溢出的错误。最后，它释放了这块内存
+static void LmsReallocTest(void)
+{
+#define TEST_SIZE     64
+#define TEST_SIZE_MIN 32
+    printf("\n-------- LmsReallocTest Start --------\n");
+    char *buf = (char *)malloc(TEST_SIZE);
+    printf("[LmsReallocTest] read overflow & underflow error should be triggered, read range[-1, TEST_SIZE]\n");
+    BufReadTest(buf, -1, TEST_SIZE);
+    char *buf1 = (char *)realloc(buf, TEST_SIZE_MIN);
+    if (buf1 == NULL) {
+        free(buf);
+        return;
+    }
+    buf = NULL;
+    printf("[LmsReallocTest] read overflow & underflow error should be triggered, read range[-1, TEST_SIZE_MIN]\n");
+    BufReadTest(buf1, -1, TEST_SIZE_MIN);
+    free(buf1);
+    printf("\n-------- LmsReallocTest End --------\n");
+}
+// 此函数使用calloc函数分配内存，calloc会初始化分配的内存为零。然后它调用BufReadTest函数来读取分配的内存范围，但实际上并未使用这块内存。如果内存分配失败，则calloc返回NULL，函数会直接返回。最后，使用free释放内存。
+static void LmsCallocTest(void)
+{
+#define TEST_SIZE 16
+    printf("\n-------- LmsCallocTest Start --------\n");
+    char *buf = (char *)calloc(4, 4); /* 4: test size */
+    if (buf == NULL) {
+        return;
+    }
+    printf("[LmsCallocTest] read overflow & underflow error should be triggered, read range[-1, TEST_SIZE]\n");
+    BufReadTest(buf, -1, TEST_SIZE);
+    free(buf);
+    printf("\n-------- LmsCallocTest End --------\n");
+}
+//LmsVallocTest: 此函数使用valloc函数分配内存，valloc会根据页的边界来分配内存。然后它调用BufReadTest函数来读取分配的内存范围。如果内存分配失败，则valloc返回NULL，函数会直接返回。最后，使用free释放内存。
+static void LmsVallocTest(void)
+{
+#define TEST_SIZE 4096
+    printf("\n-------- LmsVallocTest Start --------\n");
+    char *buf = (char *)valloc(TEST_SIZE);
+    if (buf == NULL) {
+        return;
+    }
+    printf("[LmsVallocTest] read overflow & underflow error should be triggered, read range[-1, TEST_SIZE]\n");
+    BufReadTest(buf, -1, TEST_SIZE);
+    free(buf);
+    printf("\n-------- LmsVallocTest End --------\n");
+}
+//LmsAlignedAllocTest: 此函数使用aligned_alloc函数分配内存，aligned_alloc会分配一块特定对齐的内存。然后它调用BufReadTest函数来读取分配的内存范围。如果内存分配失败，则aligned_alloc返回NULL，函数会直接返回。最后，使用free释放内存。
+static void LmsAlignedAllocTest(void)
+{
+#define TEST_ALIGN_SIZE 64
+#define TEST_SIZE       128
+    printf("\n-------- LmsAlignedAllocTest Start --------\n");
+    char *buf = (char *)aligned_alloc(TEST_ALIGN_SIZE, TEST_SIZE);
+    if (buf == NULL) {
+        return;
+    }
+    printf("[LmsAlignedAllocTest] read overflow & underflow error should be triggered, read range[-1,128]\n");
+    BufReadTest(buf, -1, 128);
+    free(buf);
+    printf("\n-------- LmsAlignedAllocTest End --------\n");
+}
+//LmsMemsetTest: 此函数使用malloc函数分配内存，然后使用memset函数将该内存块设置为0。注意，这里的memset被用于填充比分配的内存还要多的字节（TEST_SIZE + 1），这可能会导致溢出错误。然后使用free释放内存。
+static void LmsMemsetTest(void)
+{
+#define TEST_SIZE 32
+    printf("\n-------- LmsMemsetTest Start --------\n");
+    char *buf = (char *)malloc(TEST_SIZE);
+    if (buf == NULL) {
+        return;
+    }
+    printf("[LmsMemsetTest] memset overflow & underflow error should be triggered, memset size:%d\n", TEST_SIZE + 1);
+    memset(buf, 0, TEST_SIZE + 1);
+    free(buf);
+    printf("\n-------- LmsMemsetTest End --------\n");
+}
+//: 该函数旨在测试memcpy函数的功能。首先，它使用malloc分配一块内存，然后尝试使用memcpy将一个数组的内容复制到这块内存中，复制的大小超过分配的内存大小，从而触发溢出错误。
+
+static void LmsMemcpyTest(void)
+{
+#define TEST_SIZE 20
+    printf("\n-------- LmsMemcpyTest Start --------\n");
+    char *buf = (char *)malloc(TEST_SIZE);
+    if (buf == NULL) {
+        return;
+    }
+    char localBuf[32] = {0}; /* 32: test size */
+    printf("[LmsMemcpyTest] memcpy overflow error should be triggered, memcpy size:%d\n", TEST_SIZE + 1);
+    memcpy(buf, localBuf, TEST_SIZE + 1);
+    free(buf);
+    printf("\n-------- LmsMemcpyTest End --------\n");
+}
+//LmsMemmoveTest: 该函数测试memmove函数的功能。memmove函数用于复制一定数量的字节从一个位置到另一个位置，即使这两个位置是重叠的。该函数尝试复制的内容超过了分配的内存大小，从而触发溢出错误。
+static void LmsMemmoveTest(void)
+{
+#define TEST_SIZE 20
+    printf("\n-------- LmsMemmoveTest Start --------\n");
+    char *buf = (char *)malloc(TEST_SIZE);
+    if (buf == NULL) {
+        return;
+    }
+    printf("[LmsMemmoveTest] memmove overflow error should be triggered\n");
+    memmove(buf + 12, buf, 10); /* 12 and 10: test size */
+    free(buf);
+    printf("\n-------- LmsMemmoveTest End --------\n");
+}
+LmsStrcpyTest: 该函数测试strcpy函数的功能。strcpy函数用于将一个字符串复制到另一个字符串。该函数尝试复制一个字符串到分配的内存中，复制的字符串长度超过了分配的内存大小，从而触发溢出错误。
+static void LmsStrcpyTest(void)
+{
+#define TEST_SIZE 16
+    printf("\n-------- LmsStrcpyTest Start --------\n");
+    char *buf = (char *)malloc(TEST_SIZE);
+    if (buf == NULL) {
+        return;
+    }
+    char *testStr = "bbbbbbbbbbbbbbbbb";
+    printf("[LmsStrcpyTest] strcpy overflow error should be triggered, src string buf size:%d\n", strlen(testStr) + 1);
+    strcpy(buf, testStr);
+    free(buf);
+    printf("\n-------- LmsStrcpyTest End --------\n");
+}
+//LmsStrcatTest: 该函数测试strcat函数的功能。strcat函数用于将一个字符串连接到另一个字符串的末尾。该函数首先分配一块内存，并尝试将一个字符串连接到这块内存的末尾，连接后的字符串长度超过了分配的内存大小，从而触发溢出错误。
+static void LmsStrcatTest(void)
+{
+#define TEST_SIZE 16
+    printf("\n-------- LmsStrcatTest Start --------\n");
+    char *buf = (char *)malloc(TEST_SIZE);
+    if (buf == NULL) {
+        return;
+    }
+    buf[0] = 'a';
+    buf[1] = 'b';
+    buf[2] = 0;
+    char *testStr = "cccccccccccccc";
+    printf("[LmsStrcatTest] strcat overflow error should be triggered, src string:%s dest string:%s"
+        "total buf size:%d\n",
+        testStr, buf, strlen(testStr) + strlen(buf) + 1);
+    strcat(buf, testStr);
+    free(buf);
+    printf("\n-------- LmsStrcatTest End --------\n");
+}
+//static void LmsFreeTest(void): 这是一个静态函数，名为LmsFreeTest，不接受任何参数并且没有返回值。该函数主要用于测试free函数的功能。
+static void LmsFreeTest(void)
+{
+#define TEST_SIZE 16
+    printf("\n-------- LmsFreeTest Start --------\n");
+    char *buf = (char *)malloc(TEST_SIZE);
+    if (buf == NULL) {
+        return;
+    }
+    printf("[LmsFreeTest] free size:%d\n", TEST_SIZE);
+    free(buf);
+    printf("[LmsFreeTest] Use after free error should be triggered, read range[1,1]\n");
+    BufReadTest(buf, 1, 1);
+    printf("[LmsFreeTest] double free error should be triggered\n");
+    free(buf);
+    printf("\n-------- LmsFreeTest End --------\n");
+}
+
+int main(int argc, char * const *argv)
+{
+    (void)argc;
+    (void)argv;
+    printf("\n############### Lms Test start ###############\n");
+    char *tmp = (char *)malloc(5000); /* 5000: test mem size */
+    if (tmp == NULL) {
+        return;
+    }
+    LmsMallocTest();
+    LmsReallocTest();
+    LmsCallocTest();
+    LmsVallocTest();
+    LmsAlignedAllocTest();
+    LmsMemsetTest();
+    LmsMemcpyTest();
+    LmsMemmoveTest();
+    LmsStrcpyTest();
+    LmsStrcatTest();
+    LmsFreeTest();
+    free(tmp);
+    printf("\n############### Lms Test End ###############\n");
+}
+//int main(int argc, char * const *argv): 定义主函数，接受命令行参数。
+//(void)argc; (void)argv;: 这两行代码忽略了命令行参数，实际上它们没有用到。
+//printf("\n############### Lms Test start ###############\n");: 打印一条消息，表示Lms测试开始。
+// *tmp = (char *)malloc(5000);: 分配一块大小为5000的内存，用于后续的测试函数。
+//if (tmp == NULL) { return; }: 检查malloc是否成功分配了内存。如果分配失败，主函数直接返回。
+//调用多个内存管理测试函数，例如LmsMallocTest()、LmsReallocTest()等。这些函数的具体实现没有在给出的代码中给出，因此我无法对它们进行注释。
+//LmsFreeTest();: 调用LmsFreeTest函数，进行free函数的测试。
+//free(tmp);: 释放之前使用malloc分配的内存。
+//printf("\n############### Lms Test End ###############\n");: 打印一条消息，表示Lms测试结束
\ No newline at end of file