From 97df963d711d17bfd927645c3a185f21abf839dd Mon Sep 17 00:00:00 2001 From: zhangxiaoyu Date: Tue, 1 Nov 2022 20:05:22 +0800 Subject: [PATCH] add ut and bugfix for device mapper and websocket Signed-off-by: zhangxiaoyu --- ...instead-of-select-for-wait_exit_fifo.patch | 4 +- 0002-add-namespace-util-UT.patch | 4 +- 0003-refactor-build-system-of-cutils-ut.patch | 4 +- ...-run-storage-layers-ut-with-non-root.patch | 4 +- 0005-add-extern-C-for-mainloop-header.patch | 4 +- 0006-add-UT-for-mainloop-and-network.patch | 4 +- 0007-add-check-for-aes-apis.patch | 159 ++++ 0008-add-ut-for-cutils-aes.patch | 142 ++++ 0009-add-ut-for-cutils-error.patch | 100 +++ 0010-ensure-argument-is-not-null.patch | 28 + 0011-add-ut-for-utils_fs.patch | 96 +++ 0012-Add-adaptation-code-for-filters.patch | 55 ++ 0013-Add-parameter-check-to-path.patch | 30 + 0014-Add-ut-for-utils_convert.patch | 134 ++++ 0015-Add-ut-for-path.patch | 187 +++++ 0016-Add-ut-for-filters.patch | 160 ++++ 0017-add-static-for-unexport-function.patch | 91 +++ 0018-add-ut-for-cutils-timestamp.patch | 296 ++++++++ 0019-fix-timestamp-ut-error.patch | 37 + 0020-improve-code-in-utils_mount_spec.patch | 45 ++ 0021-Add-ut-for-utils_mount_spec.patch | 118 +++ 0022-Add-ut-for-utils_regex.patch | 100 +++ 0023-improve-code-in-utils.c.patch | 164 +++++ 0024-add-ut-for-cutils-utils.patch | 327 +++++++++ 0025-make-sure-kill-pid-not-negative.patch | 63 ++ 0026-add-UT-for-atomic-and-map.patch | 240 ++++++ ...ry-goto-and-add-parameter-check-for-.patch | 125 ++++ 0028-Add-ut-for-verify.patch | 487 +++++++++++++ 0029-fix-error-in-utils_verify_ut.patch | 26 + 0030-add-more-test-for-string-and-map.patch | 122 ++++ ...t-if-add-device-mapper-device-failed.patch | 32 + ...ec-device-info-ref-in-grow-device-fs.patch | 59 ++ 0033-device-mapper-bugfix.patch | 72 ++ ...yncCloseSem-when-close-all-wssession.patch | 25 + ...ove-debug-information-for-console-io.patch | 187 +++++ 0036-add-ut-for-file.patch | 288 ++++++++ 0037-Add-extend-C-for-header-files.patch | 688 ++++++++++++++++++ 0038-feat-add-container-cleanup-module.patch | 589 +++++++++++++++ ...-for-websocket-receive-data-too-long.patch | 154 ++++ iSulad.spec | 41 +- 40 files changed, 5478 insertions(+), 13 deletions(-) create mode 100644 0007-add-check-for-aes-apis.patch create mode 100644 0008-add-ut-for-cutils-aes.patch create mode 100644 0009-add-ut-for-cutils-error.patch create mode 100644 0010-ensure-argument-is-not-null.patch create mode 100644 0011-add-ut-for-utils_fs.patch create mode 100644 0012-Add-adaptation-code-for-filters.patch create mode 100644 0013-Add-parameter-check-to-path.patch create mode 100644 0014-Add-ut-for-utils_convert.patch create mode 100644 0015-Add-ut-for-path.patch create mode 100644 0016-Add-ut-for-filters.patch create mode 100644 0017-add-static-for-unexport-function.patch create mode 100644 0018-add-ut-for-cutils-timestamp.patch create mode 100644 0019-fix-timestamp-ut-error.patch create mode 100644 0020-improve-code-in-utils_mount_spec.patch create mode 100644 0021-Add-ut-for-utils_mount_spec.patch create mode 100644 0022-Add-ut-for-utils_regex.patch create mode 100644 0023-improve-code-in-utils.c.patch create mode 100644 0024-add-ut-for-cutils-utils.patch create mode 100644 0025-make-sure-kill-pid-not-negative.patch create mode 100644 0026-add-UT-for-atomic-and-map.patch create mode 100644 0027-remove-unnecessary-goto-and-add-parameter-check-for-.patch create mode 100644 0028-Add-ut-for-verify.patch create mode 100644 0029-fix-error-in-utils_verify_ut.patch create mode 100644 0030-add-more-test-for-string-and-map.patch create mode 100644 0031-remove-mnt-point-if-add-device-mapper-device-failed.patch create mode 100644 0032-dec-device-info-ref-in-grow-device-fs.patch create mode 100644 0033-device-mapper-bugfix.patch create mode 100644 0034-delete-syncCloseSem-when-close-all-wssession.patch create mode 100644 0035-improve-debug-information-for-console-io.patch create mode 100644 0036-add-ut-for-file.patch create mode 100644 0037-Add-extend-C-for-header-files.patch create mode 100644 0038-feat-add-container-cleanup-module.patch create mode 100644 0039-bugfix-for-websocket-receive-data-too-long.patch diff --git a/0001-use-epoll-instead-of-select-for-wait_exit_fifo.patch b/0001-use-epoll-instead-of-select-for-wait_exit_fifo.patch index 8e08869..b143643 100644 --- a/0001-use-epoll-instead-of-select-for-wait_exit_fifo.patch +++ b/0001-use-epoll-instead-of-select-for-wait_exit_fifo.patch @@ -1,7 +1,7 @@ From f9cb1b86511fac1c3a7f11fdaa4c9c20dc889068 Mon Sep 17 00:00:00 2001 From: zhangxiaoyu Date: Sun, 9 Oct 2022 19:00:38 +0800 -Subject: [PATCH 01/35] use epoll instead of select for wait_exit_fifo +Subject: [PATCH 01/39] use epoll instead of select for wait_exit_fifo Signed-off-by: zhangxiaoyu --- @@ -154,5 +154,5 @@ index b9099a74..5124b33a 100644 #define EPOLL_LOOP_HANDLE_CONTINUE 0 -- -2.37.3 +2.25.1 diff --git a/0002-add-namespace-util-UT.patch b/0002-add-namespace-util-UT.patch index d129451..5d794d4 100644 --- a/0002-add-namespace-util-UT.patch +++ b/0002-add-namespace-util-UT.patch @@ -1,7 +1,7 @@ From 864a500f18d56aebeaa71960f10791386212b18b Mon Sep 17 00:00:00 2001 From: haozi007 Date: Thu, 13 Oct 2022 15:55:08 +0800 -Subject: [PATCH 02/35] add namespace util UT +Subject: [PATCH 02/39] add namespace util UT Signed-off-by: haozi007 --- @@ -151,5 +151,5 @@ index 00000000..da50d503 +} \ No newline at end of file -- -2.37.3 +2.25.1 diff --git a/0003-refactor-build-system-of-cutils-ut.patch b/0003-refactor-build-system-of-cutils-ut.patch index 4cb6e2b..6027a44 100644 --- a/0003-refactor-build-system-of-cutils-ut.patch +++ b/0003-refactor-build-system-of-cutils-ut.patch @@ -1,7 +1,7 @@ From d1061efc9a83df659f5aeab57352b9247380217a Mon Sep 17 00:00:00 2001 From: haozi007 Date: Thu, 13 Oct 2022 16:56:10 +0800 -Subject: [PATCH 03/35] refactor build system of cutils ut +Subject: [PATCH 03/39] refactor build system of cutils ut Signed-off-by: haozi007 --- @@ -178,5 +178,5 @@ index c86141ef..1343f4e6 100644 +target_link_libraries(${EXE} ${GTEST_BOTH_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT} ${ISULA_LIBUTILS_LIBRARY} libutils_ut -lcrypto -lyajl -lz) add_test(NAME ${EXE} COMMAND ${EXE} --gtest_output=xml:${EXE}-Results.xml) -- -2.37.3 +2.25.1 diff --git a/0004-run-storage-layers-ut-with-non-root.patch b/0004-run-storage-layers-ut-with-non-root.patch index 91830e9..ebfaa34 100644 --- a/0004-run-storage-layers-ut-with-non-root.patch +++ b/0004-run-storage-layers-ut-with-non-root.patch @@ -1,7 +1,7 @@ From 8c33633d26ec5d5eb9b5ad415afc114cf6c232f3 Mon Sep 17 00:00:00 2001 From: haozi007 Date: Tue, 11 Oct 2022 20:34:18 +0800 -Subject: [PATCH 04/35] run storage layers ut with non-root +Subject: [PATCH 04/39] run storage layers ut with non-root Signed-off-by: haozi007 --- @@ -64,5 +64,5 @@ index 0b481a95..87dfb4a1 100644 } -- -2.37.3 +2.25.1 diff --git a/0005-add-extern-C-for-mainloop-header.patch b/0005-add-extern-C-for-mainloop-header.patch index 0d08ad7..f85189c 100644 --- a/0005-add-extern-C-for-mainloop-header.patch +++ b/0005-add-extern-C-for-mainloop-header.patch @@ -1,7 +1,7 @@ From 0ddc58b78b0ca7d6c1cb52b10e3fa03f0da69326 Mon Sep 17 00:00:00 2001 From: zhangxiaoyu Date: Sat, 15 Oct 2022 16:51:38 +0800 -Subject: [PATCH 05/35] add extern C for mainloop header +Subject: [PATCH 05/39] add extern C for mainloop header Signed-off-by: zhangxiaoyu --- @@ -33,5 +33,5 @@ index 5124b33a..7a4f1cfd 100644 + #endif -- -2.37.3 +2.25.1 diff --git a/0006-add-UT-for-mainloop-and-network.patch b/0006-add-UT-for-mainloop-and-network.patch index 0a05433..54d5819 100644 --- a/0006-add-UT-for-mainloop-and-network.patch +++ b/0006-add-UT-for-mainloop-and-network.patch @@ -1,7 +1,7 @@ From f7089859d339cfe2b33ab701c02e1f424e4bd248 Mon Sep 17 00:00:00 2001 From: zhangxiaoyu Date: Sat, 15 Oct 2022 16:52:32 +0800 -Subject: [PATCH 06/35] add UT for mainloop and network +Subject: [PATCH 06/39] add UT for mainloop and network Signed-off-by: zhangxiaoyu --- @@ -513,5 +513,5 @@ index 00000000..fcae5664 + +#endif // _ISULAD_TEST_MOCKS_UTILS_NETWORK_MOCK_H -- -2.37.3 +2.25.1 diff --git a/0007-add-check-for-aes-apis.patch b/0007-add-check-for-aes-apis.patch new file mode 100644 index 0000000..b9a2778 --- /dev/null +++ b/0007-add-check-for-aes-apis.patch @@ -0,0 +1,159 @@ +From 59b3f0832626fecebef66326b5316dbd10e482e0 Mon Sep 17 00:00:00 2001 +From: haozi007 +Date: Sat, 15 Oct 2022 14:53:50 +0800 +Subject: [PATCH 07/39] add check for aes apis + +Signed-off-by: haozi007 +--- + src/utils/cutils/namespace.c | 3 +-- + src/utils/cutils/utils_aes.c | 48 ++++++++++++++++++++++++++++++------ + src/utils/cutils/utils_aes.h | 2 +- + 3 files changed, 43 insertions(+), 10 deletions(-) + +diff --git a/src/utils/cutils/namespace.c b/src/utils/cutils/namespace.c +index 2916c8bb..dc2fe810 100644 +--- a/src/utils/cutils/namespace.c ++++ b/src/utils/cutils/namespace.c +@@ -20,9 +20,8 @@ + + char *namespace_get_connected_container(const char *mode) + { +- const char *p = mode != NULL ? (mode + strlen(SHARE_NAMESPACE_PREFIX)) : NULL; +- + if (namespace_is_container(mode)) { ++ const char *p = mode + strlen(SHARE_NAMESPACE_PREFIX); + return util_strdup_s(p); + } + +diff --git a/src/utils/cutils/utils_aes.c b/src/utils/cutils/utils_aes.c +index 9e318b5b..1e25ecd3 100644 +--- a/src/utils/cutils/utils_aes.c ++++ b/src/utils/cutils/utils_aes.c +@@ -28,12 +28,17 @@ + #include "utils.h" + #include "utils_file.h" + +-int util_aes_key(char *key_file, bool create, unsigned char *aeskey) ++int util_aes_key(const char *key_file, bool create, unsigned char *aeskey) + { + char *key_dir = NULL; + int fd = 0; + int ret = 0; + ++ if (key_file == NULL || aeskey == NULL) { ++ ERROR("Invalid arguments"); ++ return -1; ++ } ++ + if (!util_file_exists(key_file)) { + if (!create) { + ERROR("init aes failed, file %s not exist", key_file); +@@ -102,6 +107,11 @@ size_t util_aes_encode_buf_len(size_t len) + return AES_256_CFB_IV_LEN + util_aes_decode_buf_len(len); + } + ++static bool invalid_ase_args(unsigned char *aeskey, unsigned char *bytes, size_t len, unsigned char **out) ++{ ++ return aeskey == NULL || out == NULL || bytes == NULL || len == 0; ++} ++ + int util_aes_encode(unsigned char *aeskey, unsigned char *bytes, size_t len, unsigned char **out) + { + int ret = 0; +@@ -110,22 +120,34 @@ int util_aes_encode(unsigned char *aeskey, unsigned char *bytes, size_t len, uns + int size = 0; + int expected_size = len; + unsigned char *iv = NULL; ++ EVP_CIPHER_CTX *ctx = NULL; + #ifdef OPENSSL_IS_BORINGSSL + const EVP_CIPHER *cipher = EVP_aes_256_ofb(); + #else + const EVP_CIPHER *cipher = EVP_aes_256_cfb(); + #endif +- EVP_CIPHER_CTX *ctx = EVP_CIPHER_CTX_new(); + +- if (ctx == NULL || cipher == NULL) { ++ if (cipher == NULL) { + ERROR("EVP init failed"); + return -1; + } + ++ if (invalid_ase_args(aeskey, bytes, len, out)) { ++ ERROR("Invalid arguments"); ++ return -1; ++ } ++ ++ ctx = EVP_CIPHER_CTX_new(); ++ if (ctx == NULL) { ++ ERROR("Ctx create failed"); ++ return -1; ++ } ++ + *out = util_common_calloc_s(util_aes_encode_buf_len(len) + 1); + if (*out == NULL) { + ERROR("out of memory"); +- return -1; ++ ret = -1; ++ goto out; + } + iv = *out; + +@@ -192,27 +214,39 @@ int util_aes_decode(unsigned char *aeskey, unsigned char *bytes, size_t len, uns + int size = 0; + int expected_size = 0; + unsigned char *iv = NULL; ++ EVP_CIPHER_CTX *ctx = NULL; + #ifdef OPENSSL_IS_BORINGSSL + const EVP_CIPHER *cipher = EVP_aes_256_ofb(); + #else + const EVP_CIPHER *cipher = EVP_aes_256_cfb(); + #endif +- EVP_CIPHER_CTX *ctx = EVP_CIPHER_CTX_new(); + +- if (ctx == NULL || cipher == NULL) { ++ if (cipher == NULL) { + ERROR("EVP init failed"); + return -1; + } + ++ if (invalid_ase_args(aeskey, bytes, len, out)) { ++ ERROR("Invalid arguments"); ++ return -1; ++ } ++ + if (len <= AES_256_CFB_IV_LEN) { + ERROR("Invalid aes length, it must be larger than %d", AES_256_CFB_IV_LEN); + return -1; + } + ++ ctx = EVP_CIPHER_CTX_new(); ++ if (ctx == NULL) { ++ ERROR("Ctx create failed"); ++ return -1; ++ } ++ + *out = util_common_calloc_s(util_aes_decode_buf_len(len) + 1); + if (*out == NULL) { + ERROR("out of memory"); +- return -1; ++ ret = -1; ++ goto out; + } + + iv = bytes; +diff --git a/src/utils/cutils/utils_aes.h b/src/utils/cutils/utils_aes.h +index d429c9e0..476fea65 100644 +--- a/src/utils/cutils/utils_aes.h ++++ b/src/utils/cutils/utils_aes.h +@@ -27,7 +27,7 @@ extern "C" { + #define AES_256_CFB_KEY_LEN 32 + #define AES_256_CFB_IV_LEN 16 + +-int util_aes_key(char *key_path, bool create, unsigned char *aeskey); ++int util_aes_key(const char *key_path, bool create, unsigned char *aeskey); + + // note: Input bytes is "IV+data", "bytes+AES_256_CFB_IV_LEN" is the real data to be encoded. + // The output length is the input "len" and add the '\0' after end of the length. +-- +2.25.1 + diff --git a/0008-add-ut-for-cutils-aes.patch b/0008-add-ut-for-cutils-aes.patch new file mode 100644 index 0000000..4d8b700 --- /dev/null +++ b/0008-add-ut-for-cutils-aes.patch @@ -0,0 +1,142 @@ +From 3909ddbc369c69202308e77beda6553b7d95d79b Mon Sep 17 00:00:00 2001 +From: haozi007 +Date: Sat, 15 Oct 2022 15:04:56 +0800 +Subject: [PATCH 08/39] add ut for cutils aes + +Signed-off-by: haozi007 +--- + test/CMakeLists.txt | 1 + + test/cutils/CMakeLists.txt | 1 + + test/cutils/utils_aes/CMakeLists.txt | 16 ++++++ + test/cutils/utils_aes/utils_aes_ut.cc | 74 +++++++++++++++++++++++++++ + 4 files changed, 92 insertions(+) + create mode 100644 test/cutils/utils_aes/CMakeLists.txt + create mode 100644 test/cutils/utils_aes/utils_aes_ut.cc + +diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt +index a36f68c5..034aaf97 100644 +--- a/test/CMakeLists.txt ++++ b/test/CMakeLists.txt +@@ -62,6 +62,7 @@ IF(ENABLE_COVERAGE) + + COMMAND lcov --directory . --capture --output-file coverage.info + COMMAND lcov -a coverage.base -a coverage.info --output-file coverage.total ++ COMMAND lcov --remove coverage.total '/usr/include/*' --output-file coverage.total + COMMAND lcov --remove coverage.total ${COVERAGE_EXCLUDES} --output-file ${PROJECT_BINARY_DIR}/coverage.info.cleaned + COMMAND genhtml -o coverage ${PROJECT_BINARY_DIR}/coverage.info.cleaned + COMMAND ${CMAKE_COMMAND} -E remove coverage.base coverage.total ${PROJECT_BINARY_DIR}/coverage.info.cleaned +diff --git a/test/cutils/CMakeLists.txt b/test/cutils/CMakeLists.txt +index 724f2188..93c73fb8 100644 +--- a/test/cutils/CMakeLists.txt ++++ b/test/cutils/CMakeLists.txt +@@ -23,3 +23,4 @@ add_subdirectory(utils_base64) + add_subdirectory(utils_pwgr) + add_subdirectory(utils_namespace) + add_subdirectory(utils_network) ++add_subdirectory(utils_aes) +diff --git a/test/cutils/utils_aes/CMakeLists.txt b/test/cutils/utils_aes/CMakeLists.txt +new file mode 100644 +index 00000000..f7535bb3 +--- /dev/null ++++ b/test/cutils/utils_aes/CMakeLists.txt +@@ -0,0 +1,16 @@ ++project(iSulad_UT) ++ ++SET(EXE utils_aes_ut) ++ ++add_executable(${EXE} ++ utils_aes_ut.cc) ++ ++target_include_directories(${EXE} PUBLIC ++ ${GTEST_INCLUDE_DIR} ++ ${CMAKE_CURRENT_SOURCE_DIR}/../../include ++ ${CMAKE_CURRENT_SOURCE_DIR}/../../../src/common ++ ${CMAKE_CURRENT_SOURCE_DIR}/../../../src/utils/cutils/map ++ ${CMAKE_CURRENT_SOURCE_DIR}/../../../src/utils/cutils ++ ) ++target_link_libraries(${EXE} ${GTEST_BOTH_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT} ${ISULA_LIBUTILS_LIBRARY} libutils_ut -lcrypto -lyajl -lz) ++add_test(NAME ${EXE} COMMAND ${EXE} --gtest_output=xml:${EXE}-Results.xml) +diff --git a/test/cutils/utils_aes/utils_aes_ut.cc b/test/cutils/utils_aes/utils_aes_ut.cc +new file mode 100644 +index 00000000..e564428d +--- /dev/null ++++ b/test/cutils/utils_aes/utils_aes_ut.cc +@@ -0,0 +1,74 @@ ++/****************************************************************************** ++ * Copyright (c) Huawei Technologies Co., Ltd. 2022. All rights reserved. ++ * iSulad licensed under the Mulan PSL v2. ++ * You can use this software according to the terms and conditions of the Mulan PSL v2. ++ * You may obtain a copy of Mulan PSL v2 at: ++ * http://license.coscl.org.cn/MulanPSL2 ++ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR ++ * IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR ++ * PURPOSE. ++ * See the Mulan PSL v2 for more details. ++ * Author: haozi007 ++ * Create: 2022-10-13 ++ * Description: utils namespace unit test ++ *******************************************************************************/ ++ ++#include ++#include "utils_aes.h" ++ ++TEST(utils_aes, test_util_aes_key) ++{ ++ std::string key_file = "./aes_key"; ++ unsigned char key_val[AES_256_CFB_KEY_LEN] = { 0 }; ++ ++ unlink(key_file.c_str()); ++ ASSERT_NE(util_aes_key(key_file.c_str(), false, key_val), 0); ++ ASSERT_NE(util_aes_key(nullptr, true, key_val), 0); ++ ASSERT_NE(util_aes_key(nullptr, false, key_val), 0); ++ ASSERT_NE(util_aes_key(key_file.c_str(), true, nullptr), 0); ++ ASSERT_NE(util_aes_key(key_file.c_str(), false, nullptr), 0); ++ ASSERT_NE(util_aes_key(nullptr, true, nullptr), 0); ++ ASSERT_NE(util_aes_key(nullptr, false, nullptr), 0); ++} ++ ++TEST(utils_aes, test_util_aes_encode) ++{ ++ std::string key_file = "./aes_key"; ++ unsigned char key_val[AES_256_CFB_KEY_LEN] = { 0 }; ++ std::string test_data = "hello world"; ++ unsigned char *out = nullptr; ++ ++ ASSERT_EQ(util_aes_key(key_file.c_str(), true, key_val), 0); ++ ASSERT_EQ(util_aes_encode(key_val, (unsigned char *)test_data.c_str(), test_data.size(), &out), 0); ++ ++ ASSERT_NE(util_aes_encode(nullptr, (unsigned char *)test_data.c_str(), test_data.size(), &out), 0); ++ ASSERT_NE(util_aes_encode(key_val, nullptr, 0, &out), 0); ++ ASSERT_NE(util_aes_encode(key_val, (unsigned char *)test_data.c_str(), 0, &out), 0); ++ ASSERT_NE(util_aes_encode(key_val, (unsigned char *)test_data.c_str(), test_data.size(), nullptr), 0); ++ ++ unlink(key_file.c_str()); ++} ++ ++TEST(utils_aes, test_util_aes_decode) ++{ ++ std::string key_file = "./aes_key"; ++ unsigned char key_val[AES_256_CFB_KEY_LEN] = { 0 }; ++ std::string test_data = "hello world"; ++ unsigned char *encode_data = nullptr; ++ unsigned char *decode_data = nullptr; ++ size_t aes_len = AES_256_CFB_IV_LEN; ++ ++ ASSERT_EQ(util_aes_key(key_file.c_str(), true, key_val), 0); ++ ASSERT_EQ(util_aes_encode(key_val, (unsigned char *)test_data.c_str(), test_data.size(), &encode_data), 0); ++ aes_len += test_data.size(); ++ ASSERT_EQ(util_aes_decode(key_val, encode_data, aes_len, &decode_data), 0); ++ printf("get decode value = %s\n", (const char *)decode_data); ++ ASSERT_EQ(strcmp(test_data.c_str(), (const char *)decode_data), 0); ++ ++ ASSERT_NE(util_aes_decode(nullptr, encode_data, aes_len, &decode_data), 0); ++ ASSERT_NE(util_aes_decode(key_val, nullptr, 0, &decode_data), 0); ++ ASSERT_NE(util_aes_decode(key_val, encode_data, 0, &decode_data), 0); ++ ASSERT_NE(util_aes_decode(key_val, encode_data, aes_len, nullptr), 0); ++ ++ unlink(key_file.c_str()); ++} +\ No newline at end of file +-- +2.25.1 + diff --git a/0009-add-ut-for-cutils-error.patch b/0009-add-ut-for-cutils-error.patch new file mode 100644 index 0000000..d1019a3 --- /dev/null +++ b/0009-add-ut-for-cutils-error.patch @@ -0,0 +1,100 @@ +From b2f293d1777ba3846ea4bcab5754b66ebfe4094c Mon Sep 17 00:00:00 2001 +From: haozi007 +Date: Sat, 15 Oct 2022 17:01:02 +0800 +Subject: [PATCH 09/39] add ut for cutils error + +Signed-off-by: haozi007 +--- + test/cutils/CMakeLists.txt | 1 + + test/cutils/utils_error/CMakeLists.txt | 16 ++++++++ + test/cutils/utils_error/utils_error_ut.cc | 45 +++++++++++++++++++++++ + 3 files changed, 62 insertions(+) + create mode 100644 test/cutils/utils_error/CMakeLists.txt + create mode 100644 test/cutils/utils_error/utils_error_ut.cc + +diff --git a/test/cutils/CMakeLists.txt b/test/cutils/CMakeLists.txt +index 93c73fb8..d3e1038a 100644 +--- a/test/cutils/CMakeLists.txt ++++ b/test/cutils/CMakeLists.txt +@@ -24,3 +24,4 @@ add_subdirectory(utils_pwgr) + add_subdirectory(utils_namespace) + add_subdirectory(utils_network) + add_subdirectory(utils_aes) ++add_subdirectory(utils_error) +diff --git a/test/cutils/utils_error/CMakeLists.txt b/test/cutils/utils_error/CMakeLists.txt +new file mode 100644 +index 00000000..28016605 +--- /dev/null ++++ b/test/cutils/utils_error/CMakeLists.txt +@@ -0,0 +1,16 @@ ++project(iSulad_UT) ++ ++SET(EXE utils_error_ut) ++ ++add_executable(${EXE} ++ utils_error_ut.cc) ++ ++target_include_directories(${EXE} PUBLIC ++ ${GTEST_INCLUDE_DIR} ++ ${CMAKE_CURRENT_SOURCE_DIR}/../../include ++ ${CMAKE_CURRENT_SOURCE_DIR}/../../../src/common ++ ${CMAKE_CURRENT_SOURCE_DIR}/../../../src/utils/cutils/map ++ ${CMAKE_CURRENT_SOURCE_DIR}/../../../src/utils/cutils ++ ) ++target_link_libraries(${EXE} ${GTEST_BOTH_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT} ${ISULA_LIBUTILS_LIBRARY} libutils_ut -lcrypto -lyajl -lz) ++add_test(NAME ${EXE} COMMAND ${EXE} --gtest_output=xml:${EXE}-Results.xml) +diff --git a/test/cutils/utils_error/utils_error_ut.cc b/test/cutils/utils_error/utils_error_ut.cc +new file mode 100644 +index 00000000..d4585d70 +--- /dev/null ++++ b/test/cutils/utils_error/utils_error_ut.cc +@@ -0,0 +1,45 @@ ++/****************************************************************************** ++ * Copyright (c) Huawei Technologies Co., Ltd. 2022. All rights reserved. ++ * iSulad licensed under the Mulan PSL v2. ++ * You can use this software according to the terms and conditions of the Mulan PSL v2. ++ * You may obtain a copy of Mulan PSL v2 at: ++ * http://license.coscl.org.cn/MulanPSL2 ++ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR ++ * IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR ++ * PURPOSE. ++ * See the Mulan PSL v2 for more details. ++ * Author: haozi007 ++ * Create: 2022-10-13 ++ * Description: utils namespace unit test ++ *******************************************************************************/ ++ ++#include ++#include "error.h" ++ ++TEST(utils_error, test_errno_to_error_message) ++{ ++ const char *ret = nullptr; ++ std::string internal_err = "Server internal error"; ++ std::string unknow_err = "Unknown error"; ++ ++ ret = errno_to_error_message(ISULAD_SUCCESS); ++ ASSERT_EQ(strcmp(ret, DEF_SUCCESS_STR), 0); ++ ++ ret = errno_to_error_message(ISULAD_ERR_INTERNAL); ++ ASSERT_EQ(strcmp(ret, internal_err.c_str()), 0); ++ ++ ret = errno_to_error_message(ISULAD_ERR_UNKNOWN); ++ ASSERT_EQ(strcmp(ret, unknow_err.c_str()), 0); ++} ++ ++TEST(utils_error, test_format_errorf) ++{ ++ char *out = nullptr; ++ std::string target = "hello world"; ++ ++ format_errorf(&out, "hello %s", "world"); ++ ASSERT_EQ(strcmp(out, target.c_str()), 0); ++ ++ format_errorf(nullptr, "hello %s", "world"); ++ format_errorf(&out, nullptr); ++} +\ No newline at end of file +-- +2.25.1 + diff --git a/0010-ensure-argument-is-not-null.patch b/0010-ensure-argument-is-not-null.patch new file mode 100644 index 0000000..2b4ae93 --- /dev/null +++ b/0010-ensure-argument-is-not-null.patch @@ -0,0 +1,28 @@ +From 99caa82b9406ef344707401c0b8c548296924466 Mon Sep 17 00:00:00 2001 +From: haozi007 +Date: Sat, 15 Oct 2022 17:18:28 +0800 +Subject: [PATCH 10/39] ensure argument is not null + +Signed-off-by: haozi007 +--- + src/utils/cutils/error.h | 4 ++++ + 1 file changed, 4 insertions(+) + +diff --git a/src/utils/cutils/error.h b/src/utils/cutils/error.h +index 5a8dca99..e3946cf2 100644 +--- a/src/utils/cutils/error.h ++++ b/src/utils/cutils/error.h +@@ -62,6 +62,10 @@ static inline void format_errorf(char **err, const char *format, ...) + va_list argp; + va_start(argp, format); + ++ if (err == NULL) { ++ return; ++ } ++ + ret = vsnprintf(errbuf, BUFSIZ, format, argp); + va_end(argp); + if (ret < 0) { +-- +2.25.1 + diff --git a/0011-add-ut-for-utils_fs.patch b/0011-add-ut-for-utils_fs.patch new file mode 100644 index 0000000..dcd39f4 --- /dev/null +++ b/0011-add-ut-for-utils_fs.patch @@ -0,0 +1,96 @@ +From 8020e1e076e597a82962fe03990f89314f5419fa Mon Sep 17 00:00:00 2001 +From: haozi007 +Date: Mon, 17 Oct 2022 11:10:05 +0800 +Subject: [PATCH 11/39] add ut for utils_fs + +Signed-off-by: haozi007 +--- + test/cutils/CMakeLists.txt | 1 + + test/cutils/utils_fs/CMakeLists.txt | 16 +++++++++++ + test/cutils/utils_fs/utils_fs_ut.cc | 42 +++++++++++++++++++++++++++++ + 3 files changed, 59 insertions(+) + create mode 100644 test/cutils/utils_fs/CMakeLists.txt + create mode 100644 test/cutils/utils_fs/utils_fs_ut.cc + +diff --git a/test/cutils/CMakeLists.txt b/test/cutils/CMakeLists.txt +index d3e1038a..9073a68d 100644 +--- a/test/cutils/CMakeLists.txt ++++ b/test/cutils/CMakeLists.txt +@@ -25,3 +25,4 @@ add_subdirectory(utils_namespace) + add_subdirectory(utils_network) + add_subdirectory(utils_aes) + add_subdirectory(utils_error) ++add_subdirectory(utils_fs) +diff --git a/test/cutils/utils_fs/CMakeLists.txt b/test/cutils/utils_fs/CMakeLists.txt +new file mode 100644 +index 00000000..7ff3176a +--- /dev/null ++++ b/test/cutils/utils_fs/CMakeLists.txt +@@ -0,0 +1,16 @@ ++project(iSulad_UT) ++ ++SET(EXE utils_fs_ut) ++ ++add_executable(${EXE} ++ utils_fs_ut.cc) ++ ++target_include_directories(${EXE} PUBLIC ++ ${GTEST_INCLUDE_DIR} ++ ${CMAKE_CURRENT_SOURCE_DIR}/../../include ++ ${CMAKE_CURRENT_SOURCE_DIR}/../../../src/common ++ ${CMAKE_CURRENT_SOURCE_DIR}/../../../src/utils/cutils/map ++ ${CMAKE_CURRENT_SOURCE_DIR}/../../../src/utils/cutils ++ ) ++target_link_libraries(${EXE} ${GTEST_BOTH_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT} ${ISULA_LIBUTILS_LIBRARY} libutils_ut -lcrypto -lyajl -lz) ++add_test(NAME ${EXE} COMMAND ${EXE} --gtest_output=xml:${EXE}-Results.xml) +diff --git a/test/cutils/utils_fs/utils_fs_ut.cc b/test/cutils/utils_fs/utils_fs_ut.cc +new file mode 100644 +index 00000000..e1c4fd4b +--- /dev/null ++++ b/test/cutils/utils_fs/utils_fs_ut.cc +@@ -0,0 +1,42 @@ ++/****************************************************************************** ++ * Copyright (c) Huawei Technologies Co., Ltd. 2022. All rights reserved. ++ * iSulad licensed under the Mulan PSL v2. ++ * You can use this software according to the terms and conditions of the Mulan PSL v2. ++ * You may obtain a copy of Mulan PSL v2 at: ++ * http://license.coscl.org.cn/MulanPSL2 ++ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR ++ * IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR ++ * PURPOSE. ++ * See the Mulan PSL v2 for more details. ++ * Author: haozi007 ++ * Create: 2022-10-13 ++ * Description: utils namespace unit test ++ *******************************************************************************/ ++ ++#include ++#include "utils_fs.h" ++ ++int good_cb(const char *mp, const char *pattern) ++{ ++ return 0; ++} ++ ++int good_check_cb(const char *mp, const char *pattern) ++{ ++ return pattern != nullptr ? 0 : -1; ++} ++ ++int bad_cb(const char *mp, const char *pattern) ++{ ++ return -1; ++} ++ ++TEST(utils_fs, test_util_deal_with_mount_info) ++{ ++ std::string spattern = "[0-9]*"; ++ ++ ASSERT_EQ(util_deal_with_mount_info(good_cb, spattern.c_str()), true); ++ ASSERT_EQ(util_deal_with_mount_info(bad_cb, spattern.c_str()), false); ++ ASSERT_EQ(util_deal_with_mount_info(good_check_cb, spattern.c_str()), true); ++ ASSERT_EQ(util_deal_with_mount_info(good_check_cb, nullptr), false); ++} +-- +2.25.1 + diff --git a/0012-Add-adaptation-code-for-filters.patch b/0012-Add-adaptation-code-for-filters.patch new file mode 100644 index 0000000..42f58ed --- /dev/null +++ b/0012-Add-adaptation-code-for-filters.patch @@ -0,0 +1,55 @@ +From f1313b04f60672a1aae1a3d36df5f0b8abcdd06f Mon Sep 17 00:00:00 2001 +From: zhongtao +Date: Mon, 17 Oct 2022 15:04:01 +0800 +Subject: [PATCH 12/39] Add adaptation code for filters + +Signed-off-by: zhongtao +--- + src/utils/cutils/filters.c | 3 ++- + src/utils/cutils/filters.h | 8 ++++++++ + 2 files changed, 10 insertions(+), 1 deletion(-) + +diff --git a/src/utils/cutils/filters.c b/src/utils/cutils/filters.c +index 1885e9cc..21f5db7c 100644 +--- a/src/utils/cutils/filters.c ++++ b/src/utils/cutils/filters.c +@@ -315,9 +315,10 @@ bool filters_args_valid_key(const char **accepted, size_t len, const char *field + { + size_t i; + +- if (field == NULL) { ++ if (accepted == NULL || field == NULL) { + return false; + } ++ + for (i = 0; i < len; i++) { + if (accepted[i] != NULL && strcmp(accepted[i], field) == 0) { + return true; +diff --git a/src/utils/cutils/filters.h b/src/utils/cutils/filters.h +index 021704d1..c6e5a618 100644 +--- a/src/utils/cutils/filters.h ++++ b/src/utils/cutils/filters.h +@@ -20,6 +20,10 @@ + + #include "map.h" + ++#ifdef __cplusplus ++extern "C" { ++#endif ++ + struct filters_args { + // A map of map[string][map[string][bool]] + map_t *fields; +@@ -48,5 +52,9 @@ bool filters_args_exact_match(const struct filters_args *filters, const char *fi + + bool filters_args_match(const struct filters_args *filters, const char *field, const char *source); + ++#ifdef __cplusplus ++} ++#endif ++ + #endif + +-- +2.25.1 + diff --git a/0013-Add-parameter-check-to-path.patch b/0013-Add-parameter-check-to-path.patch new file mode 100644 index 0000000..bec11df --- /dev/null +++ b/0013-Add-parameter-check-to-path.patch @@ -0,0 +1,30 @@ +From 45824723bf3968a1106089fb0572ad6a593ac62e Mon Sep 17 00:00:00 2001 +From: zhongtao +Date: Mon, 17 Oct 2022 15:15:49 +0800 +Subject: [PATCH 13/39] Add parameter check to path + +Signed-off-by: zhongtao +--- + src/utils/cutils/path.c | 6 ++++++ + 1 file changed, 6 insertions(+) + +diff --git a/src/utils/cutils/path.c b/src/utils/cutils/path.c +index 79cd7af6..5a743632 100644 +--- a/src/utils/cutils/path.c ++++ b/src/utils/cutils/path.c +@@ -733,6 +733,12 @@ int util_realpath_in_scope(const char *rootfs, const char *path, char **real_pat + char cleaned[PATH_MAX] = { 0 }; + char *tmp = NULL; + ++ if (rootfs == NULL || path == NULL || real_path == NULL) { ++ ERROR("Null parameter"); ++ ret = -1; ++ goto out; ++ } ++ + int nret = snprintf(full_path, sizeof(full_path), "%s%s", rootfs, path); + if (nret < 0 || (size_t)nret >= sizeof(full_path)) { + ERROR("sprintf error: %s", strerror(errno)); +-- +2.25.1 + diff --git a/0014-Add-ut-for-utils_convert.patch b/0014-Add-ut-for-utils_convert.patch new file mode 100644 index 0000000..56abf81 --- /dev/null +++ b/0014-Add-ut-for-utils_convert.patch @@ -0,0 +1,134 @@ +From 8cd75df646c836745b5a1325e68be67046a84f1a Mon Sep 17 00:00:00 2001 +From: zhongtao +Date: Mon, 17 Oct 2022 18:23:19 +0800 +Subject: [PATCH 14/39] Add ut for utils_convert + +Signed-off-by: zhongtao +--- + test/cutils/utils_convert/utils_convert_ut.cc | 112 ++++++++++++++++++ + 1 file changed, 112 insertions(+) + +diff --git a/test/cutils/utils_convert/utils_convert_ut.cc b/test/cutils/utils_convert/utils_convert_ut.cc +index 7e46fd84..bee9c3c4 100644 +--- a/test/cutils/utils_convert/utils_convert_ut.cc ++++ b/test/cutils/utils_convert/utils_convert_ut.cc +@@ -239,3 +239,115 @@ TEST(utils_convert, test_util_str_to_bool) + ret = util_str_to_bool("nullptr", &converted); + ASSERT_NE(ret, 0); + } ++ ++TEST(utils_convert, test_util_safe_uint64) ++{ ++ int ret; ++ uint64_t converted; ++ ret = util_safe_uint64("255", &converted); ++ ASSERT_EQ(ret, 0); ++ ASSERT_EQ(converted, 255); ++ ++ ret = util_safe_uint64("255", nullptr); ++ ASSERT_NE(ret, 0); ++ ++ ret = util_safe_uint64("-1", &converted); ++ ASSERT_EQ(ret, 0); ++ ASSERT_EQ(converted, UINT64_MAX); ++ ++ ret = util_safe_uint64("0", &converted); ++ ASSERT_EQ(ret, 0); ++ ASSERT_EQ(converted, 0); ++ ++ ret = util_safe_uint64("1.23", &converted); ++ ASSERT_NE(ret, 0); ++ ++ ret = util_safe_uint64("1x", &converted); ++ ASSERT_NE(ret, 0); ++ ++ ret = util_safe_uint64("18446744073709551616", &converted); ++ ASSERT_NE(ret, 0); ++ ++ ret = util_safe_uint64("nullptr", &converted); ++ ASSERT_NE(ret, 0); ++} ++ ++TEST(utils_convert, test_util_parse_octal_uint32) ++{ ++ int ret; ++ uint32_t converted; ++ ret = util_parse_octal_uint32("50", &converted); ++ ASSERT_EQ(ret, 0); ++ ASSERT_EQ(converted, 40); ++ ++ ret = util_parse_octal_uint32("50", nullptr); ++ ASSERT_NE(ret, 0); ++ ++ ret = util_parse_octal_uint32("-1", &converted); ++ ASSERT_NE(ret, 0); ++ ++ ret = util_parse_octal_uint32("0", &converted); ++ ASSERT_EQ(ret, 0); ++ ASSERT_EQ(converted, 0); ++ ++ ret = util_parse_octal_uint32("1.23", &converted); ++ ASSERT_NE(ret, 0); ++ ++ ret = util_parse_octal_uint32("1x", &converted); ++ ASSERT_NE(ret, 0); ++ ++ ret = util_parse_octal_uint32("40000000000", &converted); ++ ASSERT_NE(ret, 0); ++ ++ ret = util_parse_octal_uint32("nullptr", &converted); ++ ASSERT_NE(ret, 0); ++} ++ ++TEST(utils_convert, test_util_uint_to_string) ++{ ++ char *converted; ++ long long unsigned int ret; ++ ++ ret = 123456; ++ converted = util_uint_to_string(ret); ++ ASSERT_STREQ(converted, "123456"); ++ ++ ret = 0; ++ converted = util_uint_to_string(ret); ++ ASSERT_STREQ(converted, "0"); ++ ++ ret = ULLONG_MAX; ++ converted = util_uint_to_string(ret); ++ ASSERT_NE(converted, nullptr); ++ ASSERT_STREQ(converted, std::to_string((long long unsigned int)ULLONG_MAX).c_str()); ++ ++ ret = -1; ++ converted = util_uint_to_string(ret); ++ ASSERT_NE(converted, nullptr); ++ ASSERT_STREQ(converted, std::to_string((long long unsigned int)ULLONG_MAX).c_str()); ++} ++ ++TEST(utils_convert, test_util_int_to_string) ++{ ++ char *converted; ++ long long int ret; ++ ++ ret = 123456; ++ converted = util_int_to_string(ret); ++ ASSERT_STREQ(converted, "123456"); ++ ++ ret = 0; ++ converted = util_int_to_string(ret); ++ ASSERT_STREQ(converted, "0"); ++ ++ ret = LLONG_MAX; ++ converted = util_int_to_string(ret); ++ ASSERT_NE(converted, nullptr); ++ ASSERT_STREQ(converted, std::to_string((long long)LLONG_MAX).c_str()); ++ ++ ret = LLONG_MIN; ++ converted = util_int_to_string(ret); ++ ASSERT_NE(converted, nullptr); ++ ASSERT_STREQ(converted, std::to_string((long long)LLONG_MIN).c_str()); ++ ++} +\ No newline at end of file +-- +2.25.1 + diff --git a/0015-Add-ut-for-path.patch b/0015-Add-ut-for-path.patch new file mode 100644 index 0000000..c71d7c0 --- /dev/null +++ b/0015-Add-ut-for-path.patch @@ -0,0 +1,187 @@ +From eb122520ccdcd71dee4e93d3bf9e6c296e3af315 Mon Sep 17 00:00:00 2001 +From: zhongtao +Date: Mon, 17 Oct 2022 11:43:18 +0800 +Subject: [PATCH 15/39] Add ut for path + +Signed-off-by: zhongtao +--- + test/CMakeLists.txt | 1 - + test/cutils/CMakeLists.txt | 1 + + test/cutils/path/CMakeLists.txt | 17 ++++++++ + test/{ => cutils}/path/path_ut.cc | 70 ++++++++++++++++++++++++++++++- + test/path/CMakeLists.txt | 28 ------------- + 5 files changed, 87 insertions(+), 30 deletions(-) + create mode 100644 test/cutils/path/CMakeLists.txt + rename test/{ => cutils}/path/path_ut.cc (82%) + delete mode 100644 test/path/CMakeLists.txt + +diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt +index 034aaf97..92a4e969 100644 +--- a/test/CMakeLists.txt ++++ b/test/CMakeLists.txt +@@ -42,7 +42,6 @@ include_directories(${GMOCK_INCLUDE_DIRS}) + IF(ENABLE_UT) + add_subdirectory(cutils) + add_subdirectory(image) +- add_subdirectory(path) + add_subdirectory(cmd) + add_subdirectory(runtime) + add_subdirectory(specs) +diff --git a/test/cutils/CMakeLists.txt b/test/cutils/CMakeLists.txt +index 9073a68d..00753e64 100644 +--- a/test/cutils/CMakeLists.txt ++++ b/test/cutils/CMakeLists.txt +@@ -16,6 +16,7 @@ target_include_directories(libutils_ut + ) + + add_subdirectory(mainloop) ++add_subdirectory(path) + add_subdirectory(utils_string) + add_subdirectory(utils_convert) + add_subdirectory(utils_array) +diff --git a/test/cutils/path/CMakeLists.txt b/test/cutils/path/CMakeLists.txt +new file mode 100644 +index 00000000..745258a1 +--- /dev/null ++++ b/test/cutils/path/CMakeLists.txt +@@ -0,0 +1,17 @@ ++project(iSulad_UT) ++ ++SET(EXE path_ut) ++ ++add_executable(${EXE} ++ path_ut.cc) ++ ++target_include_directories(${EXE} PUBLIC ++ ${CMAKE_CURRENT_SOURCE_DIR}/../../include ++ ${CMAKE_CURRENT_SOURCE_DIR}/../../../src/common ++ ${CMAKE_CURRENT_SOURCE_DIR}/../../../src/utils/cutils/map ++ ${CMAKE_CURRENT_SOURCE_DIR}/../../../src/utils/cutils ++ ${CMAKE_CURRENT_SOURCE_DIR}/../../../src/utils/sha256 ++ ) ++set_target_properties(${EXE} PROPERTIES LINK_FLAGS "-Wl,--wrap,getcwd -Wl,--wrap,readlink") ++target_link_libraries(${EXE} ${GTEST_BOTH_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT} ${ISULA_LIBUTILS_LIBRARY} libutils_ut -lcrypto -lyajl -lz) ++add_test(NAME ${EXE} COMMAND ${EXE} --gtest_output=xml:${EXE}-Results.xml) +diff --git a/test/path/path_ut.cc b/test/cutils/path/path_ut.cc +similarity index 82% +rename from test/path/path_ut.cc +rename to test/cutils/path/path_ut.cc +index 0068ecb4..8601fa07 100644 +--- a/test/path/path_ut.cc ++++ b/test/cutils/path/path_ut.cc +@@ -1,5 +1,5 @@ + /* +- * Copyright (c) Huawei Technologies Co., Ltd. 2019. All rights reserved. ++ * Copyright (c) Huawei Technologies Co., Ltd. 2019-2022. All rights reserved. + * iSulad licensed under the Mulan PSL v2. + * You can use this software according to the terms and conditions of the Mulan PSL v2. + * You may obtain a copy of Mulan PSL v2 at: +@@ -376,3 +376,71 @@ TEST(path_ut, test_preserve_trailing_dot_or_separator) + free(res); + res = nullptr; + } ++ ++TEST(path_ut, test_split_path_dir_entry) ++{ ++ std::string str; ++ char *dir = nullptr; ++ char *base = nullptr; ++ char **null_dir = nullptr; ++ ++ str = "/home/dir/file"; ++ ASSERT_EQ(util_split_path_dir_entry(nullptr, &dir, &base), -1); ++ ASSERT_EQ(util_split_path_dir_entry(str.c_str(), null_dir, &base), 0); ++ ASSERT_EQ(null_dir, nullptr); ++ ++ str = "/home/dir/../file"; ++ ASSERT_EQ(util_split_path_dir_entry(str.c_str(), &dir, &base), 0); ++ ASSERT_NE(dir, nullptr); ++ ASSERT_STREQ(dir, "/home"); ++ ASSERT_NE(base, nullptr); ++ ASSERT_STREQ(base, "file"); ++ ++ str = "/home/dir/./file"; ++ ASSERT_EQ(util_split_path_dir_entry(str.c_str(), &dir, &base), 0); ++ ASSERT_NE(dir, nullptr); ++ ASSERT_STREQ(dir, "/home/dir"); ++ ASSERT_NE(base, nullptr); ++ ASSERT_STREQ(base, "file"); ++ ++ str = "./dir/file"; ++ MOCK_SET_V(getcwd, getcwd_specify); ++ ASSERT_EQ(util_split_path_dir_entry(str.c_str(), &dir, &base), 0); ++ ASSERT_NE(dir, nullptr); ++ ASSERT_STREQ(dir, "/home/dir"); ++ ASSERT_NE(base, nullptr); ++ ASSERT_STREQ(base, "file"); ++} ++ ++TEST(path_ut, test_realpath_in_scope) ++{ ++ std::string rootfs; ++ std::string path; ++ char *realpath = nullptr; ++ char *null_roofs = nullptr; ++ ++ ASSERT_EQ(util_realpath_in_scope(null_roofs, path.c_str(), &realpath), -1); ++ ++ rootfs = "/home/dir"; ++ path = "/file"; ++ ASSERT_EQ(util_realpath_in_scope(rootfs.c_str(), path.c_str(), &realpath), 0); ++ ASSERT_NE(realpath, nullptr); ++ ASSERT_STREQ(realpath, "/home/dir/file"); ++ ++ rootfs = "/home/dir"; ++ path = "/../file"; ++ ASSERT_EQ(util_realpath_in_scope(rootfs.c_str(), path.c_str(), &realpath), -1); ++ ++ rootfs = "/home/dir"; ++ path = "/./file"; ++ ASSERT_EQ(util_realpath_in_scope(rootfs.c_str(), path.c_str(), &realpath), 0); ++ ASSERT_NE(realpath, nullptr); ++ ASSERT_STREQ(realpath, "/home/dir/file"); ++ ++ rootfs = ""; ++ path = "./dir/file"; ++ MOCK_SET_V(getcwd, getcwd_specify); ++ ASSERT_EQ(util_realpath_in_scope(rootfs.c_str(), path.c_str(), &realpath), 0); ++ ASSERT_NE(realpath, nullptr); ++ ASSERT_STREQ(realpath, "/home/dir/file"); ++} +diff --git a/test/path/CMakeLists.txt b/test/path/CMakeLists.txt +deleted file mode 100644 +index dcb69130..00000000 +--- a/test/path/CMakeLists.txt ++++ /dev/null +@@ -1,28 +0,0 @@ +-project(iSulad_UT) +- +-SET(EXE path_ut) +- +-add_executable(${EXE} +- ${CMAKE_CURRENT_SOURCE_DIR}/../../src/utils/cutils/utils.c +- ${CMAKE_CURRENT_SOURCE_DIR}/../../src/utils/cutils/path.c +- ${CMAKE_CURRENT_SOURCE_DIR}/../../src/utils/cutils/map/map.c +- ${CMAKE_CURRENT_SOURCE_DIR}/../../src/utils/cutils/map/rb_tree.c +- ${CMAKE_CURRENT_SOURCE_DIR}/../../src/utils/cutils/utils_string.c +- ${CMAKE_CURRENT_SOURCE_DIR}/../../src/utils/cutils/utils_array.c +- ${CMAKE_CURRENT_SOURCE_DIR}/../../src/utils/cutils/utils_file.c +- ${CMAKE_CURRENT_SOURCE_DIR}/../../src/utils/cutils/utils_convert.c +- ${CMAKE_CURRENT_SOURCE_DIR}/../../src/utils/cutils/utils_regex.c +- ${CMAKE_CURRENT_SOURCE_DIR}/../../src/utils/cutils/utils_verify.c +- ${CMAKE_CURRENT_SOURCE_DIR}/../../src/utils/sha256/sha256.c +- path_ut.cc) +- +-target_include_directories(${EXE} PUBLIC +- ${CMAKE_CURRENT_SOURCE_DIR}/../include +- ${CMAKE_CURRENT_SOURCE_DIR}/../../src/common +- ${CMAKE_CURRENT_SOURCE_DIR}/../../src/utils/cutils/map +- ${CMAKE_CURRENT_SOURCE_DIR}/../../src/utils/cutils +- ${CMAKE_CURRENT_SOURCE_DIR}/../../src/utils/sha256 +- ) +-set_target_properties(${EXE} PROPERTIES LINK_FLAGS "-Wl,--wrap,getcwd -Wl,--wrap,readlink") +-target_link_libraries(${EXE} ${GTEST_BOTH_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT} ${ISULA_LIBUTILS_LIBRARY} -lcrypto -lyajl -lz) +-add_test(NAME ${EXE} COMMAND ${EXE} --gtest_output=xml:${EXE}-Results.xml) +-- +2.25.1 + diff --git a/0016-Add-ut-for-filters.patch b/0016-Add-ut-for-filters.patch new file mode 100644 index 0000000..bcb6ec5 --- /dev/null +++ b/0016-Add-ut-for-filters.patch @@ -0,0 +1,160 @@ +From e8b1afc8241200a51b1eab8884fca4bfda286126 Mon Sep 17 00:00:00 2001 +From: zhongtao +Date: Mon, 17 Oct 2022 11:25:58 +0800 +Subject: [PATCH 16/39] Add ut for filters + +Signed-off-by: zhongtao +--- + test/cutils/CMakeLists.txt | 1 + + test/cutils/utils_filters/CMakeLists.txt | 18 +++ + test/cutils/utils_filters/utils_filters_ut.cc | 103 ++++++++++++++++++ + 3 files changed, 122 insertions(+) + create mode 100644 test/cutils/utils_filters/CMakeLists.txt + create mode 100644 test/cutils/utils_filters/utils_filters_ut.cc + +diff --git a/test/cutils/CMakeLists.txt b/test/cutils/CMakeLists.txt +index 00753e64..4e67d9ed 100644 +--- a/test/cutils/CMakeLists.txt ++++ b/test/cutils/CMakeLists.txt +@@ -27,3 +27,4 @@ add_subdirectory(utils_network) + add_subdirectory(utils_aes) + add_subdirectory(utils_error) + add_subdirectory(utils_fs) ++add_subdirectory(utils_filters) +diff --git a/test/cutils/utils_filters/CMakeLists.txt b/test/cutils/utils_filters/CMakeLists.txt +new file mode 100644 +index 00000000..31d3ac25 +--- /dev/null ++++ b/test/cutils/utils_filters/CMakeLists.txt +@@ -0,0 +1,18 @@ ++project(iSulad_UT) ++ ++SET(EXE utils_filters_ut) ++ ++add_executable(${EXE} ++ utils_filters_ut.cc) ++ ++target_include_directories(${EXE} PUBLIC ++ ${GTEST_INCLUDE_DIR} ++ ${CMAKE_CURRENT_SOURCE_DIR}/../../include ++ ${CMAKE_CURRENT_SOURCE_DIR}/../../../src/common ++ ${CMAKE_CURRENT_SOURCE_DIR}/../../../src/utils/cutils/map ++ ${CMAKE_CURRENT_SOURCE_DIR}/../../../src/utils/sha256 ++ ${CMAKE_CURRENT_SOURCE_DIR}/../../../src/utils/cutils ++ ) ++ ++target_link_libraries(${EXE} ${GTEST_BOTH_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT} ${ISULA_LIBUTILS_LIBRARY} libutils_ut -lcrypto -lyajl -lz) ++add_test(NAME ${EXE} COMMAND ${EXE} --gtest_output=xml:${EXE}-Results.xml) +diff --git a/test/cutils/utils_filters/utils_filters_ut.cc b/test/cutils/utils_filters/utils_filters_ut.cc +new file mode 100644 +index 00000000..81a928f9 +--- /dev/null ++++ b/test/cutils/utils_filters/utils_filters_ut.cc +@@ -0,0 +1,103 @@ ++/* ++ * Copyright (c) Huawei Technologies Co., Ltd. 2022. All rights reserved. ++ * iSulad licensed under the Mulan PSL v2. ++ * You can use this software according to the terms and conditions of the Mulan PSL v2. ++ * You may obtain a copy of Mulan PSL v2 at: ++ * http://license.coscl.org.cn/MulanPSL2 ++ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR ++ * IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR ++ * PURPOSE. ++ * See the Mulan PSL v2 for more details. ++ * Description: filters unit test ++ * Author: zhongtao ++ * Create: 2022-10-17 ++ */ ++ ++#include ++#include "filters.h" ++#include "utils.h" ++ ++TEST(utils_filters, test_filters) ++{ ++ struct filters_args *filters = filters_args_new(); ++ ASSERT_NE(filters, nullptr); ++ ++ const char *key1_outside = "lable"; ++ const char *key1_inside = "lable1"; ++ const char *value1_inside = "1"; ++ const char *value1_outside = "lable1=1"; ++ const char *exact_value1_outside = "lable2=2"; ++ const char *key2_outside = "id"; ++ const char *value2_outside = "id1=123"; ++ const char *key3_outside = "patten"; ++ const char *value3_outside = "^/?[a-zA-Z0-9][a-zA-Z0-9_.-]+$"; ++ const char *match_patten = "c8da28a6cea7443b648ec70a1c947b6cb920ee0ef3c4a691d4252ff6e1888036"; ++ const char *unmatch_patten = "#c8da28a6cea7443b648ec70a1c947b6cb920ee0ef3c4a691d4252ff6e1888036"; ++ ++ //test filters_args_add ++ ASSERT_EQ(filters_args_add(filters, key1_outside, value1_outside), true); ++ ASSERT_EQ(filters_args_add(filters, key2_outside, value2_outside), true); ++ ASSERT_EQ(filters_args_add(filters, key3_outside, value3_outside), true); ++ ++ ASSERT_EQ(filters_args_add(nullptr, key1_outside, value1_outside), false); ++ ++ //test filters_args_get ++ char **value = NULL; ++ value = filters_args_get(filters, key2_outside); ++ ASSERT_NE(value, nullptr); ++ ASSERT_STREQ(*value, value2_outside); ++ ++ value = filters_args_get(nullptr, key1_outside); ++ ASSERT_EQ(value, nullptr); ++ ++ // test filters_args_len ++ ASSERT_EQ(filters_args_len(nullptr), 0); ++ ASSERT_EQ(filters_args_len(filters), 3); ++ ++ //test filters_args_del ++ ASSERT_EQ(filters_args_del(filters, key2_outside, value2_outside), true); ++ value = filters_args_get(filters, key2_outside); ++ ASSERT_EQ(value, nullptr); ++ ++ ASSERT_EQ(filters_args_del(nullptr, key1_outside, value1_outside), false); ++ ++ //test filters_args_match_kv_list ++ map_t *source = map_new(MAP_STR_STR, MAP_DEFAULT_CMP_FUNC, MAP_DEFAULT_FREE_FUNC); ++ ASSERT_EQ(map_replace(source, (void *)key1_inside, (void *)value1_inside), true); ++ ++ ASSERT_EQ(filters_args_match_kv_list(filters, key1_outside, source), true); ++ ASSERT_EQ(filters_args_match_kv_list(filters, key1_outside, nullptr), false); ++ ASSERT_EQ(filters_args_match_kv_list(nullptr, key1_outside, source), true); ++ ++ //test filters_args_exact_match ++ ASSERT_EQ(filters_args_exact_match(filters, key1_outside, value1_outside), true); ++ ASSERT_EQ(filters_args_exact_match(filters, key1_outside, exact_value1_outside), false); ++ ASSERT_EQ(filters_args_exact_match(nullptr, key1_outside, exact_value1_outside), true); ++ ASSERT_EQ(filters_args_exact_match(filters, key1_outside, nullptr), false); ++ ++ //test filters_args_match ++ ASSERT_EQ(filters_args_match(filters, key3_outside, match_patten), true); ++ ASSERT_EQ(filters_args_match(filters, key3_outside, unmatch_patten), false); ++ ASSERT_EQ(filters_args_match(nullptr, key3_outside, match_patten), true); ++ ASSERT_EQ(filters_args_match(filters, key3_outside, nullptr), false); ++ ++ //test filters_args_free ++ filters_args_free(nullptr); ++ filters_args_free(filters); ++} ++ ++TEST(utils_filters, test_filters_args_valid_key) ++{ ++ const char *accepted_filters[] = { "id", "label", "name", NULL }; ++ const char *valid = "name"; ++ const char *invalid = "description"; ++ ++ ASSERT_EQ(filters_args_valid_key(accepted_filters, sizeof(accepted_filters) / sizeof(char *), valid), true); ++ ASSERT_EQ(filters_args_valid_key(accepted_filters, sizeof(accepted_filters) / sizeof(char *), invalid), false); ++ ++ ASSERT_EQ(filters_args_valid_key(accepted_filters, sizeof(accepted_filters) / sizeof(char *), nullptr), false); ++ ASSERT_EQ(filters_args_valid_key(nullptr, 3, valid), false); ++ ASSERT_EQ(filters_args_valid_key(accepted_filters, 1, valid), false); ++ ASSERT_EQ(filters_args_valid_key(accepted_filters, 5, valid), true); ++ ++} +\ No newline at end of file +-- +2.25.1 + diff --git a/0017-add-static-for-unexport-function.patch b/0017-add-static-for-unexport-function.patch new file mode 100644 index 0000000..79bb2a9 --- /dev/null +++ b/0017-add-static-for-unexport-function.patch @@ -0,0 +1,91 @@ +From 5b7c5fd4d856ad222dc51d79f8cf972730e48a54 Mon Sep 17 00:00:00 2001 +From: haozi007 +Date: Mon, 17 Oct 2022 14:31:39 +0800 +Subject: [PATCH 17/39] add static for unexport function + +1. add static for inner function; +2. add check for aguments; +3. remove same code; + +Signed-off-by: haozi007 +--- + src/utils/cutils/utils_timestamp.c | 21 ++++++++++++--------- + 1 file changed, 12 insertions(+), 9 deletions(-) + +diff --git a/src/utils/cutils/utils_timestamp.c b/src/utils/cutils/utils_timestamp.c +index c490c00e..85551d51 100644 +--- a/src/utils/cutils/utils_timestamp.c ++++ b/src/utils/cutils/utils_timestamp.c +@@ -39,7 +39,7 @@ bool unix_nanos_to_timestamp(int64_t nanos, types_timestamp_t *timestamp) + return true; + } + +-int types_timestamp_cmp_check(const types_timestamp_t *t1, const types_timestamp_t *t2) ++static int types_timestamp_cmp_check(const types_timestamp_t *t1, const types_timestamp_t *t2) + { + if (t1 == NULL && t2 == NULL) { + return 0; +@@ -54,7 +54,7 @@ int types_timestamp_cmp_check(const types_timestamp_t *t1, const types_timestamp + return 2; + } + +-int types_timestamp_cmp_nanos(const types_timestamp_t *t1, const types_timestamp_t *t2) ++static int types_timestamp_cmp_nanos(const types_timestamp_t *t1, const types_timestamp_t *t2) + { + if (t1->has_nanos && t2->has_nanos) { + if (t1->nanos > t2->nanos) { +@@ -147,7 +147,7 @@ bool util_get_timestamp(const char *str_time, types_timestamp_t *timestamp) + return true; + } + +-bool get_time_buffer_help(const types_timestamp_t *timestamp, char *timebuffer, size_t maxsize, bool local_utc) ++static bool get_time_buffer_help(const types_timestamp_t *timestamp, char *timebuffer, size_t maxsize, bool local_utc) + { + int nret = 0; + int tm_zone_hour = 0; +@@ -222,6 +222,11 @@ bool util_get_now_time_stamp(types_timestamp_t *timestamp) + int err = 0; + struct timespec ts; + ++ if (timestamp == NULL) { ++ ERROR("Invalid arguments"); ++ return false; ++ } ++ + err = clock_gettime(CLOCK_REALTIME, &ts); + if (err != 0) { + ERROR("failed to get time"); +@@ -586,10 +591,11 @@ static bool get_tm_zone_from_str(const char *str, struct tm *tm, int32_t *nanos, + char *tmstr = NULL; + char *zp = NULL; + char *zonestr = NULL; ++ bool ret = false; + + if (hasnil(str, tm, nanos, tz)) { + ERROR("Get tm and timezone from str input error"); +- goto err_out; ++ return false; + } + + tmstr = util_strdup_s(str); +@@ -610,15 +616,12 @@ static bool get_tm_zone_from_str(const char *str, struct tm *tm, int32_t *nanos, + ERROR("init tz failed"); + goto err_out; + } +- +- free(tmstr); +- free(zonestr); +- return true; ++ ret = true; + + err_out: + free(tmstr); + free(zonestr); +- return false; ++ return ret; + } + + static int64_t get_minmus_time(struct tm *tm1, struct tm *tm2) +-- +2.25.1 + diff --git a/0018-add-ut-for-cutils-timestamp.patch b/0018-add-ut-for-cutils-timestamp.patch new file mode 100644 index 0000000..e1a2b28 --- /dev/null +++ b/0018-add-ut-for-cutils-timestamp.patch @@ -0,0 +1,296 @@ +From 725f5813ee3125ad3c55dfbe3aeb5d8155e93e8f Mon Sep 17 00:00:00 2001 +From: haozi007 +Date: Mon, 17 Oct 2022 20:16:58 +0800 +Subject: [PATCH 18/39] add ut for cutils timestamp + +Signed-off-by: haozi007 +--- + test/cutils/CMakeLists.txt | 1 + + test/cutils/utils_timestamp/CMakeLists.txt | 16 ++ + .../utils_timestamp/utils_timestamp_ut.cc | 241 ++++++++++++++++++ + 3 files changed, 258 insertions(+) + create mode 100644 test/cutils/utils_timestamp/CMakeLists.txt + create mode 100644 test/cutils/utils_timestamp/utils_timestamp_ut.cc + +diff --git a/test/cutils/CMakeLists.txt b/test/cutils/CMakeLists.txt +index 4e67d9ed..7f454f75 100644 +--- a/test/cutils/CMakeLists.txt ++++ b/test/cutils/CMakeLists.txt +@@ -28,3 +28,4 @@ add_subdirectory(utils_aes) + add_subdirectory(utils_error) + add_subdirectory(utils_fs) + add_subdirectory(utils_filters) ++add_subdirectory(utils_timestamp) +diff --git a/test/cutils/utils_timestamp/CMakeLists.txt b/test/cutils/utils_timestamp/CMakeLists.txt +new file mode 100644 +index 00000000..38aec640 +--- /dev/null ++++ b/test/cutils/utils_timestamp/CMakeLists.txt +@@ -0,0 +1,16 @@ ++project(iSulad_UT) ++ ++SET(EXE utils_timestamp_ut) ++ ++add_executable(${EXE} ++ utils_timestamp_ut.cc) ++ ++target_include_directories(${EXE} PUBLIC ++ ${GTEST_INCLUDE_DIR} ++ ${CMAKE_CURRENT_SOURCE_DIR}/../../include ++ ${CMAKE_CURRENT_SOURCE_DIR}/../../../src/common ++ ${CMAKE_CURRENT_SOURCE_DIR}/../../../src/utils/cutils/map ++ ${CMAKE_CURRENT_SOURCE_DIR}/../../../src/utils/cutils ++ ) ++target_link_libraries(${EXE} ${GTEST_BOTH_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT} ${ISULA_LIBUTILS_LIBRARY} libutils_ut -lcrypto -lyajl -lz) ++add_test(NAME ${EXE} COMMAND ${EXE} --gtest_output=xml:${EXE}-Results.xml) +diff --git a/test/cutils/utils_timestamp/utils_timestamp_ut.cc b/test/cutils/utils_timestamp/utils_timestamp_ut.cc +new file mode 100644 +index 00000000..d6756e3a +--- /dev/null ++++ b/test/cutils/utils_timestamp/utils_timestamp_ut.cc +@@ -0,0 +1,241 @@ ++/****************************************************************************** ++ * Copyright (c) Huawei Technologies Co., Ltd. 2022. All rights reserved. ++ * iSulad licensed under the Mulan PSL v2. ++ * You can use this software according to the terms and conditions of the Mulan PSL v2. ++ * You may obtain a copy of Mulan PSL v2 at: ++ * http://license.coscl.org.cn/MulanPSL2 ++ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR ++ * IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR ++ * PURPOSE. ++ * See the Mulan PSL v2 for more details. ++ * Author: haozi007 ++ * Create: 2022-10-13 ++ * Description: utils timestamp unit test ++ *******************************************************************************/ ++ ++#include ++#include "utils_timestamp.h" ++ ++TEST(utils_timestamp, test_util_types_timestamp_cmp) ++{ ++ types_timestamp_t t1 = { 0 }; ++ types_timestamp_t t2 = { 0 }; ++ ++ // t1 == t2 ++ ASSERT_EQ(util_types_timestamp_cmp(&t1, &t2), 0); ++ ++ t1.has_seconds = true; ++ t1.seconds = 2; ++ t1.has_nanos = false; ++ t1.nanos = 0; ++ t2.has_seconds = false; ++ t2.seconds = 0; ++ t2.has_nanos = false; ++ t2.nanos = 100; ++ // t1 > t2 ++ ASSERT_EQ(util_types_timestamp_cmp(&t1, &t2), 1); ++ ++ t1.has_seconds = false; ++ t1.seconds = 2; ++ t1.has_nanos = false; ++ t1.nanos = 0; ++ t2.has_seconds = true; ++ t2.seconds = 1; ++ t2.has_nanos = true; ++ t2.nanos = 100; ++ // t1 < t2 ++ ASSERT_EQ(util_types_timestamp_cmp(&t1, &t2), -1); ++ ++ t1.has_seconds = true; ++ t1.seconds = 2; ++ t1.has_nanos = false; ++ t1.nanos = 0; ++ t2.has_seconds = true; ++ t2.seconds = 2; ++ t2.has_nanos = false; ++ t2.nanos = 0; ++ // t1 == t2 ++ ASSERT_EQ(util_types_timestamp_cmp(&t1, &t2), 0); ++ ++ t1.has_nanos = true; ++ t1.nanos = 88; ++ t2.has_nanos = true; ++ t2.nanos = 88; ++ // t1 == t2 ++ ASSERT_EQ(util_types_timestamp_cmp(&t1, &t2), 0); ++} ++ ++TEST(utils_timestamp, test_util_get_timestamp) ++{ ++ types_timestamp_t t = { 0 }; ++ std::string invalid_str = "1970-01-02X:00:xx"; ++ std::string dstr1 = "1970-01-01T00:00:01.000000800"; ++ struct tm tm_local = { 0 }; ++ const time_t now_time = time(NULL); ++ long int tm_gmtoff = 0; ++ ++ (void)localtime_r(&now_time, &tm_local); ++#ifdef __USE_MISC ++ tm_gmtoff = tm_local.tm_gmtoff; ++#else ++ tm_gmtoff = tm_local.__tm_gmtoff; ++#endif ++ ++ ASSERT_EQ(util_get_timestamp(dstr1.c_str(), &t), true); ++ t.seconds += tm_gmtoff; ++ ASSERT_EQ(t.has_seconds, true); ++ ASSERT_EQ(t.seconds, 1); ++ ASSERT_EQ(t.has_nanos, true); ++ ASSERT_EQ(t.nanos, 800); ++ ++ // invalid agruments check ++ ASSERT_EQ(util_get_timestamp(nullptr, &t), false); ++ ASSERT_EQ(util_get_timestamp(dstr1.c_str(), nullptr), false); ++ ASSERT_EQ(util_get_timestamp(invalid_str.c_str(), nullptr), false); ++} ++ ++TEST(utils_timestamp, test_util_get_now_local_utc_time_buffer) ++{ ++ char local_time[128] = { 0 }; ++ ++ ASSERT_EQ(util_get_now_local_utc_time_buffer(local_time, 128), true); ++ ASSERT_EQ(util_get_now_local_utc_time_buffer(nullptr, 0), false); ++} ++ ++TEST(utils_timestamp, test_util_get_time_interval) ++{ ++ types_timestamp_t t1 = { 0 }; ++ types_timestamp_t t2 = { 0 }; ++ int64_t ret = 0; ++ ++ ASSERT_EQ(util_get_time_interval(t1, t2, &ret), 0); ++ ASSERT_EQ(ret, 0); ++ ++ t2.has_seconds = true; ++ t2.seconds = 8; ++ t2.has_nanos = true; ++ t2.nanos = 8; ++ ASSERT_EQ(util_get_time_interval(t1, t2, &ret), 0); ++ ASSERT_EQ(ret, 8000000008); ++ ++ t2.has_seconds = true; ++ t2.seconds = INT64_MAX; ++ t2.has_nanos = false; ++ t2.nanos = 0; ++ ASSERT_NE(util_get_time_interval(t1, t2, &ret), 0); ++ ++ t2.seconds = INT64_MAX - 1; ++ t2.has_nanos = true; ++ t2.nanos = 100; ++ ASSERT_NE(util_get_time_interval(t1, t2, &ret), 0); ++} ++ ++TEST(utils_timestamp, test_util_get_tm_from_str) ++{ ++ std::string invalid_str = "2016-01-02T15:04:01:03"; ++ ++ std::vector> cases = { ++ std::make_tuple("1970-01-01T01", 0, 0, 0, 1, 1, 0, 70), ++ std::make_tuple("1980-02-02T02:02", 0, 0, 2, 2, 2, 1, 80), ++ std::make_tuple("1990-03-03T03:03:03", 0, 3, 3, 3, 3, 2, 90), ++ }; ++ ++ for (const auto &cs : cases) { ++ struct tm got = { 0 }; ++ int32_t nano = 0; ++ ASSERT_EQ(util_get_tm_from_str(std::get<0>(elem).c_str(), &got, &nano), true); ++ ASSERT_EQ(nano, std::get<1>(elem)); ++ ASSERT_EQ(got.tm_sec, std::get<2>(elem)); ++ ASSERT_EQ(got.tm_min, std::get<3>(elem)); ++ ASSERT_EQ(got.tm_hour, std::get<4>(elem)); ++ ASSERT_EQ(got.tm_mday, std::get<5>(elem)); ++ ASSERT_EQ(got.tm_mon, std::get<6>(elem)); ++ ASSERT_EQ(got.tm_year, std::get<7>(elem)); ++ } ++ ++ // check invalid cases ++ ASSERT_NE(util_get_tm_from_str(invalid_str.c_str(), &got, &nano), true); ++ ASSERT_NE(util_get_tm_from_str(nullptr, &got, &nano), true); ++ ASSERT_NE(util_get_tm_from_str(invalid_str.c_str(), nullptr, &nano), true); ++ ASSERT_NE(util_get_tm_from_str(invalid_str.c_str(), &got, nullptr), true); ++} ++ ++TEST(utils_timestamp, test_util_time_seconds_since) ++{ ++ std::string defaultstr = "-"; ++ std::string invalid_str = "2016-01-02T15:04:01:03"; ++ std::string dstr1 = "1990-03-03T03:03:03"; ++ types_timestamp_t currt = { 0 }; ++ char tbuf[128] = { 0 }; ++ int64_t ret; ++ ++ ASSERT_EQ(util_get_now_time_stamp(&currt), true); ++ currt.seconds -= 10; ++ ASSERT_EQ(util_get_time_buffer(&currt, tbuf, 128), true); ++ ret = util_time_seconds_since(tbuf); ++ ASSERT_GE(ret, 9); ++ ASSERT_LE(ret, 11); ++ ++ ASSERT_EQ(util_time_seconds_since(dstr1.c_str()), 0); ++ ++ // invalid cases ++ ASSERT_EQ(util_time_seconds_since(invalid_str.c_str()), 0); ++ ASSERT_EQ(util_time_seconds_since(nullptr), 0); ++ ASSERT_EQ(util_time_seconds_since(defaultContainerTime), 0); ++ ASSERT_EQ(util_time_seconds_since(defaultstr.c_str()), 0); ++} ++ ++TEST(utils_timestamp, test_util_time_format_duration) ++{ ++ std::string invalid_str = "2016-01-02T15:04:01:03"; ++ std::string dstr3 = "1990-03-03T03:03:03.000000000+08:00"; ++ std::string defaultstr = "-"; ++ char out[128] = { 0 }; ++ ++ ASSERT_EQ(util_time_format_duration(dstr3.c_str(), out, 128), 0); ++ ++ // invalid cases ++ ASSERT_EQ(util_time_format_duration(invalid_str.c_str(), out, 128), 1); ++ ASSERT_EQ(util_time_format_duration(nullptr, out, 128), 1); ++ ASSERT_EQ(util_time_format_duration(defaultContainerTime, out, 128), 1); ++ ASSERT_EQ(util_time_format_duration(defaultstr.c_str(), out, 128), 1); ++ ASSERT_EQ(util_time_format_duration(invalid_str.c_str(), out, 0), -1); ++} ++ ++TEST(utils_timestamp, test_util_to_unix_nanos_from_str) ++{ ++ std::string invalid_str = "2016-01-02T15:04:01:03"; ++ std::string dstr3 = "1970-01-01T00:00:01.0+00:00"; ++ int64_t ret = 0; ++ ++ ASSERT_EQ(util_to_unix_nanos_from_str(dstr3.c_str(), &ret), 0); ++ ASSERT_EQ(ret, 1000000000); ++ ++ // invalid cases ++ ASSERT_NE(util_to_unix_nanos_from_str(invalid_str.c_str(), &ret), 0); ++ ASSERT_EQ(util_to_unix_nanos_from_str(nullptr, &ret), 0); ++} ++ ++TEST(utils_timestamp, test_util_time_str_to_nanoseconds) ++{ ++ int64_t ret = 0; ++ std::string invalid_str = "xxxxxxx"; ++ std::string dstr2 = "1ms"; ++ std::string dstr3 = "2s"; ++ std::string dstr4 = "1m"; ++ std::string dstr5 = "1h"; ++ ++ ASSERT_EQ(util_time_str_to_nanoseconds(dstr2.c_str(), &ret), 0); ++ ASSERT_EQ(ret, Time_Milli); ++ ASSERT_EQ(util_time_str_to_nanoseconds(dstr3.c_str(), &ret), 0); ++ ASSERT_EQ(ret, 2 * Time_Second); ++ ASSERT_EQ(util_time_str_to_nanoseconds(dstr4.c_str(), &ret), 0); ++ ASSERT_EQ(ret, 60 * Time_Second); ++ ASSERT_EQ(util_time_str_to_nanoseconds(dstr5.c_str(), &ret), 0); ++ ASSERT_EQ(ret, 3600 * Time_Second); ++ ++ // invalid cases ++ ASSERT_NE(util_time_str_to_nanoseconds(invalid_str.c_str(), &ret), 0); ++ ASSERT_NE(util_time_str_to_nanoseconds(nullptr, &ret), 0); ++ ASSERT_NE(util_time_str_to_nanoseconds(dstr3.c_str(), nullptr), 0); ++} +\ No newline at end of file +-- +2.25.1 + diff --git a/0019-fix-timestamp-ut-error.patch b/0019-fix-timestamp-ut-error.patch new file mode 100644 index 0000000..f9c2e76 --- /dev/null +++ b/0019-fix-timestamp-ut-error.patch @@ -0,0 +1,37 @@ +From e437396ff5bc90bfa3736e0ef06be117bca4b174 Mon Sep 17 00:00:00 2001 +From: haozi007 +Date: Tue, 18 Oct 2022 10:23:34 +0800 +Subject: [PATCH 19/39] fix timestamp ut error + +Signed-off-by: haozi007 +--- + test/cutils/utils_timestamp/utils_timestamp_ut.cc | 6 +++--- + 1 file changed, 3 insertions(+), 3 deletions(-) + +diff --git a/test/cutils/utils_timestamp/utils_timestamp_ut.cc b/test/cutils/utils_timestamp/utils_timestamp_ut.cc +index d6756e3a..0f6b80f6 100644 +--- a/test/cutils/utils_timestamp/utils_timestamp_ut.cc ++++ b/test/cutils/utils_timestamp/utils_timestamp_ut.cc +@@ -133,6 +133,8 @@ TEST(utils_timestamp, test_util_get_time_interval) + TEST(utils_timestamp, test_util_get_tm_from_str) + { + std::string invalid_str = "2016-01-02T15:04:01:03"; ++ struct tm got = { 0 }; ++ int32_t nano = 0; + + std::vector> cases = { + std::make_tuple("1970-01-01T01", 0, 0, 0, 1, 1, 0, 70), +@@ -140,9 +142,7 @@ TEST(utils_timestamp, test_util_get_tm_from_str) + std::make_tuple("1990-03-03T03:03:03", 0, 3, 3, 3, 3, 2, 90), + }; + +- for (const auto &cs : cases) { +- struct tm got = { 0 }; +- int32_t nano = 0; ++ for (const auto &elem : cases) { + ASSERT_EQ(util_get_tm_from_str(std::get<0>(elem).c_str(), &got, &nano), true); + ASSERT_EQ(nano, std::get<1>(elem)); + ASSERT_EQ(got.tm_sec, std::get<2>(elem)); +-- +2.25.1 + diff --git a/0020-improve-code-in-utils_mount_spec.patch b/0020-improve-code-in-utils_mount_spec.patch new file mode 100644 index 0000000..324b8da --- /dev/null +++ b/0020-improve-code-in-utils_mount_spec.patch @@ -0,0 +1,45 @@ +From 99df201139e1afbc719f78bae047eaf826676b7f Mon Sep 17 00:00:00 2001 +From: zhongtao +Date: Mon, 17 Oct 2022 20:20:00 +0800 +Subject: [PATCH 20/39] improve code in utils_mount_spec + +Signed-off-by: zhongtao +--- + src/utils/cutils/utils_mount_spec.c | 16 ++++++++++++---- + 1 file changed, 12 insertions(+), 4 deletions(-) + +diff --git a/src/utils/cutils/utils_mount_spec.c b/src/utils/cutils/utils_mount_spec.c +index d8f64c81..e9b23cf2 100644 +--- a/src/utils/cutils/utils_mount_spec.c ++++ b/src/utils/cutils/utils_mount_spec.c +@@ -458,15 +458,23 @@ int util_parse_mount_spec(char *mount_str, mount_spec **spec, char **errmsg_out) + + if (mount_str == NULL) { + CACHE_ERRMSG(errmsg, "Invalid mount specification: can't be empty"); +- ret = -1; +- goto out; ++ return -1; + } + if (!mount_str[0]) { + CACHE_ERRMSG(errmsg, "Invalid mount specification: can't be empty"); +- ret = -1; +- goto out; ++ return -1; + } + ++ if(spec == NULL){ ++ CACHE_ERRMSG(errmsg, "Invalid spec: can't be NULL"); ++ return -1; ++ } ++ ++ if(errmsg_out == NULL){ ++ CACHE_ERRMSG(errmsg, "Invalid errmsg_out: can't be NULL"); ++ return -1; ++ } ++ + m = util_common_calloc_s(sizeof(mount_spec)); + if (m == NULL) { + CACHE_ERRMSG(errmsg, "out of memory"); +-- +2.25.1 + diff --git a/0021-Add-ut-for-utils_mount_spec.patch b/0021-Add-ut-for-utils_mount_spec.patch new file mode 100644 index 0000000..be8e636 --- /dev/null +++ b/0021-Add-ut-for-utils_mount_spec.patch @@ -0,0 +1,118 @@ +From 7e4921d01576f180c3624195a0edff4b4f6807f8 Mon Sep 17 00:00:00 2001 +From: zhongtao +Date: Tue, 18 Oct 2022 10:46:14 +0800 +Subject: [PATCH 21/39] Add ut for utils_mount_spec + +Signed-off-by: zhongtao +--- + test/cutils/CMakeLists.txt | 1 + + test/cutils/utils_mount_spec/CMakeLists.txt | 16 +++++ + .../utils_mount_spec/utils_mount_spec_ut.cc | 64 +++++++++++++++++++ + 3 files changed, 81 insertions(+) + create mode 100644 test/cutils/utils_mount_spec/CMakeLists.txt + create mode 100644 test/cutils/utils_mount_spec/utils_mount_spec_ut.cc + +diff --git a/test/cutils/CMakeLists.txt b/test/cutils/CMakeLists.txt +index 7f454f75..f159aacb 100644 +--- a/test/cutils/CMakeLists.txt ++++ b/test/cutils/CMakeLists.txt +@@ -29,3 +29,4 @@ add_subdirectory(utils_error) + add_subdirectory(utils_fs) + add_subdirectory(utils_filters) + add_subdirectory(utils_timestamp) ++add_subdirectory(utils_mount_spec) +diff --git a/test/cutils/utils_mount_spec/CMakeLists.txt b/test/cutils/utils_mount_spec/CMakeLists.txt +new file mode 100644 +index 00000000..24fb5add +--- /dev/null ++++ b/test/cutils/utils_mount_spec/CMakeLists.txt +@@ -0,0 +1,16 @@ ++project(iSulad_UT) ++ ++SET(EXE utils_mount_spec_ut) ++ ++add_executable(${EXE} ++ utils_mount_spec_ut.cc) ++ ++target_include_directories(${EXE} PUBLIC ++ ${GTEST_INCLUDE_DIR} ++ ${CMAKE_CURRENT_SOURCE_DIR}/../../include ++ ${CMAKE_CURRENT_SOURCE_DIR}/../../../src/common ++ ${CMAKE_CURRENT_SOURCE_DIR}/../../../src/utils/cutils/map ++ ${CMAKE_CURRENT_SOURCE_DIR}/../../../src/utils/cutils ++ ) ++target_link_libraries(${EXE} ${GTEST_BOTH_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT} ${ISULA_LIBUTILS_LIBRARY} libutils_ut -lcrypto -lyajl -lz) ++add_test(NAME ${EXE} COMMAND ${EXE} --gtest_output=xml:${EXE}-Results.xml) +diff --git a/test/cutils/utils_mount_spec/utils_mount_spec_ut.cc b/test/cutils/utils_mount_spec/utils_mount_spec_ut.cc +new file mode 100644 +index 00000000..0f60d397 +--- /dev/null ++++ b/test/cutils/utils_mount_spec/utils_mount_spec_ut.cc +@@ -0,0 +1,64 @@ ++/****************************************************************************** ++ * Copyright (c) Huawei Technologies Co., Ltd. 2022. All rights reserved. ++ * iSulad licensed under the Mulan PSL v2. ++ * You can use this software according to the terms and conditions of the Mulan PSL v2. ++ * You may obtain a copy of Mulan PSL v2 at: ++ * http://license.coscl.org.cn/MulanPSL2 ++ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR ++ * IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR ++ * PURPOSE. ++ * See the Mulan PSL v2 for more details. ++ * Author: zhongtao ++ * Create: 2022-10-18 ++ * Description: utils mount spec unit test ++ *******************************************************************************/ ++ ++#include ++#include "utils_mount_spec.h" ++ ++TEST(utils_mount_spec, test_util_valid_mount_spec) ++{ ++ char *base_valid = (char *)"type=bind,source=/home,target=/vol3,readonly=true,bind-selinux-opts=z,bind-propagation=rprivate"; ++ char *oci_valid = (char *)"type=tmpfs,dst=/tmpfs,tmpfs-size=1m,tmpfs-mode=1700"; ++ char *invalid1 = (char *)"type=volume,src=vol,dst=/vol,ro=true,red=false"; ++ char *invalid2 = (char *)"type,src,dst"; ++ char *errmsg = NULL; ++ ++ ASSERT_EQ(util_valid_mount_spec(base_valid, &errmsg), true); ++ ASSERT_EQ(util_valid_mount_spec(oci_valid, &errmsg), true); ++ ++ ASSERT_EQ(util_valid_mount_spec(invalid1, &errmsg), false); ++ ASSERT_EQ(util_valid_mount_spec(invalid2, &errmsg), false); ++ ASSERT_EQ(util_valid_mount_spec(nullptr, &errmsg), false); ++ ASSERT_EQ(util_valid_mount_spec(base_valid, nullptr), false); ++} ++ ++TEST(utils_mount_spec, test_util_parse_mount_spec) ++{ ++ char *base_valid = (char *)"type=bind,source=/home,target=/vol3,readonly=true,bind-selinux-opts=z,bind-propagation=rprivate"; ++ char *oci_valid = (char *)"type=tmpfs,dst=/tmpfs,tmpfs-size=1m,tmpfs-mode=1700"; ++ char *invalid1 = (char *)"type=volume,src=vol,dst=/vol,ro=true,red=false"; ++ char *invalid2 = (char *)"type,src,dst"; ++ mount_spec *m = NULL; ++ char *errmsg = NULL; ++ ++ ASSERT_EQ(util_parse_mount_spec(base_valid, &m, &errmsg), 0); ++ ASSERT_STREQ(m->type, "bind"); ++ ASSERT_STREQ(m->source, "/home"); ++ ASSERT_STREQ(m->target, "/vol3"); ++ ASSERT_EQ(m->readonly, true); ++ ASSERT_STREQ(m->bind_options->propagation, "rprivate"); ++ ASSERT_STREQ(m->bind_options->selinux_opts, "z"); ++ ++ ASSERT_EQ(util_parse_mount_spec(oci_valid, &m, &errmsg), 0); ++ ASSERT_STREQ(m->type, "tmpfs"); ++ ASSERT_STREQ(m->target, "/tmpfs"); ++ ASSERT_EQ(m->tmpfs_options->size_bytes, 1048576); ++ ASSERT_EQ(m->tmpfs_options->mode, 960); ++ ++ ASSERT_NE(util_parse_mount_spec(invalid1, &m, &errmsg), 0); ++ ASSERT_NE(util_parse_mount_spec(invalid2, &m, &errmsg), 0); ++ ASSERT_NE(util_parse_mount_spec(nullptr, &m, &errmsg), 0); ++ ASSERT_NE(util_parse_mount_spec(base_valid, nullptr, &errmsg), 0); ++ ASSERT_NE(util_parse_mount_spec(base_valid, &m, nullptr), 0); ++} +-- +2.25.1 + diff --git a/0022-Add-ut-for-utils_regex.patch b/0022-Add-ut-for-utils_regex.patch new file mode 100644 index 0000000..ba7f635 --- /dev/null +++ b/0022-Add-ut-for-utils_regex.patch @@ -0,0 +1,100 @@ +From e43af2dc017a63a772c7dea2583d7d58506d7608 Mon Sep 17 00:00:00 2001 +From: zhongtao +Date: Tue, 18 Oct 2022 11:50:37 +0800 +Subject: [PATCH 22/39] Add ut for utils_regex + +Signed-off-by: zhongtao +--- + test/cutils/CMakeLists.txt | 1 + + test/cutils/utils_regex/CMakeLists.txt | 16 ++++++++ + test/cutils/utils_regex/utils_regex_ut.cc | 46 +++++++++++++++++++++++ + 3 files changed, 63 insertions(+) + create mode 100644 test/cutils/utils_regex/CMakeLists.txt + create mode 100644 test/cutils/utils_regex/utils_regex_ut.cc + +diff --git a/test/cutils/CMakeLists.txt b/test/cutils/CMakeLists.txt +index f159aacb..4b235a09 100644 +--- a/test/cutils/CMakeLists.txt ++++ b/test/cutils/CMakeLists.txt +@@ -30,3 +30,4 @@ add_subdirectory(utils_fs) + add_subdirectory(utils_filters) + add_subdirectory(utils_timestamp) + add_subdirectory(utils_mount_spec) ++add_subdirectory(utils_regex) +diff --git a/test/cutils/utils_regex/CMakeLists.txt b/test/cutils/utils_regex/CMakeLists.txt +new file mode 100644 +index 00000000..3f6410b2 +--- /dev/null ++++ b/test/cutils/utils_regex/CMakeLists.txt +@@ -0,0 +1,16 @@ ++project(iSulad_UT) ++ ++SET(EXE utils_regex_ut) ++ ++add_executable(${EXE} ++ utils_regex_ut.cc) ++ ++target_include_directories(${EXE} PUBLIC ++ ${GTEST_INCLUDE_DIR} ++ ${CMAKE_CURRENT_SOURCE_DIR}/../../include ++ ${CMAKE_CURRENT_SOURCE_DIR}/../../../src/common ++ ${CMAKE_CURRENT_SOURCE_DIR}/../../../src/utils/cutils/map ++ ${CMAKE_CURRENT_SOURCE_DIR}/../../../src/utils/cutils ++ ) ++target_link_libraries(${EXE} ${GTEST_BOTH_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT} ${ISULA_LIBUTILS_LIBRARY} libutils_ut -lcrypto -lyajl -lz) ++add_test(NAME ${EXE} COMMAND ${EXE} --gtest_output=xml:${EXE}-Results.xml) +diff --git a/test/cutils/utils_regex/utils_regex_ut.cc b/test/cutils/utils_regex/utils_regex_ut.cc +new file mode 100644 +index 00000000..1b4414de +--- /dev/null ++++ b/test/cutils/utils_regex/utils_regex_ut.cc +@@ -0,0 +1,46 @@ ++/****************************************************************************** ++ * Copyright (c) Huawei Technologies Co., Ltd. 2022. All rights reserved. ++ * iSulad licensed under the Mulan PSL v2. ++ * You can use this software according to the terms and conditions of the Mulan PSL v2. ++ * You may obtain a copy of Mulan PSL v2 at: ++ * http://license.coscl.org.cn/MulanPSL2 ++ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR ++ * IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR ++ * PURPOSE. ++ * See the Mulan PSL v2 for more details. ++ * Author: zhongtao ++ * Create: 2022-10-18 ++ * Description: utils regex unit test ++ *******************************************************************************/ ++ ++#include ++#include "utils_regex.h" ++ ++TEST(utils_regex, test_util_reg_match) ++{ ++ const char *pattern = "^[a-f0-9]{64}$"; ++ const char *valid = "c8da28a6cea7443b648ec70a1c947b6cb920ee0ef3c4a691d4252ff6e1888036"; ++ const char *invalid = "g8da28a6cea7443b648ec70a1c947b6cb920ee0ef3c4a691d4252ff6e1888036"; ++ ++ ASSERT_EQ(util_reg_match(pattern, valid), 0); ++ ASSERT_EQ(util_reg_match(pattern, invalid), 1); ++ ++ ASSERT_EQ(util_reg_match(pattern, nullptr), -1); ++ ASSERT_EQ(util_reg_match(nullptr, pattern), -1); ++} ++ ++TEST(utils_regex, test_util_wildcard_to_regex) ++{ ++ std::string wildcard = "*hello?"; ++ char *value = NULL; ++ ++ ASSERT_EQ(util_wildcard_to_regex(wildcard.c_str(), &value), 0); ++ ASSERT_STREQ(value, "^.*hello.$"); ++ ++ wildcard = "file{1,2,3}"; ++ ASSERT_EQ(util_wildcard_to_regex(wildcard.c_str(), &value), 0); ++ ASSERT_STREQ(value, "^file\\{1,2,3\\}$"); ++ ++ ASSERT_EQ(util_wildcard_to_regex(nullptr, &value), -1); ++ ASSERT_EQ(util_wildcard_to_regex(wildcard.c_str(), nullptr), -1); ++} +-- +2.25.1 + diff --git a/0023-improve-code-in-utils.c.patch b/0023-improve-code-in-utils.c.patch new file mode 100644 index 0000000..28dae19 --- /dev/null +++ b/0023-improve-code-in-utils.c.patch @@ -0,0 +1,164 @@ +From 60ef94806076e728b6f76d5b9b874e375182233c Mon Sep 17 00:00:00 2001 +From: haozi007 +Date: Tue, 18 Oct 2022 15:47:36 +0800 +Subject: [PATCH 23/39] improve code in utils.c + +Signed-off-by: haozi007 +--- + src/utils/cutils/utils.c | 60 ++++++++++++++++++++++------------------ + 1 file changed, 33 insertions(+), 27 deletions(-) + +diff --git a/src/utils/cutils/utils.c b/src/utils/cutils/utils.c +index e362581b..eddfda5c 100644 +--- a/src/utils/cutils/utils.c ++++ b/src/utils/cutils/utils.c +@@ -64,13 +64,13 @@ int util_mem_realloc(void **newptr, size_t newsize, void *oldptr, size_t oldsize + void *tmp = NULL; + + if (newptr == NULL || newsize == 0) { +- goto err_out; ++ return -1; + } + + tmp = util_common_calloc_s(newsize); + if (tmp == NULL) { + ERROR("Failed to malloc memory"); +- goto err_out; ++ return -1; + } + + if (oldptr != NULL) { +@@ -82,9 +82,6 @@ int util_mem_realloc(void **newptr, size_t newsize, void *oldptr, size_t oldsize + + *newptr = tmp; + return 0; +- +-err_out: +- return -1; + } + + static int util_read_pipe(int pipe_fd, char **out_buf, size_t *out_buf_size, size_t *out_real_size) +@@ -353,8 +350,6 @@ void util_contain_errmsg(const char *errmsg, int *exit_code) + } else if (strcasestr(errmsg, "not a directory")) { + *exit_code = 127; + } +- +- return; + } + + char *util_short_digest(const char *digest) +@@ -818,6 +813,9 @@ bool util_exec_cmd(exec_func_t cb_func, void *args, const char *stdin_msg, char + close(in_fd[1]); + in_fd[1] = -1; + ++ if (stdout_msg == NULL) { ++ stdout_close_flag = 1; ++ } + for (;;) { + if (stdout_close_flag == 0) { + stdout_close_flag = util_read_pipe(out_fd[0], &stdout_buffer, &stdout_buf_size, &stdout_real_size); +@@ -840,8 +838,14 @@ bool util_exec_cmd(exec_func_t cb_func, void *args, const char *stdin_msg, char + close(err_fd[0]); + close(out_fd[0]); + out: +- *stdout_msg = stdout_buffer; +- *stderr_msg = stderr_buffer; ++ if (stdout_msg != NULL) { ++ *stdout_msg = stdout_buffer; ++ } ++ if (stderr_msg != NULL) { ++ *stderr_msg = stderr_buffer; ++ } else { ++ free(stderr_buffer); ++ } + return ret; + } + +@@ -947,8 +951,8 @@ int util_env_insert(char ***penv, size_t *penv_len, const char *key, size_t key_ + env = *penv; + env_len = *penv_len; + +- if (env_len > (SIZE_MAX / sizeof(char *)) - 1) { +- ERROR("Failed to realloc memory for envionment variables"); ++ if (env_len > (MAX_MEMORY_SIZE / sizeof(char *)) - 1) { ++ ERROR("Too large envionment variables"); + return -1; + } + +@@ -1108,7 +1112,7 @@ static int set_echo_back(bool echo_back) + return 0; + } + +-int util_input_notty(char *buf, size_t maxlen) ++static int util_input_notty(char *buf, size_t maxlen) + { + size_t i = 0; + int ret = 0; +@@ -1424,9 +1428,9 @@ int util_read_pid_ppid_info(uint32_t pid, pid_ppid_info_t *pid_info) + proc_t *proc = NULL; + proc_t *p_proc = NULL; + +- if (pid == 0) { +- ret = -1; +- goto out; ++ if (pid == 0 || pid_info == NULL) { ++ ERROR("Invalid arguments"); ++ return -1; + } + + proc = util_get_process_proc_info((pid_t)pid); +@@ -1506,8 +1510,8 @@ defs_map_string_object *dup_map_string_empty_object(defs_map_string_object *src) + return NULL; + } + +- dst->keys = util_common_calloc_s(src->len * sizeof(char *)); +- dst->values = util_common_calloc_s(src->len * sizeof(defs_map_string_object_element *)); ++ dst->keys = util_smart_calloc_s(sizeof(char *), src->len); ++ dst->values = util_smart_calloc_s(sizeof(defs_map_string_object_element *), src->len); + if (dst->keys == NULL || dst->values == NULL) { + ERROR("Out of memory"); + ret = -1; +@@ -1538,12 +1542,16 @@ int convert_v2_runtime(const char *runtime, char *binary) + size_t parts_len = 0; + char buf[PATH_MAX] = {0}; + int ret = 0; ++ int nret; ++ ++ if (binary == NULL) { ++ return -1; ++ } + + parts = util_string_split_multi(runtime, '.'); + if (parts == NULL) { + ERROR("split failed: %s", runtime); +- ret = -1; +- goto out; ++ return -1; + } + + parts_len = util_array_len((const char **)parts); +@@ -1553,15 +1561,13 @@ int convert_v2_runtime(const char *runtime, char *binary) + goto out; + } + +- if (binary != NULL) { +- int nret = snprintf(buf, sizeof(buf), "%s-%s-%s-%s", "containerd", "shim", parts[2], parts[3]); +- if (nret < 0 || (size_t)nret >= sizeof(buf)) { +- ERROR("Failed to snprintf string"); +- ret = -1; +- goto out; +- } +- strcpy(binary, buf); ++ nret = snprintf(buf, sizeof(buf), "%s-%s-%s-%s", "containerd", "shim", parts[2], parts[3]); ++ if (nret < 0 || (size_t)nret >= sizeof(buf)) { ++ ERROR("Failed to snprintf string"); ++ ret = -1; ++ goto out; + } ++ (void)strcpy(binary, buf); + + out: + util_free_array(parts); +-- +2.25.1 + diff --git a/0024-add-ut-for-cutils-utils.patch b/0024-add-ut-for-cutils-utils.patch new file mode 100644 index 0000000..a1597ee --- /dev/null +++ b/0024-add-ut-for-cutils-utils.patch @@ -0,0 +1,327 @@ +From fef883b9716bf8b71dd10152d9dea1b4e6952530 Mon Sep 17 00:00:00 2001 +From: haozi007 +Date: Tue, 18 Oct 2022 17:11:04 +0800 +Subject: [PATCH 24/39] add ut for cutils utils + +Signed-off-by: haozi007 +--- + test/cutils/CMakeLists.txt | 1 + + test/cutils/utils_utils/CMakeLists.txt | 16 ++ + test/cutils/utils_utils/utils_utils_ut.cc | 272 ++++++++++++++++++++++ + 3 files changed, 289 insertions(+) + create mode 100644 test/cutils/utils_utils/CMakeLists.txt + create mode 100644 test/cutils/utils_utils/utils_utils_ut.cc + +diff --git a/test/cutils/CMakeLists.txt b/test/cutils/CMakeLists.txt +index 4b235a09..23426015 100644 +--- a/test/cutils/CMakeLists.txt ++++ b/test/cutils/CMakeLists.txt +@@ -31,3 +31,4 @@ add_subdirectory(utils_filters) + add_subdirectory(utils_timestamp) + add_subdirectory(utils_mount_spec) + add_subdirectory(utils_regex) ++add_subdirectory(utils_utils) +diff --git a/test/cutils/utils_utils/CMakeLists.txt b/test/cutils/utils_utils/CMakeLists.txt +new file mode 100644 +index 00000000..7b3bd546 +--- /dev/null ++++ b/test/cutils/utils_utils/CMakeLists.txt +@@ -0,0 +1,16 @@ ++project(iSulad_UT) ++ ++SET(EXE utils_utils_ut) ++ ++add_executable(${EXE} ++ utils_utils_ut.cc) ++ ++target_include_directories(${EXE} PUBLIC ++ ${GTEST_INCLUDE_DIR} ++ ${CMAKE_CURRENT_SOURCE_DIR}/../../include ++ ${CMAKE_CURRENT_SOURCE_DIR}/../../../src/common ++ ${CMAKE_CURRENT_SOURCE_DIR}/../../../src/utils/cutils/map ++ ${CMAKE_CURRENT_SOURCE_DIR}/../../../src/utils/cutils ++ ) ++target_link_libraries(${EXE} ${GTEST_BOTH_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT} ${ISULA_LIBUTILS_LIBRARY} libutils_ut -lcrypto -lyajl -lz) ++add_test(NAME ${EXE} COMMAND ${EXE} --gtest_output=xml:${EXE}-Results.xml) +diff --git a/test/cutils/utils_utils/utils_utils_ut.cc b/test/cutils/utils_utils/utils_utils_ut.cc +new file mode 100644 +index 00000000..531947d2 +--- /dev/null ++++ b/test/cutils/utils_utils/utils_utils_ut.cc +@@ -0,0 +1,272 @@ ++/****************************************************************************** ++ * Copyright (c) Huawei Technologies Co., Ltd. 2022. All rights reserved. ++ * iSulad licensed under the Mulan PSL v2. ++ * You can use this software according to the terms and conditions of the Mulan PSL v2. ++ * You may obtain a copy of Mulan PSL v2 at: ++ * http://license.coscl.org.cn/MulanPSL2 ++ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR ++ * IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR ++ * PURPOSE. ++ * See the Mulan PSL v2 for more details. ++ * Author: haozi007 ++ * Create: 2022-10-18 ++ * Description: utils unit test ++ *******************************************************************************/ ++ ++#include ++#include "utils.h" ++ ++TEST(utils_utils, test_util_mem_realloc) ++{ ++ char *old = nullptr; ++ ASSERT_EQ(util_mem_realloc(nullptr, 0, old, 0), -1); ++} ++ ++TEST(utils_utils, test_util_sig_parse) ++{ ++ std::string num_str = "9"; ++ std::string sig_str = "SIGSEGV"; ++ std::string sig_only = "SEGV"; ++ ++ ASSERT_EQ(util_sig_parse(nullptr), -1); ++ ASSERT_EQ(util_sig_parse(num_str.c_str()), 9); ++ ASSERT_EQ(util_sig_parse(sig_str.c_str()), 11); ++ ASSERT_EQ(util_sig_parse(sig_str.c_str()), 11); ++} ++ ++TEST(utils_utils, test_util_contain_errmsg) ++{ ++ int exit_code = 0; ++ std::string teststr = "hello world"; ++ std::vector> cases = { ++ std::make_tuple("executable file not found", 127), ++ std::make_tuple("no such file or directory", 127), ++ std::make_tuple("system cannot find the file specified", 127), ++ std::make_tuple("permission denied", 126), ++ std::make_tuple("not a directory", 127), ++ }; ++ ++ for (const auto &elem : cases) { ++ util_contain_errmsg(std::get<0>(elem).c_str(), &exit_code); ++ ASSERT_EQ(exit_code, std::get<1>(elem)); ++ } ++ ++ // invalid cases ++ util_contain_errmsg(nullptr, &exit_code); ++ util_contain_errmsg(teststr.c_str(), &exit_code); ++ util_contain_errmsg(teststr.c_str(), nullptr); ++} ++ ++TEST(utils_utils, test_util_digest) ++{ ++ std::string valid_dg = "sha256:729ce43e2c915c3463b620f3fba201a4a641ca5a282387e233db799208342a08"; ++ std::string invalid_dg = "xxxx"; ++ ++ ASSERT_STREQ(util_short_digest(valid_dg.c_str()), "729ce43e2c91"); ++ ASSERT_STREQ(util_short_digest(invalid_dg.c_str()), nullptr); ++ ASSERT_STREQ(util_short_digest(nullptr), nullptr); ++ ASSERT_STREQ(util_full_digest(nullptr), nullptr); ++} ++ ++TEST(utils_utils, test_util_proc_info) ++{ ++ char buf[1024] = {0}; ++ pid_t cpid = getpid(); ++ proc_t *pt = nullptr; ++ ++ ASSERT_EQ(util_stat2proc(nullptr, 10), nullptr); ++ ASSERT_EQ(util_stat2proc(buf, 0), nullptr); ++ ++ ASSERT_EQ(util_process_alive(0, 10000), false); ++ // maybe return true ++ ASSERT_EQ(util_process_alive(10000000, 10000), false); ++ ++ pt = util_get_process_proc_info(cpid); ++ ASSERT_NE(pt, nullptr); ++ ASSERT_EQ(util_process_alive(cpid, pt->start_time), true); ++ ASSERT_EQ(util_process_alive(cpid, 11), false); ++ ++} ++ ++void top_cb(char **args, const char *pid_args, size_t args_len) ++{ ++ printf("this is stdout\n"); ++ fprintf(stderr, "this is stderr\n"); ++ exit(0); ++} ++ ++TEST(utils_utils, test_util_exec_top_cmd) ++{ ++ char *out_str = nullptr; ++ char *err_str = nullptr; ++ ++ ASSERT_EQ(util_exec_top_cmd(top_cb, nullptr, nullptr, 0, &out_str, &err_str), true); ++ ASSERT_NE(out_str, nullptr); ++ free(out_str); ++ ASSERT_NE(err_str, nullptr); ++ free(err_str); ++} ++ ++TEST(utils_utils, test_util_get_backtrace) ++{ ++ char **ret = util_get_backtrace(); ++ ++ ASSERT_NE(ret, nullptr); ++ free(ret); ++} ++ ++TEST(utils_utils, test_util_env_ops) ++{ ++ char **ret = nullptr; ++ size_t ret_len = 0; ++ std::string first_val = "hello=world"; ++ std::string second_val = "todo=test"; ++ std::string new_val = "hello=test"; ++ std::string key1 = "hello"; ++ std::string key2 = "todo"; ++ char *got = nullptr; ++ ++ ASSERT_EQ(util_env_insert(&ret, &ret_len, key1.c_str(), key1.size(), first_val.c_str()), 0); ++ ASSERT_EQ(ret_len, 1); ++ ASSERT_STREQ(ret[0], first_val.c_str()); ++ ++ ASSERT_EQ(util_env_insert(&ret, &ret_len, key2.c_str(), key2.size(), second_val.c_str()), 0); ++ ASSERT_EQ(ret_len, 2); ++ ASSERT_STREQ(ret[1], second_val.c_str()); ++ ++ ++ got = util_env_get_val(ret, ret_len, key1.c_str(), key1.size()); ++ ASSERT_STREQ(got, "world"); ++ free(got); ++ ++ ASSERT_EQ(util_env_insert(&ret, &ret_len, key1.c_str(), key1.size(), new_val.c_str()), 0); ++ ASSERT_EQ(ret_len, 2); ++ ASSERT_STREQ(ret[0], new_val.c_str()); ++ ++ got = util_env_get_val(ret, ret_len, key2.c_str(), key2.size()); ++ ASSERT_STREQ(got, "test"); ++ free(got); ++ ++ util_free_array_by_len(ret, ret_len); ++} ++ ++TEST(utils_utils, test_util_parse_user_remap) ++{ ++ unsigned int uid, gid, offset; ++ std::string valid_str = "1000:1000:65535"; ++ std::string invalid_str = "1000:1000:65536"; ++ ++ ASSERT_EQ(util_parse_user_remap(valid_str.c_str(), &uid, &gid, &offset), 0); ++ ASSERT_EQ(uid, 1000); ++ ASSERT_EQ(gid, 1000); ++ ASSERT_EQ(offset, 65535); ++ ++ ASSERT_EQ(util_parse_user_remap(nullptr, &uid, &gid, &offset), -1); ++ ASSERT_EQ(util_parse_user_remap(invalid_str.c_str(), &uid, &gid, &offset), -1); ++} ++ ++TEST(utils_utils, test_util_check_pid_max_kernel_namespaced) ++{ ++ int ret = system("cat /proc/kallsyms | grep proc_dointvec_pidmax"); ++ ASSERT_EQ(util_check_pid_max_kernel_namespaced(), ret == 0 ? true : false); ++} ++ ++TEST(utils_utils, test_util_memset_sensitive_string) ++{ ++ char buff[32] = "hello"; ++ ++ util_memset_sensitive_string(buff); ++ ASSERT_EQ(strlen(buff), 0); ++ util_memset_sensitive_string(nullptr); ++} ++ ++void exec_cb(void *args) ++{ ++ char buff[8] = { 0 }; ++ int ret; ++ ++ ret = util_input_readall(buff, 7); ++ ++ if (ret < 0) { ++ exit(-1); ++ } ++ exit(0); ++} ++ ++void exec_echo_cb(void *args) ++{ ++ char buff[8] = { 0 }; ++ int ret; ++ bool *is_echo = (bool *)args; ++ ++ if (*is_echo) { ++ ret = util_input_noecho(buff, 7); ++ } else { ++ ret = util_input_echo(buff, 7); ++ } ++ ++ if (ret < 0) { ++ exit(-1); ++ } ++ exit(0); ++} ++ ++TEST(utils_utils, test_util_input) ++{ ++ std::string test = "hello"; ++ bool is_echo = true; ++ ++ ASSERT_EQ(util_exec_cmd(exec_cb, nullptr, test.c_str(), nullptr, nullptr), true); ++ ++ ASSERT_EQ(util_exec_cmd(exec_echo_cb, &is_echo, test.c_str(), nullptr, nullptr), false); ++ is_echo = false; ++ ASSERT_EQ(util_exec_cmd(exec_echo_cb, &is_echo, test.c_str(), nullptr, nullptr), false); ++} ++ ++TEST(utils_utils, test_util_normalized_host_os_arch) ++{ ++ ASSERT_EQ(util_normalized_host_os_arch(nullptr, nullptr, nullptr), -1); ++} ++ ++TEST(utils_utils, test_util_read_pid_ppid_info) ++{ ++ pid_t pid = getpid(); ++ pid_t ppid = getppid(); ++ pid_ppid_info_t pid_info = { 0 }; ++ ++ ASSERT_EQ(util_read_pid_ppid_info((uint32_t)pid, &pid_info), 0); ++ ASSERT_EQ(pid_info.ppid, (int)ppid); ++ ++ ASSERT_EQ(util_read_pid_ppid_info(0, nullptr), -1); ++} ++ ++TEST(utils_utils, test_util_parse_user_group) ++{ ++ std::string uandg = "user:group"; ++ char *user = nullptr; ++ char *group = nullptr; ++ char *tmp = nullptr; ++ ++ util_parse_user_group(uandg.c_str(), &user, &group, &tmp); ++ ASSERT_STREQ(user, "user"); ++ ASSERT_STREQ(group, "group"); ++ free(tmp); ++} ++ ++TEST(utils_utils, test_dup_map_string_empty_object) ++{ ++ ASSERT_EQ(dup_map_string_empty_object(nullptr), nullptr); ++} ++ ++TEST(utils_utils, test_convert_v2_runtime) ++{ ++ std::string valid_str = "io.containerd.runc.v1"; ++ std::string valid_ret = "containerd-shim-runc-v1"; ++ std::string invalid_str = "xxx.xxx.xxx.xxx"; ++ char buff[32] = { 0 }; ++ ++ ASSERT_EQ(convert_v2_runtime(invalid_str.c_str(), buff), -1); ++ ASSERT_EQ(convert_v2_runtime(nullptr, buff), -1); ++ ASSERT_EQ(convert_v2_runtime(valid_str.c_str(), nullptr), -1); ++ ASSERT_EQ(convert_v2_runtime(valid_str.c_str(), buff), 0); ++} +\ No newline at end of file +-- +2.25.1 + diff --git a/0025-make-sure-kill-pid-not-negative.patch b/0025-make-sure-kill-pid-not-negative.patch new file mode 100644 index 0000000..39015e0 --- /dev/null +++ b/0025-make-sure-kill-pid-not-negative.patch @@ -0,0 +1,63 @@ +From 979b21ba298edc64c88e2534b013076aa92ec975 Mon Sep 17 00:00:00 2001 +From: zhangxiaoyu +Date: Wed, 19 Oct 2022 14:38:49 +0800 +Subject: [PATCH 25/39] make sure kill pid not negative + +Signed-off-by: zhangxiaoyu +--- + src/cmd/isulad-shim/common.c | 2 +- + src/daemon/modules/runtime/isula/isula_rt_ops.c | 4 ++-- + src/utils/cutils/utils.c | 2 +- + 3 files changed, 4 insertions(+), 4 deletions(-) + +diff --git a/src/cmd/isulad-shim/common.c b/src/cmd/isulad-shim/common.c +index 20e0963c..bb8464bb 100644 +--- a/src/cmd/isulad-shim/common.c ++++ b/src/cmd/isulad-shim/common.c +@@ -175,7 +175,7 @@ int cmd_combined_output(const char *binary, const char *params[], void *output, + ret = SHIM_OK; + + out: +- if (ret != SHIM_OK && pid != 0) { ++ if (ret != SHIM_OK) { + kill(pid, 9); + } + +diff --git a/src/daemon/modules/runtime/isula/isula_rt_ops.c b/src/daemon/modules/runtime/isula/isula_rt_ops.c +index 1e4cb5aa..c9667ee5 100644 +--- a/src/daemon/modules/runtime/isula/isula_rt_ops.c ++++ b/src/daemon/modules/runtime/isula/isula_rt_ops.c +@@ -361,7 +361,7 @@ static bool shim_alive(const char *workdir) + + file_read_int(fpid, &pid); + +- if (pid == 0) { ++ if (pid <= 0) { + ERROR("failed read shim-pid file %s", fpid); + return false; + } +@@ -798,7 +798,7 @@ static void shim_kill_force(const char *workdir) + + file_read_int(fpid, &pid); + +- if (pid == 0) { ++ if (pid <= 0) { + goto out; + } + +diff --git a/src/utils/cutils/utils.c b/src/utils/cutils/utils.c +index eddfda5c..9f5deaf9 100644 +--- a/src/utils/cutils/utils.c ++++ b/src/utils/cutils/utils.c +@@ -461,7 +461,7 @@ bool util_process_alive(pid_t pid, unsigned long long start_time) + bool alive = true; + proc_t *pid_info = NULL; + +- if (pid == 0) { ++ if (pid <= 0) { + return false; + } + +-- +2.25.1 + diff --git a/0026-add-UT-for-atomic-and-map.patch b/0026-add-UT-for-atomic-and-map.patch new file mode 100644 index 0000000..a034ee9 --- /dev/null +++ b/0026-add-UT-for-atomic-and-map.patch @@ -0,0 +1,240 @@ +From d9eb77bbe430fa74ca1c55c0c6907afaeb559499 Mon Sep 17 00:00:00 2001 +From: zhangxiaoyu +Date: Tue, 18 Oct 2022 19:19:23 +0800 +Subject: [PATCH 26/39] add UT for atomic and map + +Signed-off-by: zhangxiaoyu +--- + test/cutils/CMakeLists.txt | 2 + + test/cutils/map/CMakeLists.txt | 16 ++++++ + test/cutils/map/map_ut.cc | 39 ++++++++++++++ + test/cutils/util_atomic/CMakeLists.txt | 18 +++++++ + test/cutils/util_atomic/util_atomic_ut.cc | 56 +++++++++++++++++++++ + test/cutils/utils_string/utils_string_ut.cc | 25 +++++++++ + test/mocks/utils_network_mock.cc | 2 +- + 7 files changed, 157 insertions(+), 1 deletion(-) + create mode 100644 test/cutils/map/CMakeLists.txt + create mode 100644 test/cutils/map/map_ut.cc + create mode 100644 test/cutils/util_atomic/CMakeLists.txt + create mode 100644 test/cutils/util_atomic/util_atomic_ut.cc + +diff --git a/test/cutils/CMakeLists.txt b/test/cutils/CMakeLists.txt +index 23426015..28e37b27 100644 +--- a/test/cutils/CMakeLists.txt ++++ b/test/cutils/CMakeLists.txt +@@ -17,6 +17,8 @@ target_include_directories(libutils_ut + + add_subdirectory(mainloop) + add_subdirectory(path) ++add_subdirectory(map) ++add_subdirectory(util_atomic) + add_subdirectory(utils_string) + add_subdirectory(utils_convert) + add_subdirectory(utils_array) +diff --git a/test/cutils/map/CMakeLists.txt b/test/cutils/map/CMakeLists.txt +new file mode 100644 +index 00000000..4059559f +--- /dev/null ++++ b/test/cutils/map/CMakeLists.txt +@@ -0,0 +1,16 @@ ++project(iSulad_UT) ++ ++SET(EXE map_ut) ++ ++add_executable(${EXE} ++ map_ut.cc) ++ ++target_include_directories(${EXE} PUBLIC ++ ${GTEST_INCLUDE_DIR} ++ ${CMAKE_CURRENT_SOURCE_DIR}/../../include ++ ${CMAKE_CURRENT_SOURCE_DIR}/../../../src/common ++ ${CMAKE_CURRENT_SOURCE_DIR}/../../../src/utils/cutils/map ++ ) ++ ++target_link_libraries(${EXE} ${GTEST_BOTH_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT} libutils_ut -lcrypto -lyajl -lz) ++add_test(NAME ${EXE} COMMAND ${EXE} --gtest_output=xml:${EXE}-Results.xml) +diff --git a/test/cutils/map/map_ut.cc b/test/cutils/map/map_ut.cc +new file mode 100644 +index 00000000..fd75da28 +--- /dev/null ++++ b/test/cutils/map/map_ut.cc +@@ -0,0 +1,39 @@ ++/* ++ * Copyright (c) Huawei Technologies Co., Ltd. 2022. All rights reserved. ++ * iSulad licensed under the Mulan PSL v2. ++ * You can use this software according to the terms and conditions of the Mulan PSL v2. ++ * You may obtain a copy of Mulan PSL v2 at: ++ * http://license.coscl.org.cn/MulanPSL2 ++ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR ++ * IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR ++ * PURPOSE. ++ * See the Mulan PSL v2 for more details. ++ * Description: map unit test ++ * Author: zhangxiaoyu ++ * Create: 2022-10-19 ++ */ ++ ++#include ++#include ++#include ++#include "map.h" ++ ++TEST(map_map_ut, test_map) ++{ ++ // map[string][bool] ++ map_t *map_test = nullptr; ++ bool exist = true; ++ ++ map_test = map_new(MAP_STR_BOOL, MAP_DEFAULT_CMP_FUNC, MAP_DEFAULT_FREE_FUNC); ++ ASSERT_NE(map_test, nullptr); ++ ASSERT_EQ(map_insert(map_test, (void *)"key", &exist), true); ++ ++ map_itor *itor = map_itor_new(map_test); ++ ASSERT_NE(itor, nullptr); ++ ASSERT_EQ(map_itor_first(itor), true); ++ ASSERT_EQ(map_itor_last(itor), true); ++ ASSERT_EQ(map_itor_prev(itor), false); ++ ++ map_itor_free(itor); ++ map_clear(map_test); ++} +diff --git a/test/cutils/util_atomic/CMakeLists.txt b/test/cutils/util_atomic/CMakeLists.txt +new file mode 100644 +index 00000000..071b2a04 +--- /dev/null ++++ b/test/cutils/util_atomic/CMakeLists.txt +@@ -0,0 +1,18 @@ ++project(iSulad_UT) ++ ++SET(EXE util_atomic_ut) ++ ++add_executable(${EXE} ++ util_atomic_ut.cc) ++ ++target_include_directories(${EXE} PUBLIC ++ ${GTEST_INCLUDE_DIR} ++ ${CMAKE_CURRENT_SOURCE_DIR}/../../include ++ ${CMAKE_CURRENT_SOURCE_DIR}/../../../src/common ++ ${CMAKE_CURRENT_SOURCE_DIR}/../../../src/utils/cutils/map ++ ${CMAKE_CURRENT_SOURCE_DIR}/../../../src/utils/sha256 ++ ${CMAKE_CURRENT_SOURCE_DIR}/../../../src/utils/cutils ++ ) ++ ++target_link_libraries(${EXE} ${GTEST_BOTH_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT} ${ISULA_LIBUTILS_LIBRARY} libutils_ut -lcrypto -lyajl -lz) ++add_test(NAME ${EXE} COMMAND ${EXE} --gtest_output=xml:${EXE}-Results.xml) +diff --git a/test/cutils/util_atomic/util_atomic_ut.cc b/test/cutils/util_atomic/util_atomic_ut.cc +new file mode 100644 +index 00000000..29772a1e +--- /dev/null ++++ b/test/cutils/util_atomic/util_atomic_ut.cc +@@ -0,0 +1,56 @@ ++/* ++ * Copyright (c) Huawei Technologies Co., Ltd. 2022. All rights reserved. ++ * iSulad licensed under the Mulan PSL v2. ++ * You can use this software according to the terms and conditions of the Mulan PSL v2. ++ * You may obtain a copy of Mulan PSL v2 at: ++ * http://license.coscl.org.cn/MulanPSL2 ++ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR ++ * IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR ++ * PURPOSE. ++ * See the Mulan PSL v2 for more details. ++ * Description: util_atomic unit test ++ * Author: zhangxiaoyu ++ * Create: 2022-10-15 ++ */ ++ ++#include ++#include ++#include ++#include "mock.h" ++#include "util_atomic.h" ++ ++TEST(utils_atomic_ut, test_atomic_inc_dec) ++{ ++ uint64_t atomic = 0; ++ uint64_t atomic_image = 0; ++ ++ atomic_int_set(&atomic, 10); ++ ASSERT_EQ(atomic_int_get(&atomic), 10); ++ ASSERT_EQ(atomic_int_inc(&atomic), 11); ++ ASSERT_EQ(atomic_int_dec_test(&atomic), false); ++ ++ atomic_int_set_image(&atomic_image, 1); ++ ASSERT_EQ(atomic_int_inc_image(&atomic_image), 2); ++ ASSERT_EQ(atomic_int_dec_test_image(&atomic_image), false); ++ ASSERT_EQ(atomic_int_dec_test_image(&atomic_image), true); ++} ++ ++TEST(utils_atomic_ut, test_atomic_calculate) ++{ ++ uint64_t atomic = 0; ++ ++ ASSERT_EQ(atomic_int_compare_exchange(&atomic, 1, 2), false); ++ ++ ++ ASSERT_EQ(atomic_int_compare_exchange(&atomic, 0, 2), true); ++ // atomic = 2 ++ ASSERT_EQ(atomic_int_add(&atomic, 3), 2); ++ // atomic = 5 ++ ASSERT_EQ(atomic_int_and(&atomic, 4), 5); ++ // atomic = 4 ++ ASSERT_EQ(atomic_int_or(&atomic, 8), 4); ++ // atomic = 12 ++ ASSERT_EQ(atomic_int_xor(&atomic, 3), 12); ++ // atomic = 15 ++ ASSERT_EQ(atomic_int_get(&atomic), 15); ++} +diff --git a/test/cutils/utils_string/utils_string_ut.cc b/test/cutils/utils_string/utils_string_ut.cc +index b488a09f..8b6c61a6 100644 +--- a/test/cutils/utils_string/utils_string_ut.cc ++++ b/test/cutils/utils_string/utils_string_ut.cc +@@ -18,6 +18,7 @@ + #include + #include "mock.h" + #include "utils_string.h" ++#include "utils_array.h" + + extern "C" { + DECLARE_WRAPPER(util_strdup_s, char *, (const char *str)); +@@ -831,3 +832,27 @@ TEST(utils_string_ut, test_str_token) + ASSERT_STREQ(token, "abc"); + free(token); + } ++ ++TEST(utils_string_ut, test_string_split_multi) ++{ ++ char **result = nullptr; ++ ++ ASSERT_EQ(util_string_split_multi(nullptr, ':'), nullptr); ++ ++ result = util_string_split_multi("", ':'); ++ ASSERT_STREQ(result[0], ""); ++ ASSERT_EQ(result[1], nullptr); ++ util_free_array(result); ++ ++ result = util_string_split_multi("abcd;", ':'); ++ ASSERT_STREQ(result[0], "abcd;"); ++ ASSERT_EQ(result[1], nullptr); ++ util_free_array(result); ++ ++ result = util_string_split_multi("abc:dd:e", ':'); ++ ASSERT_STREQ(result[0], "abc"); ++ ASSERT_STREQ(result[1], "dd"); ++ ASSERT_STREQ(result[2], "e"); ++ ASSERT_EQ(result[3], nullptr); ++ util_free_array(result); ++} +diff --git a/test/mocks/utils_network_mock.cc b/test/mocks/utils_network_mock.cc +index afa346b5..01027a62 100644 +--- a/test/mocks/utils_network_mock.cc ++++ b/test/mocks/utils_network_mock.cc +@@ -57,4 +57,4 @@ int pthread_join(pthread_t thread, void **retval) + return g_utils_network_mock->PthreadJoin(thread, retval); + } + return 0; +-} +\ No newline at end of file ++} +-- +2.25.1 + diff --git a/0027-remove-unnecessary-goto-and-add-parameter-check-for-.patch b/0027-remove-unnecessary-goto-and-add-parameter-check-for-.patch new file mode 100644 index 0000000..886cb2a --- /dev/null +++ b/0027-remove-unnecessary-goto-and-add-parameter-check-for-.patch @@ -0,0 +1,125 @@ +From d9f2f58a5c8952fe0f03c8f6fbbed7f741a41e68 Mon Sep 17 00:00:00 2001 +From: zhongtao +Date: Wed, 19 Oct 2022 15:12:27 +0800 +Subject: [PATCH 27/39] remove unnecessary goto and add parameter check for + verify + +Signed-off-by: zhongtao +--- + src/utils/cutils/utils_verify.c | 41 ++++++++++++++++++++------------- + 1 file changed, 25 insertions(+), 16 deletions(-) + +diff --git a/src/utils/cutils/utils_verify.c b/src/utils/cutils/utils_verify.c +index 40b153f0..9ed33bf3 100644 +--- a/src/utils/cutils/utils_verify.c ++++ b/src/utils/cutils/utils_verify.c +@@ -143,24 +143,21 @@ bool util_validate_unix_socket(const char *socket) + } + + if (strncmp("unix://", socket, strlen("unix://"))) { +- nret = -1; +- goto err_out; ++ return false; + } + + name = socket + strlen("unix://"); + + if (name[0] == '\0') { +- nret = -1; +- goto err_out; ++ return false; + } + + nret = util_validate_absolute_path(name); + if (nret != 0) { +- nret = -1; +- goto err_out; ++ return false; + } +-err_out: +- return nret == 0; ++ ++ return true; + } + + bool util_validate_socket(const char *socket) +@@ -219,7 +216,6 @@ size_t util_get_all_caps_len() + + bool util_valid_cap(const char *cap) + { +- bool cret = true; + int nret = 0; + char tmpcap[32] = { 0 }; + size_t all_caps_len = util_get_all_caps_len(); +@@ -231,16 +227,13 @@ bool util_valid_cap(const char *cap) + nret = snprintf(tmpcap, sizeof(tmpcap), "CAP_%s", cap); + if (nret < 0 || nret >= sizeof(tmpcap)) { + ERROR("Failed to print string"); +- cret = false; +- goto err_out; ++ return false; + } + if (!util_strings_in_slice(g_all_caps, all_caps_len, tmpcap)) { +- cret = false; +- goto err_out; ++ return false; + } + +-err_out: +- return cret; ++ return true; + } + + bool util_valid_container_id(const char *id) +@@ -570,16 +563,27 @@ bool util_valid_value_false(const char *value) + + bool util_valid_rw_mode(const char *mode) + { ++ if (mode == NULL){ ++ return false; ++ } ++ + return !strcmp(mode, "rw") || !strcmp(mode, "ro"); + } + + bool util_valid_label_mode(const char *mode) + { ++ if (mode == NULL){ ++ return false; ++ } ++ + return !strcmp(mode, "z") || !strcmp(mode, "Z"); + } + + bool util_valid_copy_mode(const char *mode) + { ++ if (mode == NULL){ ++ return false; ++ } + return !strcmp(mode, "nocopy"); + } + +@@ -681,7 +685,7 @@ bool util_valid_positive_interger(const char *value) + { + const char *patten = "^[0-9]*$"; + +- if (value == NULL) { ++ if (value == NULL || strcmp(value, "") == 0) { + return false; + } + +@@ -704,6 +708,11 @@ int util_valid_env(const char *env, char **dst) + int ret = 0; + char *value = NULL; + ++ if (dst == NULL){ ++ ERROR("NULL dst"); ++ return -1; ++ } ++ + char **arr = util_string_split_multi(env, '='); + if (arr == NULL) { + ERROR("Failed to split env string"); +-- +2.25.1 + diff --git a/0028-Add-ut-for-verify.patch b/0028-Add-ut-for-verify.patch new file mode 100644 index 0000000..c9eadb7 --- /dev/null +++ b/0028-Add-ut-for-verify.patch @@ -0,0 +1,487 @@ +From c31c29a9ea4f4818036ee52cb85f82b5a02e43f9 Mon Sep 17 00:00:00 2001 +From: zhongtao +Date: Wed, 19 Oct 2022 15:09:34 +0800 +Subject: [PATCH 28/39] Add ut for verify + +Signed-off-by: zhongtao +--- + test/cutils/CMakeLists.txt | 1 + + test/cutils/utils_verify/CMakeLists.txt | 16 + + test/cutils/utils_verify/utils_verify_ut.cc | 432 ++++++++++++++++++++ + 3 files changed, 449 insertions(+) + create mode 100644 test/cutils/utils_verify/CMakeLists.txt + create mode 100644 test/cutils/utils_verify/utils_verify_ut.cc + +diff --git a/test/cutils/CMakeLists.txt b/test/cutils/CMakeLists.txt +index 28e37b27..2447b781 100644 +--- a/test/cutils/CMakeLists.txt ++++ b/test/cutils/CMakeLists.txt +@@ -34,3 +34,4 @@ add_subdirectory(utils_timestamp) + add_subdirectory(utils_mount_spec) + add_subdirectory(utils_regex) + add_subdirectory(utils_utils) ++add_subdirectory(utils_verify) +diff --git a/test/cutils/utils_verify/CMakeLists.txt b/test/cutils/utils_verify/CMakeLists.txt +new file mode 100644 +index 00000000..abf9596f +--- /dev/null ++++ b/test/cutils/utils_verify/CMakeLists.txt +@@ -0,0 +1,16 @@ ++project(iSulad_UT) ++ ++SET(EXE utils_verify_ut) ++ ++add_executable(${EXE} ++ utils_verify_ut.cc) ++ ++target_include_directories(${EXE} PUBLIC ++ ${GTEST_INCLUDE_DIR} ++ ${CMAKE_CURRENT_SOURCE_DIR}/../../include ++ ${CMAKE_CURRENT_SOURCE_DIR}/../../../src/common ++ ${CMAKE_CURRENT_SOURCE_DIR}/../../../src/utils/cutils/map ++ ${CMAKE_CURRENT_SOURCE_DIR}/../../../src/utils/cutils ++ ) ++target_link_libraries(${EXE} ${GTEST_BOTH_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT} ${ISULA_LIBUTILS_LIBRARY} libutils_ut -lcrypto -lyajl -lz) ++add_test(NAME ${EXE} COMMAND ${EXE} --gtest_output=xml:${EXE}-Results.xml) +diff --git a/test/cutils/utils_verify/utils_verify_ut.cc b/test/cutils/utils_verify/utils_verify_ut.cc +new file mode 100644 +index 00000000..d1a9b6bf +--- /dev/null ++++ b/test/cutils/utils_verify/utils_verify_ut.cc +@@ -0,0 +1,432 @@ ++/****************************************************************************** ++ * Copyright (c) Huawei Technologies Co., Ltd. 2022. All rights reserved. ++ * iSulad licensed under the Mulan PSL v2. ++ * You can use this software according to the terms and conditions of the Mulan PSL v2. ++ * You may obtain a copy of Mulan PSL v2 at: ++ * http://license.coscl.org.cn/MulanPSL2 ++ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR ++ * IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR ++ * PURPOSE. ++ * See the Mulan PSL v2 for more details. ++ * Author: zhongtao ++ * Create: 2022-10-19 ++ * Description: utils verify unit test ++ *******************************************************************************/ ++ ++#include ++#include "utils_verify.h" ++#include "utils_file.h" ++ ++TEST(utils_verify, test_util_valid_cmd_arg) ++{ ++ ASSERT_EQ(util_valid_cmd_arg("isula ps"), true); ++ ++ ASSERT_EQ(util_valid_cmd_arg(nullptr), false); ++ ASSERT_EQ(util_valid_cmd_arg("isula ps | grep"), false); ++ ASSERT_EQ(util_valid_cmd_arg("isula`"), false); ++ ASSERT_EQ(util_valid_cmd_arg("isula ps & grep`"), false); ++ ASSERT_EQ(util_valid_cmd_arg("isula ps ; grep`"), false); ++} ++ ++TEST(utils_verify, test_util_valid_signal) ++{ ++ ASSERT_EQ(util_valid_signal(2), true); ++ ++ ASSERT_EQ(util_valid_signal(0), false); ++ ASSERT_EQ(util_valid_signal(-1), false); ++ ++ ASSERT_EQ(util_valid_signal(64), true); ++ ASSERT_EQ(util_valid_signal(65), false); ++} ++ ++TEST(utils_verify, test_util_validate_absolute_path) ++{ ++ ASSERT_EQ(util_validate_absolute_path("/etc/isulad"), 0); ++ ASSERT_EQ(util_validate_absolute_path("/isulad/"), 0); ++ ++ ASSERT_EQ(util_validate_absolute_path(nullptr), -1); ++ ASSERT_EQ(util_validate_absolute_path("./isulad"), -1); ++ ASSERT_EQ(util_validate_absolute_path("isulad"), -1); ++} ++ ++TEST(utils_verify, test_util_validate_unix_socket) ++{ ++ ASSERT_EQ(util_validate_unix_socket("unix:///etc/isulad"), true); ++ ASSERT_EQ(util_validate_unix_socket("unix:///isulad/"), true); ++ ++ ASSERT_EQ(util_validate_unix_socket(nullptr), false); ++ ASSERT_EQ(util_validate_unix_socket("unix://"), false); ++ ASSERT_EQ(util_validate_unix_socket("unix://./isulad"), false); ++ ASSERT_EQ(util_validate_unix_socket("unix://isulad"), false); ++} ++ ++TEST(utils_verify, test_util_validate_socket) ++{ ++ ASSERT_EQ(util_validate_socket("unix:///etc/isulad"), true); ++ ASSERT_EQ(util_validate_socket("unix:///isulad/"), true); ++ ++ ASSERT_EQ(util_validate_socket(nullptr), false); ++ ASSERT_EQ(util_validate_socket("unix://"), false); ++ ASSERT_EQ(util_validate_socket("unix://./isulad"), false); ++ ASSERT_EQ(util_validate_socket("unix://isulad"), false); ++ ++ ASSERT_EQ(util_validate_socket("tcp://localhost:2375"), true); ++ ASSERT_EQ(util_validate_socket("tcp://127.0.0.1:2375"), true); ++ ++ ASSERT_EQ(util_validate_socket("tcp://"), false); ++ ASSERT_EQ(util_validate_socket("tcp://127.0.0.1"), false); ++ ASSERT_EQ(util_validate_socket("tcp://127.0.0.1,2375"), false); ++} ++ ++TEST(utils_verify, test_util_valid_device_mode) ++{ ++ ASSERT_EQ(util_valid_device_mode("rwm"), true); ++ ++ ASSERT_EQ(util_valid_device_mode(nullptr), false); ++ ASSERT_EQ(util_valid_device_mode(""), false); ++ ASSERT_EQ(util_valid_device_mode("rrwm"), false); ++ ASSERT_EQ(util_valid_device_mode("rwwm"), false); ++ ASSERT_EQ(util_valid_device_mode("rwmm"), false); ++ ASSERT_EQ(util_valid_device_mode("awm"), false); ++} ++ ++TEST(utils_verify, test_util_valid_str) ++{ ++ ASSERT_EQ(util_valid_str("str"), true); ++ ++ ASSERT_EQ(util_valid_str(""), false); ++ ASSERT_EQ(util_valid_str(nullptr), false); ++} ++ ++TEST(utils_verify, test_util_get_all_caps_len) ++{ ++ ASSERT_EQ(util_get_all_caps_len(), 38); ++} ++ ++TEST(utils_verify, test_util_valid_cap) ++{ ++ ASSERT_EQ(util_valid_cap("DAC_READ_SEARCH"), true); ++ ++ ASSERT_EQ(util_valid_cap(nullptr), false); ++ ASSERT_EQ(util_valid_cap(""), false); ++ ASSERT_EQ(util_valid_cap("DA_READ_SEARCH"), false); ++} ++ ++TEST(utils_verify, test_util_valid_time_tz) ++{ ++ ASSERT_EQ(util_valid_time_tz("2022-10-04T18:22:45.289257759Z"), true); ++ ++ ASSERT_EQ(util_valid_time_tz(nullptr), false); ++ ASSERT_EQ(util_valid_time_tz("2016-01-02T15:04:01:03"), false); ++} ++ ++TEST(utils_verify, test_util_valid_embedded_image_name) ++{ ++ ASSERT_EQ(util_valid_embedded_image_name("busybox:latest"), true); ++ ++ ASSERT_EQ(util_valid_embedded_image_name(nullptr), false); ++ ASSERT_EQ(util_valid_embedded_image_name("busybox:/latest"), false); ++ ASSERT_EQ(util_valid_embedded_image_name("busybox"), false); ++ ASSERT_EQ(util_valid_embedded_image_name("busybox:#latest"), false); ++} ++ ++TEST(utils_verify, test_util_valid_image_name) ++{ ++ ASSERT_EQ(util_valid_image_name("busybox:latest"), true); ++ ASSERT_EQ(util_valid_image_name("busybox"), true); ++ ++ ASSERT_EQ(util_valid_image_name(nullptr), false); ++ ASSERT_EQ(util_valid_image_name("busybox:/latest"), false); ++ ASSERT_EQ(util_valid_image_name("busybox:#latest"), false); ++} ++ ++TEST(utils_verify, test_util_tag_pos) ++{ ++ ASSERT_STREQ(util_tag_pos("busybox:latest"), ":latest"); ++ ++ ASSERT_EQ(util_tag_pos("busybox:/latest"), nullptr); ++ ASSERT_EQ(util_tag_pos("busybox"), nullptr); ++} ++ ++TEST(utils_verify, test_util_valid_file) ++{ ++ std::string isulad_dir = "/tmp/test"; ++ ASSERT_EQ(util_mkdir_p(isulad_dir.c_str(), 0700), 0); ++ ++ ASSERT_EQ(util_valid_file(isulad_dir.c_str(), S_IFDIR), true); ++ ASSERT_EQ(util_valid_file(isulad_dir.c_str(), S_IFBLK), false); ++ ASSERT_EQ(util_valid_file(isulad_dir.c_str(), 0), false); ++ ++ ASSERT_EQ(util_path_remove(isulad_dir.c_str()), 0); ++ ++ ASSERT_EQ(util_valid_file(nullptr, S_IFDIR),false); ++} ++ ++TEST(utils_verify, test_util_valid_digest) ++{ ++ ASSERT_EQ(util_valid_digest("sha256:7bd0c945d7e4cc2ce5c21d449ba07eb89c8e6c28085edbcf6f5fa4bf90e7eedc"), true); ++ ++ ASSERT_EQ(util_valid_digest(nullptr), false); ++ ASSERT_EQ(util_valid_digest("ha256:7bd0c945d7e4cc2ce5c21d449ba07eb89c8e6c28085edbcf6f5fa4bf90e7eedc"), false); ++} ++ ++TEST(utils_verify, test_util_valid_tag) ++{ ++ ASSERT_EQ(util_valid_tag("busybox:latest"), true); ++ ++ ASSERT_EQ(util_valid_tag(nullptr), false); ++ ASSERT_EQ(util_valid_tag("sha256:latest"), false); ++} ++ ++TEST(utils_verify, test_util_valid_key_type) ++{ ++ ASSERT_EQ(util_valid_key_type("type"), true); ++ ++ ASSERT_EQ(util_valid_key_type(nullptr), false); ++ ASSERT_EQ(util_valid_key_type("type:123"), false); ++} ++ ++TEST(utils_verify, test_util_valid_key_src) ++{ ++ ASSERT_EQ(util_valid_key_src("src"), true); ++ ASSERT_EQ(util_valid_key_src("source"), true); ++ ++ ASSERT_EQ(util_valid_key_src(nullptr), false); ++ ASSERT_EQ(util_valid_key_src("source:123"), false); ++} ++ ++TEST(utils_verify, test_util_valid_key_dst) ++{ ++ ASSERT_EQ(util_valid_key_dst("dst"), true); ++ ASSERT_EQ(util_valid_key_dst("destination"), true); ++ ASSERT_EQ(util_valid_key_dst("target"), true); ++ ++ ASSERT_EQ(util_valid_key_dst(nullptr), false); ++ ASSERT_EQ(util_valid_key_dst("target:123"), false); ++} ++ ++TEST(utils_verify, test_util_valid_key_ro) ++{ ++ ASSERT_EQ(util_valid_key_ro("ro"), true); ++ ASSERT_EQ(util_valid_key_ro("readonly"), true); ++ ++ ASSERT_EQ(util_valid_key_ro(nullptr), false); ++ ASSERT_EQ(util_valid_key_ro("readonly:123"), false); ++} ++ ++TEST(utils_verify, test_util_valid_key_propagation) ++{ ++ ASSERT_EQ(util_valid_key_propagation("bind-propagation"), true); ++ ++ ASSERT_EQ(util_valid_key_propagation(nullptr), false); ++ ASSERT_EQ(util_valid_key_propagation("bind-propagation:123"), false); ++} ++ ++TEST(utils_verify, test_util_valid_key_selinux) ++{ ++ ASSERT_EQ(util_valid_key_selinux("bind-selinux-opts"), true); ++ ASSERT_EQ(util_valid_key_selinux("selinux-opts"), true); ++ ++ ASSERT_EQ(util_valid_key_selinux(nullptr), false); ++ ASSERT_EQ(util_valid_key_selinux("bind-selinux-opts:123"), false); ++} ++ ++TEST(utils_verify, test_util_valid_key_tmpfs_size) ++{ ++ ASSERT_EQ(util_valid_key_tmpfs_size("tmpfs-size"), true); ++ ++ ASSERT_EQ(util_valid_key_tmpfs_size(nullptr), false); ++ ASSERT_EQ(util_valid_key_tmpfs_size("tmpfs-size:123"), false); ++} ++ ++TEST(utils_verify, test_util_valid_key_tmpfs_mode) ++{ ++ ASSERT_EQ(util_valid_key_tmpfs_mode("tmpfs-mode"), true); ++ ++ ASSERT_EQ(util_valid_key_tmpfs_mode(nullptr), false); ++ ASSERT_EQ(util_valid_key_tmpfs_mode("tmpfs-mode:123"), false); ++} ++ ++TEST(utils_verify, test_util_valid_key_nocopy) ++{ ++ ASSERT_EQ(util_valid_key_nocopy("volume-nocopy"), true); ++ ++ ASSERT_EQ(util_valid_key_nocopy(nullptr), false); ++ ASSERT_EQ(util_valid_key_nocopy("volume-nocopy:123"), false); ++} ++ ++TEST(utils_verify, test_util_valid_value_true) ++{ ++ ASSERT_EQ(util_valid_value_true("1"), true); ++ ASSERT_EQ(util_valid_value_true("true"), true); ++ ++ ASSERT_EQ(util_valid_value_true(nullptr), false); ++ ASSERT_EQ(util_valid_value_true("0"), false); ++ ASSERT_EQ(util_valid_value_true("false"), false); ++} ++ ++TEST(utils_verify, test_util_valid_value_false) ++{ ++ ASSERT_EQ(util_valid_value_false("0"), true); ++ ASSERT_EQ(util_valid_value_false("false"), true); ++ ++ ASSERT_EQ(util_valid_value_false(nullptr), false); ++ ASSERT_EQ(util_valid_value_false("1"), false); ++ ASSERT_EQ(util_valid_value_false("true"), false); ++} ++ ++TEST(utils_verify, test_util_valid_rw_mode) ++{ ++ ASSERT_EQ(util_valid_rw_mode("ro"), true); ++ ASSERT_EQ(util_valid_rw_mode("rw"), true); ++ ++ ASSERT_EQ(util_valid_rw_mode(nullptr), false); ++ ASSERT_EQ(util_valid_rw_mode("rwro"), false); ++} ++ ++TEST(utils_verify, test_util_valid_label_mode) ++{ ++ ASSERT_EQ(util_valid_label_mode("z"), true); ++ ASSERT_EQ(util_valid_label_mode("Z"), true); ++ ++ ASSERT_EQ(util_valid_label_mode(nullptr), false); ++ ASSERT_EQ(util_valid_label_mode("zZ"), false); ++} ++ ++TEST(utils_verify, test_util_valid_copy_mode) ++{ ++ ASSERT_EQ(util_valid_copy_mode("nocopy"), true); ++ ++ ASSERT_EQ(util_valid_copy_mode(nullptr), false); ++ ASSERT_EQ(util_valid_copy_mode("nocopy:123"), false); ++} ++ ++TEST(utils_verify, test_util_valid_propagation_mode) ++{ ++ ASSERT_EQ(util_valid_propagation_mode("private"), true); ++ ASSERT_EQ(util_valid_propagation_mode("rprivate"), true); ++ ASSERT_EQ(util_valid_propagation_mode("slave"), true); ++ ASSERT_EQ(util_valid_propagation_mode("rslave"), true); ++ ASSERT_EQ(util_valid_propagation_mode("shared"), true); ++ ASSERT_EQ(util_valid_propagation_mode("rshared"), true); ++ ++ ASSERT_EQ(util_valid_propagation_mode(nullptr), false); ++ ASSERT_EQ(util_valid_propagation_mode("rrslave"), false); ++} ++ ++TEST(utils_verify, test_util_valid_mount_mode) ++{ ++ ASSERT_EQ(util_valid_mount_mode("ro,private,z,nocopy"), true); ++ ++ ASSERT_EQ(util_valid_mount_mode(nullptr), false); ++ ASSERT_EQ(util_valid_mount_mode("ro,rw,private,z,nocopy"), false); ++ ASSERT_EQ(util_valid_mount_mode("ri,private,z,nocopy"), false); ++} ++ ++TEST(utils_verify, test_util_valid_container_id) ++{ ++ ASSERT_EQ(util_valid_container_id("451f587884b04ef2a81a6d410f65083c906a865044ef5bef8af833aaab8c63aa"), true); ++ ++ ASSERT_EQ(util_valid_container_id(nullptr), false); ++ ASSERT_EQ(util_valid_container_id("g51f587884b04ef2a81a6d410f65083c906a865044ef5bef8af833aaab8c63aa"), false); ++ ASSERT_EQ(util_valid_container_id(""), false); ++} ++ ++TEST(utils_verify, test_util_valid_container_name) ++{ ++ ASSERT_EQ(util_valid_container_name("test"), true); ++ ++ ASSERT_EQ(util_valid_container_name(nullptr), false); ++ ASSERT_EQ(util_valid_container_name(".test"), false); ++} ++ ++TEST(utils_verify, test_util_valid_container_id_or_name) ++{ ++ ASSERT_EQ(util_valid_container_id_or_name("test"), true); ++ ASSERT_EQ(util_valid_container_id_or_name("451f587884b04ef2a81a6d410f65083c906a865044ef5bef8af833aaab8c63aa"), true); ++ ++ ASSERT_EQ(util_valid_container_id_or_name(nullptr), false); ++ ASSERT_EQ(util_valid_container_id_or_name(".test"), false); ++ ASSERT_EQ(util_valid_container_id_or_name(""), false); ++} ++ ++TEST(utils_verify, test_util_valid_host_name) ++{ ++ ASSERT_EQ(util_valid_host_name("LAPTOP-6O44CJ3O"), true); ++ ++ ASSERT_EQ(util_valid_host_name(nullptr), false); ++ ASSERT_EQ(util_valid_host_name(".LAPTOP-6O44CJ3O"), false); ++} ++ ++TEST(utils_verify, test_util_valid_runtime_name) ++{ ++ ASSERT_EQ(util_valid_runtime_name("runc"), true); ++ ++ ASSERT_EQ(util_valid_runtime_name(nullptr), false); ++} ++ ++TEST(utils_verify, test_util_valid_short_sha256_id) ++{ ++ ASSERT_EQ(util_valid_short_sha256_id("ff4a8eb070e12018233797e865841d877a7835c4c6d5cfc52e5481995da6b2f7"), true); ++ ASSERT_EQ(util_valid_short_sha256_id("ff4"), true); ++ ++ ASSERT_EQ(util_valid_short_sha256_id(nullptr), false); ++ ASSERT_EQ(util_valid_short_sha256_id("ff"), false); ++} ++ ++TEST(utils_verify, test_util_valid_exec_suffix) ++{ ++ ASSERT_EQ(util_valid_exec_suffix("ff4a8eb070e12018233797e865841d877a7835c4c6d5cfc52e5481995da6b2f7"), true); ++ ++ ASSERT_EQ(util_valid_exec_suffix(nullptr), false); ++ ASSERT_EQ(util_valid_exec_suffix("gf4a8eb070e12018233797e865841d877a7835c4c6d5cfc52e5481995da6b2f7"), false); ++} ++ ++TEST(utils_verify, test_util_valid_positive_interger) ++{ ++ ASSERT_EQ(util_valid_positive_interger("123456789"), true); ++ ASSERT_EQ(util_valid_positive_interger("0"), true); ++ ++ ASSERT_EQ(util_valid_positive_interger(nullptr), false); ++ ASSERT_EQ(util_valid_positive_interger("-123456789"), false); ++ ASSERT_EQ(util_valid_positive_interger(""), false); ++} ++ ++TEST(utils_verify, test_util_valid_device_cgroup_rule) ++{ ++ ASSERT_EQ(util_valid_device_cgroup_rule("b 8:* rmw"), true); ++ ++ ASSERT_EQ(util_valid_device_cgroup_rule(nullptr), false); ++ ASSERT_EQ(util_valid_device_cgroup_rule("d 8:* rmw"), false); ++} ++ ++TEST(utils_verify, test_util_valid_env) ++{ ++ char *env = (char *)"USER=root"; ++ char *dst = nullptr; ++ ++ ASSERT_EQ(util_valid_env(env, &dst), 0); ++ ASSERT_STREQ(dst, "USER=root"); ++ ++ ASSERT_EQ(util_valid_env(nullptr, &dst), -1); ++ ASSERT_EQ(util_valid_env(env, nullptr), -1); ++} ++ ++TEST(utils_verify, test_util_valid_sysctl) ++{ ++ ASSERT_EQ(util_valid_sysctl("kernel.msgmax"), true); ++ ASSERT_EQ(util_valid_sysctl("net.abc"), true); ++ ++ ASSERT_EQ(util_valid_sysctl(nullptr), false); ++ ASSERT_EQ(util_valid_sysctl("kernel.shmal"), false); ++} ++ ++TEST(utils_verify, test_util_valid_volume_name) ++{ ++ ASSERT_EQ(util_valid_volume_name("f6391b735a917ffbaff138970dc45290508574e6ab92e06a1e9dd290f31592ca"), true); ++ ASSERT_EQ(util_valid_volume_name("aa"), true); ++ ++ ASSERT_EQ(util_valid_volume_name(nullptr), false); ++ ASSERT_EQ(util_valid_volume_name(""), false); ++ ASSERT_EQ(util_valid_volume_name("a"), false); ++} +\ No newline at end of file +-- +2.25.1 + diff --git a/0029-fix-error-in-utils_verify_ut.patch b/0029-fix-error-in-utils_verify_ut.patch new file mode 100644 index 0000000..4ce1be7 --- /dev/null +++ b/0029-fix-error-in-utils_verify_ut.patch @@ -0,0 +1,26 @@ +From f342d18d5eb26baabad2749002bac71b412ed8b6 Mon Sep 17 00:00:00 2001 +From: zhongtao +Date: Thu, 20 Oct 2022 19:03:57 +0800 +Subject: [PATCH 29/39] fix error in utils_verify_ut + +Signed-off-by: zhongtao +--- + test/cutils/utils_verify/utils_verify_ut.cc | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/test/cutils/utils_verify/utils_verify_ut.cc b/test/cutils/utils_verify/utils_verify_ut.cc +index d1a9b6bf..9c4bf944 100644 +--- a/test/cutils/utils_verify/utils_verify_ut.cc ++++ b/test/cutils/utils_verify/utils_verify_ut.cc +@@ -100,7 +100,7 @@ TEST(utils_verify, test_util_valid_str) + + TEST(utils_verify, test_util_get_all_caps_len) + { +- ASSERT_EQ(util_get_all_caps_len(), 38); ++ ASSERT_NE(util_get_all_caps_len(), 0); + } + + TEST(utils_verify, test_util_valid_cap) +-- +2.25.1 + diff --git a/0030-add-more-test-for-string-and-map.patch b/0030-add-more-test-for-string-and-map.patch new file mode 100644 index 0000000..5469f99 --- /dev/null +++ b/0030-add-more-test-for-string-and-map.patch @@ -0,0 +1,122 @@ +From 5e4fc62e36631d8d2e444ac3d60ce99ec7396ca0 Mon Sep 17 00:00:00 2001 +From: zhangxiaoyu +Date: Fri, 21 Oct 2022 09:58:40 +0800 +Subject: [PATCH 30/39] add more test for string and map + +Signed-off-by: zhangxiaoyu +--- + test/cutils/map/map_ut.cc | 50 ++++++++++++++++++++- + test/cutils/utils_string/utils_string_ut.cc | 17 ++++--- + 2 files changed, 61 insertions(+), 6 deletions(-) + +diff --git a/test/cutils/map/map_ut.cc b/test/cutils/map/map_ut.cc +index fd75da28..7e4c97e4 100644 +--- a/test/cutils/map/map_ut.cc ++++ b/test/cutils/map/map_ut.cc +@@ -18,7 +18,12 @@ + #include + #include "map.h" + +-TEST(map_map_ut, test_map) ++static void ptr_ptr_map_kefree(void *key, void *value) ++{ ++ return; ++} ++ ++TEST(map_map_ut, test_map_string) + { + // map[string][bool] + map_t *map_test = nullptr; +@@ -37,3 +42,46 @@ TEST(map_map_ut, test_map) + map_itor_free(itor); + map_clear(map_test); + } ++ ++TEST(map_map_ut, test_map_int) ++{ ++ int key = 3; ++ int value = 5; ++ int *value_ptr = nullptr; ++ // map[int][int] ++ map_t *map_test = nullptr; ++ ++ map_test = map_new(MAP_INT_INT, MAP_DEFAULT_CMP_FUNC, MAP_DEFAULT_FREE_FUNC); ++ ASSERT_NE(map_test, nullptr); ++ ASSERT_EQ(map_insert(map_test, &key, &value), true); ++ ++ key = 22; ++ value = 33; ++ ASSERT_EQ(map_insert(map_test, &key, &value), true); ++ ++ value_ptr = (int *)map_search(map_test, &key); ++ ASSERT_EQ(*value_ptr, 33); ++ ++ key = 44; ++ ASSERT_EQ(map_search(map_test, &key), nullptr); ++ ++ map_clear(map_test); ++} ++ ++TEST(map_map_ut, test_map_ptr) ++{ ++ int *key_ptr = new int(3); ++ int *value_ptr = new int(5); ++ // map[ptr][ptr] ++ map_t *map_test = nullptr; ++ ++ map_test = map_new(MAP_PTR_PTR, MAP_DEFAULT_CMP_FUNC, ptr_ptr_map_kefree); ++ ASSERT_NE(map_test, nullptr); ++ ASSERT_EQ(map_insert(map_test, key_ptr, value_ptr), true); ++ ASSERT_EQ(map_search(map_test, key_ptr), value_ptr); ++ ASSERT_EQ(map_search(map_test, nullptr), nullptr); ++ ++ map_clear(map_test); ++ delete key_ptr; ++ delete value_ptr; ++} +diff --git a/test/cutils/utils_string/utils_string_ut.cc b/test/cutils/utils_string/utils_string_ut.cc +index 8b6c61a6..0f8f0011 100644 +--- a/test/cutils/utils_string/utils_string_ut.cc ++++ b/test/cutils/utils_string/utils_string_ut.cc +@@ -833,26 +833,33 @@ TEST(utils_string_ut, test_str_token) + free(token); + } + +-TEST(utils_string_ut, test_string_split_multi) ++TEST(utils_string_ut, test_string_split_n) + { + char **result = nullptr; + +- ASSERT_EQ(util_string_split_multi(nullptr, ':'), nullptr); ++ ASSERT_EQ(util_string_split_n(nullptr, ':', 3), nullptr); ++ ASSERT_EQ(util_string_split_n("aa:bb", ':', 0), nullptr); + +- result = util_string_split_multi("", ':'); ++ result = util_string_split_n("", ':', 3); + ASSERT_STREQ(result[0], ""); + ASSERT_EQ(result[1], nullptr); + util_free_array(result); + +- result = util_string_split_multi("abcd;", ':'); ++ result = util_string_split_n("abcd;", ':', 3); + ASSERT_STREQ(result[0], "abcd;"); + ASSERT_EQ(result[1], nullptr); + util_free_array(result); + +- result = util_string_split_multi("abc:dd:e", ':'); ++ result = util_string_split_n("abc:dd:e", ':', 3); + ASSERT_STREQ(result[0], "abc"); + ASSERT_STREQ(result[1], "dd"); + ASSERT_STREQ(result[2], "e"); + ASSERT_EQ(result[3], nullptr); + util_free_array(result); ++ ++ result = util_string_split_n("abc:dd:e", ':', 2); ++ ASSERT_STREQ(result[0], "abc"); ++ ASSERT_STREQ(result[1], "dd:e"); ++ ASSERT_EQ(result[2], nullptr); ++ util_free_array(result); + } +-- +2.25.1 + diff --git a/0031-remove-mnt-point-if-add-device-mapper-device-failed.patch b/0031-remove-mnt-point-if-add-device-mapper-device-failed.patch new file mode 100644 index 0000000..99ad3e0 --- /dev/null +++ b/0031-remove-mnt-point-if-add-device-mapper-device-failed.patch @@ -0,0 +1,32 @@ +From 81cf4edd6aa0c4170eb0ec48a6934ef3262a920d Mon Sep 17 00:00:00 2001 +From: zhangxiaoyu +Date: Sat, 22 Oct 2022 11:48:48 +0800 +Subject: [PATCH 31/39] remove mnt point if add device mapper device failed + +Signed-off-by: zhangxiaoyu +--- + .../layer_store/graphdriver/devmapper/driver_devmapper.c | 8 +++++++- + 1 file changed, 7 insertions(+), 1 deletion(-) + +diff --git a/src/daemon/modules/image/oci/storage/layer_store/graphdriver/devmapper/driver_devmapper.c b/src/daemon/modules/image/oci/storage/layer_store/graphdriver/devmapper/driver_devmapper.c +index f4d54963..0a4e5e57 100644 +--- a/src/daemon/modules/image/oci/storage/layer_store/graphdriver/devmapper/driver_devmapper.c ++++ b/src/daemon/modules/image/oci/storage/layer_store/graphdriver/devmapper/driver_devmapper.c +@@ -106,7 +106,13 @@ static int do_create(const char *id, const char *parent, const struct graphdrive + goto out; + } + +- ret = add_device(id, parent, driver->devset, create_opts->storage_opt); ++ if (add_device(id, parent, driver->devset, create_opts->storage_opt) != 0) { ++ ERROR("Failed to add device"); ++ ret = -1; ++ if (util_path_remove(mnt_point_dir) != 0) { ++ ERROR("Remove path:%s failed", mnt_point_dir); ++ } ++ } + + out: + free(mnt_parent_dir); +-- +2.25.1 + diff --git a/0032-dec-device-info-ref-in-grow-device-fs.patch b/0032-dec-device-info-ref-in-grow-device-fs.patch new file mode 100644 index 0000000..be81669 --- /dev/null +++ b/0032-dec-device-info-ref-in-grow-device-fs.patch @@ -0,0 +1,59 @@ +From 5ded258d2e9a331a1fa5e3f76757fdb1e868cc8f Mon Sep 17 00:00:00 2001 +From: zhangxiaoyu +Date: Thu, 20 Oct 2022 16:17:26 +0800 +Subject: [PATCH 32/39] dec device info ref in grow device fs + +Signed-off-by: zhangxiaoyu +--- + .../graphdriver/devmapper/deviceset.c | 26 +++++++++---------- + 1 file changed, 13 insertions(+), 13 deletions(-) + +diff --git a/src/daemon/modules/image/oci/storage/layer_store/graphdriver/devmapper/deviceset.c b/src/daemon/modules/image/oci/storage/layer_store/graphdriver/devmapper/deviceset.c +index 78d8737d..4dadc336 100644 +--- a/src/daemon/modules/image/oci/storage/layer_store/graphdriver/devmapper/deviceset.c ++++ b/src/daemon/modules/image/oci/storage/layer_store/graphdriver/devmapper/deviceset.c +@@ -2483,6 +2483,7 @@ static void cleanup_deleted_devices(struct graphdriver *driver) + device_info = lookup_device(driver->devset, idsarray[i]); + if (device_info == NULL || device_info->info == NULL) { + DEBUG("devmapper: no such device with hash(%s), just skip cleanup", idsarray[i]); ++ devmapper_device_info_ref_dec(device_info); + continue; + } + +@@ -2900,21 +2901,20 @@ static int grow_device_fs(struct device_set *devset, const char *hash, uint64_t + + if (size <= base_size) { + return 0; +- } else { +- DEBUG("devmapper: new fs size is larger than old basesize, start to grow fs"); +- device_info = lookup_device(devset, hash); +- if (device_info == NULL) { +- ERROR("devmapper: lookup device %s failed", hash); +- ret = -1; +- goto out; +- } ++ } + +- if (grow_fs(devset, device_info->info) != 0) { +- ret = -1; +- goto out; +- } ++ DEBUG("devmapper: new fs size is larger than old basesize, start to grow fs"); ++ device_info = lookup_device(devset, hash); ++ if (device_info == NULL) { ++ ERROR("devmapper: lookup device %s failed", hash); ++ return -1; + } +-out: ++ ++ if (grow_fs(devset, device_info->info) != 0) { ++ ret = -1; ++ } ++ ++ devmapper_device_info_ref_dec(device_info); + return ret; + } + +-- +2.25.1 + diff --git a/0033-device-mapper-bugfix.patch b/0033-device-mapper-bugfix.patch new file mode 100644 index 0000000..bf4f5ca --- /dev/null +++ b/0033-device-mapper-bugfix.patch @@ -0,0 +1,72 @@ +From 4b59b86a191a43d88423a1f2659392b8bd9ff849 Mon Sep 17 00:00:00 2001 +From: zhangxiaoyu +Date: Wed, 26 Oct 2022 16:57:41 +0800 +Subject: [PATCH 33/39] device mapper bugfix + +Signed-off-by: zhangxiaoyu +--- + .../layer_store/graphdriver/devmapper/driver_devmapper.c | 9 +++++++-- + .../graphdriver/devmapper/wrapper_devmapper.c | 8 ++++---- + 2 files changed, 11 insertions(+), 6 deletions(-) + +diff --git a/src/daemon/modules/image/oci/storage/layer_store/graphdriver/devmapper/driver_devmapper.c b/src/daemon/modules/image/oci/storage/layer_store/graphdriver/devmapper/driver_devmapper.c +index 0a4e5e57..dd231bd6 100644 +--- a/src/daemon/modules/image/oci/storage/layer_store/graphdriver/devmapper/driver_devmapper.c ++++ b/src/daemon/modules/image/oci/storage/layer_store/graphdriver/devmapper/driver_devmapper.c +@@ -231,6 +231,9 @@ char *devmapper_mount_layer(const char *id, const struct graphdriver *driver, + if (rootfs == NULL) { + ERROR("Failed to join devmapper rootfs %s", mnt_point_dir); + ret = -1; ++ if (unmount_device(id, mnt_point_dir, driver->devset) != 0) { ++ DEBUG("devmapper: unmount %s failed", mnt_point_dir); ++ } + goto out; + } + +@@ -246,6 +249,7 @@ char *devmapper_mount_layer(const char *id, const struct graphdriver *driver, + id_file = util_path_join(mnt_point_dir, "id"); + if (!util_file_exists(id_file)) { + if (util_atomic_write_file(id_file, id, strlen(id), SECURE_CONFIG_FILE_MODE, true) != 0) { ++ ret = -1; + if (unmount_device(id, mnt_point_dir, driver->devset) != 0) { + DEBUG("devmapper: unmount %s failed", mnt_point_dir); + } +@@ -350,13 +354,14 @@ int devmapper_apply_diff(const char *id, const struct graphdriver *driver, const + if (archive_unpack(content, layer_fs, &options, &err) != 0) { + ERROR("devmapper: failed to unpack to %s: %s", layer_fs, err); + ret = -1; +- goto out; ++ goto umount_out; + } + ++umount_out: ++ // umount layer if devmapper_mount_layer success + if (devmapper_umount_layer(id, driver) != 0) { + ERROR("devmapper: failed to umount layer %s", id); + ret = -1; +- goto out; + } + + out: +diff --git a/src/daemon/modules/image/oci/storage/layer_store/graphdriver/devmapper/wrapper_devmapper.c b/src/daemon/modules/image/oci/storage/layer_store/graphdriver/devmapper/wrapper_devmapper.c +index 7ae1fd40..c8f3d6d8 100644 +--- a/src/daemon/modules/image/oci/storage/layer_store/graphdriver/devmapper/wrapper_devmapper.c ++++ b/src/daemon/modules/image/oci/storage/layer_store/graphdriver/devmapper/wrapper_devmapper.c +@@ -28,10 +28,10 @@ + #include "utils.h" + #include "err_msg.h" + +-static bool g_dm_saw_busy = false; +-static bool g_dm_saw_exist = false; +-static bool g_dm_saw_enxio = false; // no such device or address +-static bool g_dm_saw_eno_data = false; // no data available ++static __thread bool g_dm_saw_busy = false; ++static __thread bool g_dm_saw_exist = false; ++static __thread bool g_dm_saw_enxio = false; // no such device or address ++static __thread bool g_dm_saw_eno_data = false; // no data available + static int64_t dm_udev_wait_timeout = 0; + + char *dev_strerror(int errnum) +-- +2.25.1 + diff --git a/0034-delete-syncCloseSem-when-close-all-wssession.patch b/0034-delete-syncCloseSem-when-close-all-wssession.patch new file mode 100644 index 0000000..e965fe8 --- /dev/null +++ b/0034-delete-syncCloseSem-when-close-all-wssession.patch @@ -0,0 +1,25 @@ +From 1111a16537bddf5d272f58bd1b67969f105a426d Mon Sep 17 00:00:00 2001 +From: zhangxiaoyu +Date: Fri, 28 Oct 2022 11:21:19 +0800 +Subject: [PATCH 34/39] delete syncCloseSem when close all wssession + +Signed-off-by: zhangxiaoyu +--- + src/daemon/entry/cri/websocket/service/ws_server.cc | 1 + + 1 file changed, 1 insertion(+) + +diff --git a/src/daemon/entry/cri/websocket/service/ws_server.cc b/src/daemon/entry/cri/websocket/service/ws_server.cc +index 6438c4d7..a9b58685 100644 +--- a/src/daemon/entry/cri/websocket/service/ws_server.cc ++++ b/src/daemon/entry/cri/websocket/service/ws_server.cc +@@ -250,6 +250,7 @@ void WebsocketServer::CloseAllWsSession() + close(it->second->pipes.at(0)); + close(it->second->pipes.at(1)); + (void)sem_destroy(it->second->syncCloseSem); ++ delete it->second->syncCloseSem; + delete it->second->sessionMutex; + delete it->second; + } +-- +2.25.1 + diff --git a/0035-improve-debug-information-for-console-io.patch b/0035-improve-debug-information-for-console-io.patch new file mode 100644 index 0000000..3400415 --- /dev/null +++ b/0035-improve-debug-information-for-console-io.patch @@ -0,0 +1,187 @@ +From b0022ff6d820d17428aa04e6be148e84dade0855 Mon Sep 17 00:00:00 2001 +From: haozi007 +Date: Fri, 28 Oct 2022 16:32:03 +0800 +Subject: [PATCH 35/39] [improve] debug information for console io + +Signed-off-by: haozi007 +--- + .../entry/cri/websocket/service/ws_server.cc | 22 +++++++++++++------ + src/daemon/modules/events/collector.c | 12 +++++----- + src/utils/console/console.c | 8 ++++++- + src/utils/cutils/io_wrapper.h | 11 ++++++++++ + 4 files changed, 39 insertions(+), 14 deletions(-) + +diff --git a/src/daemon/entry/cri/websocket/service/ws_server.cc b/src/daemon/entry/cri/websocket/service/ws_server.cc +index a9b58685..41bb3fe8 100644 +--- a/src/daemon/entry/cri/websocket/service/ws_server.cc ++++ b/src/daemon/entry/cri/websocket/service/ws_server.cc +@@ -79,17 +79,25 @@ int SessionData::PushMessage(unsigned char *message) + + sessionMutex->lock(); + +- // In extreme scenarios, websocket data cannot be processed, +- // ignore the data coming in later to prevent iSulad from getting stuck +- if (close || buffer.size() >= FIFO_LIST_BUFFER_MAX_LEN) { +- free(message); ++ if (!close && buffer.size() < FIFO_LIST_BUFFER_MAX_LEN) { ++ buffer.push_back(message); + sessionMutex->unlock(); +- return -1; ++ return 0; + } + +- buffer.push_back(message); ++ // In extreme scenarios, websocket data cannot be processed, ++ // ignore the data coming in later to prevent iSulad from getting stuck ++ free(message); + sessionMutex->unlock(); +- return 0; ++ ++ if (close) { ++ DEBUG("Closed session"); ++ } ++ if (buffer.size() >= FIFO_LIST_BUFFER_MAX_LEN) { ++ ERROR("Too large: %zu message!", buffer.size()); ++ } ++ ++ return -1; + } + + bool SessionData::IsClosed() +diff --git a/src/daemon/modules/events/collector.c b/src/daemon/modules/events/collector.c +index 9dc4dbe7..433cb88b 100644 +--- a/src/daemon/modules/events/collector.c ++++ b/src/daemon/modules/events/collector.c +@@ -339,28 +339,28 @@ static void supplement_annotations_for_container_msg(const container_t *cont, co + struct isulad_events_format *format_msg) + { + if (supplement_pid_for_container_msg(cont, msg, format_msg) != 0) { +- ERROR("Failed to supplement pid info"); ++ WARN("Failed to supplement pid info"); + } + + if (supplement_exitcode_for_container_msg(cont, msg, format_msg) != 0) { +- ERROR("Failed to supplement exitCode info"); ++ WARN("Failed to supplement exitCode info"); + } + + if (supplement_image_for_container_msg(cont, msg, format_msg) != 0) { +- ERROR("Failed to supplement image info"); ++ WARN("Failed to supplement image info"); + } + + if (supplement_name_for_container_msg(cont, msg, format_msg) != 0) { +- ERROR("Failed to supplement name info"); ++ WARN("Failed to supplement name info"); + } + + if (supplement_labels_for_container_msg(cont, msg, format_msg) != 0) { +- ERROR("Failed to supplement label info"); ++ WARN("Failed to supplement label info"); + } + + if (strlen(msg->extra_annations) != 0) { + if (util_array_append(&format_msg->annotations, msg->extra_annations) != 0) { +- ERROR("Failed to supplement extra annations info"); ++ WARN("Failed to supplement extra annations info"); + } + } + +diff --git a/src/utils/console/console.c b/src/utils/console/console.c +index 3565eef3..d5e5d9af 100644 +--- a/src/utils/console/console.c ++++ b/src/utils/console/console.c +@@ -100,7 +100,7 @@ static int console_writer_write_data(const struct io_write_wrapper *writer, cons + } + ret = writer->write_func(writer->context, buf, (size_t)len); + if (ret <= 0 || ret != len) { +- ERROR("failed to write, error:%s", strerror(errno)); ++ ERROR("Failed to write, type: %d, expect: %zd, wrote: %zd, error: %s!", writer->io_type, len, ret, strerror(errno)); + return -1; + } + return 0; +@@ -401,6 +401,7 @@ int console_loop_with_std_fd(int stdinfd, int stdoutfd, int stderrfd, int fifoin + if (fifoinfd >= 0) { + ts.stdin_reader = stdinfd; + ts.stdin_writer.context = &fifoinfd; ++ ts.stdin_writer.io_type = FIFO_IN_IO; + ts.stdin_writer.write_func = fd_write_function; + if (tty) { + ret = epoll_loop_add_handler(&descr, ts.stdin_reader, console_cb_tty_stdin_with_escape, &ts); +@@ -418,6 +419,7 @@ int console_loop_with_std_fd(int stdinfd, int stdoutfd, int stderrfd, int fifoin + if (fifooutfd >= 0) { + ts.stdout_reader = fifooutfd; + ts.stdout_writer.context = &stdoutfd; ++ ts.stdin_writer.io_type = FIFO_OUT_IO; + ts.stdout_writer.write_func = fd_write_function; + ret = epoll_loop_add_handler(&descr, ts.stdout_reader, console_cb_stdio_copy, &ts); + if (ret) { +@@ -429,6 +431,7 @@ int console_loop_with_std_fd(int stdinfd, int stdoutfd, int stderrfd, int fifoin + if (fifoerrfd >= 0) { + ts.stderr_reader = fifoerrfd; + ts.stderr_writer.context = &stderrfd; ++ ts.stdin_writer.io_type = FIFO_ERR_IO; + ts.stderr_writer.write_func = fd_write_function; + ret = epoll_loop_add_handler(&descr, ts.stderr_reader, console_cb_stdio_copy, &ts); + if (ret) { +@@ -477,18 +480,21 @@ int console_loop_io_copy(int sync_fd, const int *srcfds, struct io_write_wrapper + ts[i].stdin_reader = srcfds[i]; + ts[i].stdin_writer.context = writers[i].context; + ts[i].stdin_writer.write_func = writers[i].write_func; ++ ts[i].stdin_writer.io_type = FUNC_IN_IO; + ret = epoll_loop_add_handler(&descr, ts[i].stdin_reader, console_cb_stdio_copy, &ts[i]); + } else if (channels[i] == STDOUT_CHANNEL) { + // Reusing ts.stdout_reader and ts.stdout_writer for coping io + ts[i].stdout_reader = srcfds[i]; + ts[i].stdout_writer.context = writers[i].context; + ts[i].stdout_writer.write_func = writers[i].write_func; ++ ts[i].stdin_writer.io_type = FUNC_OUT_IO; + ret = epoll_loop_add_handler(&descr, ts[i].stdout_reader, console_cb_stdio_copy, &ts[i]); + } else { + // Reusing ts.stderr_reader and ts.stderr_writer for coping io + ts[i].stderr_reader = srcfds[i]; + ts[i].stderr_writer.context = writers[i].context; + ts[i].stderr_writer.write_func = writers[i].write_func; ++ ts[i].stdin_writer.io_type = FUNC_ERR_IO; + ret = epoll_loop_add_handler(&descr, ts[i].stderr_reader, console_cb_stdio_copy, &ts[i]); + } + if (ret != 0) { +diff --git a/src/utils/cutils/io_wrapper.h b/src/utils/cutils/io_wrapper.h +index 0134a822..a9340d01 100644 +--- a/src/utils/cutils/io_wrapper.h ++++ b/src/utils/cutils/io_wrapper.h +@@ -21,6 +21,15 @@ + extern "C" { + #endif + ++enum { ++ FIFO_IN_IO = 0, ++ FIFO_OUT_IO, ++ FIFO_ERR_IO, ++ FUNC_IN_IO, ++ FUNC_OUT_IO, ++ FUNC_ERR_IO, ++}; ++ + typedef ssize_t (*io_write_func_t)(void *context, const void *data, size_t len); + typedef int (*io_close_func_t)(void *context, char **err); + +@@ -28,6 +37,7 @@ struct io_write_wrapper { + void *context; + io_write_func_t write_func; + io_close_func_t close_func; ++ int io_type; + }; + + typedef ssize_t (*io_read_func_t)(void *context, void *buf, size_t len); +@@ -36,6 +46,7 @@ struct io_read_wrapper { + void *context; + io_read_func_t read; + io_close_func_t close; ++ int io_type; + }; + + #ifdef __cplusplus +-- +2.25.1 + diff --git a/0036-add-ut-for-file.patch b/0036-add-ut-for-file.patch new file mode 100644 index 0000000..faedebd --- /dev/null +++ b/0036-add-ut-for-file.patch @@ -0,0 +1,288 @@ +From afe09041af292ae529ba8071e0737be778223853 Mon Sep 17 00:00:00 2001 +From: songbuhuang <544824346@qq.com> +Date: Sat, 29 Oct 2022 16:35:21 +0800 +Subject: [PATCH 36/39] add ut for file + +Signed-off-by: songbuhuang <544824346@qq.com> +--- + test/cutils/CMakeLists.txt | 1 + + test/cutils/utils_file/CMakeLists.txt | 18 ++ + test/cutils/utils_file/utils_file_ut.cc | 229 ++++++++++++++++++++++++ + 3 files changed, 248 insertions(+) + create mode 100644 test/cutils/utils_file/CMakeLists.txt + create mode 100644 test/cutils/utils_file/utils_file_ut.cc + +diff --git a/test/cutils/CMakeLists.txt b/test/cutils/CMakeLists.txt +index 2447b781..11e0ee90 100644 +--- a/test/cutils/CMakeLists.txt ++++ b/test/cutils/CMakeLists.txt +@@ -29,6 +29,7 @@ add_subdirectory(utils_network) + add_subdirectory(utils_aes) + add_subdirectory(utils_error) + add_subdirectory(utils_fs) ++add_subdirectory(utils_file) + add_subdirectory(utils_filters) + add_subdirectory(utils_timestamp) + add_subdirectory(utils_mount_spec) +diff --git a/test/cutils/utils_file/CMakeLists.txt b/test/cutils/utils_file/CMakeLists.txt +new file mode 100644 +index 00000000..20317e15 +--- /dev/null ++++ b/test/cutils/utils_file/CMakeLists.txt +@@ -0,0 +1,18 @@ ++project(iSulad_UT) ++ ++SET(EXE utils_file_ut) ++ ++add_executable(${EXE} ++ utils_file_ut.cc) ++ ++target_include_directories(${EXE} PUBLIC ++ ${GTEST_INCLUDE_DIR} ++ ${CMAKE_CURRENT_SOURCE_DIR}/../../include ++ ${CMAKE_CURRENT_SOURCE_DIR}/../../../src/common ++ ${CMAKE_CURRENT_SOURCE_DIR}/../../../src/utils/cutils/map ++ ${CMAKE_CURRENT_SOURCE_DIR}/../../../src/utils/sha256 ++ ${CMAKE_CURRENT_SOURCE_DIR}/../../../src/utils/cutils ++ ) ++ ++target_link_libraries(${EXE} ${GTEST_BOTH_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT} ${ISULA_LIBUTILS_LIBRARY} libutils_ut -lcrypto -lyajl -lz) ++add_test(NAME ${EXE} COMMAND ${EXE} --gtest_output=xml:${EXE}-Results.xml) +diff --git a/test/cutils/utils_file/utils_file_ut.cc b/test/cutils/utils_file/utils_file_ut.cc +new file mode 100644 +index 00000000..ccd60ba4 +--- /dev/null ++++ b/test/cutils/utils_file/utils_file_ut.cc +@@ -0,0 +1,229 @@ ++/* ++ * Copyright (c) Huawei Technologies Co., Ltd. 2022. All rights reserved. ++ * iSulad licensed under the Mulan PSL v2. ++ * You can use this software according to the terms and conditions of the Mulan PSL v2. ++ * You may obtain a copy of Mulan PSL v2 at: ++ * http://license.coscl.org.cn/MulanPSL2 ++ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR ++ * IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR ++ * PURPOSE. ++ * See the Mulan PSL v2 for more details. ++ * Description: utils_file unit test ++ * Author: huangsong ++ * Create: 2022-10-26 ++ */ ++ ++#include ++#include ++#include ++#include ++#include ++#include "mock.h" ++#include "utils_file.h" ++#include "constants.h" ++#include "map.h" ++ ++#define FILE_PERMISSION_TEST 0755 ++ ++TEST(utils_file, test_util_dir_exists) ++{ ++ ASSERT_EQ(util_dir_exists(nullptr), false); ++ ++ const char *path = "/tmp/test"; ++ ASSERT_EQ(util_dir_exists(path), false); ++ ASSERT_EQ(util_mkdir_p(path, FILE_PERMISSION_TEST), 0); ++ ASSERT_EQ(util_dir_exists(path), true); ++ ASSERT_EQ(util_path_remove(path), 0); ++ ++} ++ ++TEST(utils_file, test_util_fileself_exists) ++{ ++ ASSERT_EQ(util_fileself_exists(nullptr), false); ++ ++ std::string path = "/tmp/test"; ++ std::string path_link = "/tmp/test/link"; ++ ASSERT_EQ(util_mkdir_p(path.c_str(), FILE_PERMISSION_TEST), 0); ++ ASSERT_EQ(util_fileself_exists(path_link.c_str()), false); ++ ASSERT_EQ(symlink(path.c_str(),path_link.c_str()), 0); ++ ASSERT_EQ(util_fileself_exists(path_link.c_str()), true); ++ ASSERT_EQ(util_path_remove(path_link.c_str()), 0); ++ ASSERT_EQ(util_path_remove(path.c_str()), 0); ++} ++ ++TEST(utils_file, test_util_file_exists) ++{ ++ ASSERT_EQ(util_file_exists(nullptr), false); ++ ++ std::string path = "/tmp/test"; ++ ASSERT_EQ(util_file_exists(path.c_str()), false); ++ ASSERT_EQ(util_mkdir_p(path.c_str(), FILE_PERMISSION_TEST), 0); ++ ASSERT_EQ(util_file_exists(path.c_str()), true); ++ ASSERT_EQ(util_path_remove(path.c_str()), 0); ++} ++ ++ ++TEST(utils_file, test_util_recursive_rmdir) ++{ ++ ASSERT_EQ(util_recursive_rmdir(nullptr,0), -1); ++ ++ std::string path = "/tmp/test"; ++ std::string path_link = "/tmp/test/link"; ++ ASSERT_EQ(util_mkdir_p(path.c_str(), FILE_PERMISSION_TEST), 0); ++ ASSERT_EQ(util_mkdir_p(path_link.c_str(), FILE_PERMISSION_TEST), 0); ++ ASSERT_EQ(util_recursive_rmdir(path.c_str(),1), 0); ++ ASSERT_EQ(util_file_exists(path.c_str()), false); ++ ASSERT_EQ(util_file_exists(path_link.c_str()), false); ++} ++ ++TEST(utils_file, test_util_ensure_path) ++{ ++ char *rpath = NULL; ++ std::string path = "/tmp/test"; ++ ASSERT_EQ(util_ensure_path(nullptr,path.c_str()), -1); ++ ASSERT_EQ(util_ensure_path(&rpath,nullptr), -1); ++ ++ ASSERT_EQ(util_file_exists(path.c_str()), false); ++ ASSERT_EQ(util_ensure_path(&rpath,path.c_str()), 0); ++ ASSERT_EQ(util_file_exists(rpath), true); ++ ASSERT_EQ(util_path_remove(path.c_str()), 0); ++} ++ ++TEST(utils_file, test_util_build_dir) ++{ ++ ASSERT_EQ(util_build_dir(nullptr), -1); ++ ++ std::string path = "/tmp/test/file"; ++ ASSERT_EQ(util_build_dir(path.c_str()), 0); ++ ASSERT_EQ(util_file_exists("/tmp"), true); ++ ASSERT_EQ(util_file_exists("/tmp/test"), true); ++ ASSERT_EQ(util_path_remove(path.c_str()), 0); ++} ++ ++TEST(utils_file, test_util_human_size) ++{ ++ uint64_t b = 1; ++ uint64_t kb = 1024; ++ uint64_t mb = 1024 * 1024; ++ uint64_t gb = 1024 * 1024 * 1024; ++ ASSERT_STREQ(util_human_size(b), "1B"); ++ ASSERT_STREQ(util_human_size(kb), "1KB"); ++ ASSERT_STREQ(util_human_size(mb), "1MB"); ++ ASSERT_STREQ(util_human_size(gb), "1GB"); ++ ++ ASSERT_STREQ(util_human_size_decimal(b), "1B"); ++ ASSERT_STREQ(util_human_size_decimal(kb), "1.000KB"); ++ ASSERT_STREQ(util_human_size_decimal(mb), "1.000MB"); ++ ASSERT_STREQ(util_human_size_decimal(gb), "1.000GB"); ++} ++ ++TEST(utils_file, test_util_open) ++{ ++ std::string path = "/tmp/test"; ++ ASSERT_EQ(util_mkdir_p(path.c_str(), FILE_PERMISSION_TEST), 0); ++ ASSERT_NE(util_open(path.c_str(), O_RDONLY, 0), -1); ++ ASSERT_EQ(util_path_remove(path.c_str()), 0); ++} ++ ++TEST(utils_file, test_util_add_path) ++{ ++ std::string path = "/tmp/test/"; ++ std::string add_path = "add"; ++ ASSERT_EQ(util_mkdir_p(path.c_str(), FILE_PERMISSION_TEST), 0); ++ ASSERT_STREQ(util_add_path(path.c_str(),add_path.c_str()), "/tmp/test/add"); ++ ASSERT_EQ(util_path_remove(path.c_str()), 0); ++ ++ std::string path1 = "/tmp/test"; ++ ASSERT_EQ(util_mkdir_p(path1.c_str(), FILE_PERMISSION_TEST), 0); ++ ASSERT_STREQ(util_add_path(path1.c_str(),add_path.c_str()), "/tmp/add"); ++ ASSERT_EQ(util_path_remove(path1.c_str()), 0); ++} ++ ++TEST(utils_file, test_verify_file_and_get_real_path) ++{ ++ std::string path = "/tmp/test"; ++ ASSERT_EQ(util_mkdir_p(path.c_str(), FILE_PERMISSION_TEST), 0); ++ ASSERT_STREQ(verify_file_and_get_real_path(path.c_str()),"/tmp/test"); ++ ASSERT_EQ(util_path_remove(path.c_str()), 0); ++} ++ ++TEST(utils_file, test_look_path) ++{ ++ std::string path = "/usr/bin/nsenter"; ++ char *err = NULL; ++ ASSERT_STREQ(look_path("nsenter",&err),path.c_str()); ++} ++ ++TEST(utils_file, test_util_copy_file) ++{ ++ std::string path = "/tmp/test"; ++ ASSERT_EQ(util_copy_file("/etc/hosts",path.c_str(),NETWORK_MOUNT_FILE_MODE), 0); ++ ASSERT_EQ(util_path_remove(path.c_str()), 0); ++ ++ ASSERT_EQ(util_mkdir_p(path.c_str(), FILE_PERMISSION_TEST), 0); ++ ASSERT_EQ(util_copy_file("/etc/hosts",path.c_str(),NETWORK_MOUNT_FILE_MODE), -1); ++ ASSERT_EQ(util_path_remove(path.c_str()), 0); ++} ++ ++TEST(utils_file, test_utils_calculate_dir_size_without_hardlink) ++{ ++ std::string path = "/tmp/test"; ++ std::string hosts = "/etc/hosts"; ++ ASSERT_EQ(util_copy_file(hosts.c_str(),path.c_str(),NETWORK_MOUNT_FILE_MODE), 0); ++ int64_t total_size = 0; ++ int64_t total_inodes = 0; ++ utils_calculate_dir_size_without_hardlink("/tmp/", &total_size,&total_inodes); ++ ASSERT_NE(total_size, 0); ++ ASSERT_NE(total_inodes, 0); ++ ASSERT_EQ(util_path_remove(path.c_str()), 0); ++} ++ ++static bool parse_checked_layer_cb(const char *line, void *context) ++{ ++ printf("this is stdout\n"); ++ fprintf(stderr, "this is stderr\n"); ++ return true; ++} ++ ++TEST(utils_file, test_util_proc_file_line_by_line) ++{ ++ std::string path = "/tmp/test"; ++ std::string content = "hello world"; ++ int fd; ++ fd = util_open(path.c_str(), O_WRONLY | O_CREAT | O_TRUNC | O_EXCL, DEFAULT_SECURE_FILE_MODE); ++ ASSERT_EQ(util_write_nointr_in_total(fd, content.c_str(), strlen(content.c_str())),11); ++ FILE *fp = NULL; ++ map_t *checked_layers = NULL; ++ fp = util_fopen(path.c_str(), "r"); ++ checked_layers = map_new(MAP_STR_BOOL, MAP_DEFAULT_CMP_FUNC, MAP_DEFAULT_FREE_FUNC); ++ ASSERT_EQ(util_proc_file_line_by_line(fp, parse_checked_layer_cb, (void *)checked_layers),0); ++ fclose(fp); ++ ASSERT_EQ(util_path_remove(path.c_str()), 0); ++} ++ ++TEST(utils_file, test_util_recursive_remove_path) ++{ ++ ASSERT_EQ(util_recursive_remove_path(nullptr), -1); ++ ++ std::string path = "/tmp/test"; ++ std::string path_link = "/tmp/test/link"; ++ ASSERT_EQ(util_mkdir_p(path.c_str(), FILE_PERMISSION_TEST), 0); ++ ASSERT_EQ(util_mkdir_p(path_link.c_str(), FILE_PERMISSION_TEST), 0); ++ ASSERT_EQ(util_recursive_remove_path(path.c_str()), 0); ++ ASSERT_EQ(util_file_exists(path.c_str()), false); ++ ASSERT_EQ(util_file_exists(path_link.c_str()), false); ++ ++} ++ ++TEST(utils_file, test_util_copy_dir_recursive) ++{ ++ char *path = (char*)"/tmp/test1/"; ++ char *src = (char*)"/tmp/test/"; ++ ASSERT_EQ(util_mkdir_p(path, FILE_PERMISSION_TEST), 0); ++ ASSERT_EQ(util_mkdir_p(src, FILE_PERMISSION_TEST), 0); ++ ASSERT_EQ(util_copy_dir_recursive(path,src), 0); ++ ASSERT_EQ(util_recursive_remove_path(path), 0); ++ ASSERT_EQ(util_recursive_remove_path(src), 0); ++} ++ ++ +-- +2.25.1 + diff --git a/0037-Add-extend-C-for-header-files.patch b/0037-Add-extend-C-for-header-files.patch new file mode 100644 index 0000000..d8a4658 --- /dev/null +++ b/0037-Add-extend-C-for-header-files.patch @@ -0,0 +1,688 @@ +From d7b324c04b4b353270216887b05e245337942b97 Mon Sep 17 00:00:00 2001 +From: zhongtao +Date: Mon, 24 Oct 2022 20:46:47 +0800 +Subject: [PATCH 37/39] Add extend C for header files + +Signed-off-by: zhongtao +--- + src/cmd/isula/stream/attach.h | 9 +++++++++ + src/cmd/isula/stream/cp.h | 8 ++++++++ + src/cmd/isula/stream/exec.h | 8 ++++++++ + src/daemon/modules/api/log_gather_api.h | 8 ++++++++ + src/daemon/modules/api/plugin_api.h | 8 ++++++++ + src/daemon/modules/container/container_events_handler.h | 8 ++++++++ + .../modules/container/restart_manager/restartmanager.h | 8 ++++++++ + src/daemon/modules/container/supervisor/supervisor.h | 8 ++++++++ + src/daemon/modules/events/monitord.h | 8 ++++++++ + src/daemon/modules/image/embedded/db/db_all.h | 8 ++++++++ + src/daemon/modules/image/embedded/db/db_common.h | 8 ++++++++ + src/daemon/modules/image/embedded/db/db_images_common.h | 8 ++++++++ + src/daemon/modules/image/embedded/db/sqlite_common.h | 8 ++++++++ + src/daemon/modules/image/embedded/embedded_image.h | 8 ++++++++ + src/daemon/modules/image/embedded/lim.h | 8 ++++++++ + src/daemon/modules/image/embedded/snapshot/embedded.h | 8 ++++++++ + src/daemon/modules/image/embedded/snapshot/snapshot.h | 8 ++++++++ + .../modules/image/embedded/snapshot/snapshot_def.h | 7 +++++++ + src/daemon/modules/image/external/ext_image.h | 8 ++++++++ + src/daemon/modules/image/oci/registry_type.h | 8 ++++++++ + .../graphdriver/devmapper/devices_constants.h | 8 ++++++++ + src/daemon/modules/plugin/pspec.h | 8 ++++++++ + src/daemon/modules/spec/specs_mount.h | 8 ++++++++ + src/daemon/modules/spec/specs_security.h | 8 ++++++++ + src/utils/buffer/buffer.h | 8 ++++++++ + src/utils/cutils/linked_list.h | 8 ++++++++ + src/utils/http/parser.h | 8 ++++++++ + 27 files changed, 216 insertions(+) + +diff --git a/src/cmd/isula/stream/attach.h b/src/cmd/isula/stream/attach.h +index 2e71852b..9792da9d 100644 +--- a/src/cmd/isula/stream/attach.h ++++ b/src/cmd/isula/stream/attach.h +@@ -18,9 +18,18 @@ + #include "client_arguments.h" + #include "isula_libutils/container_inspect.h" + ++#ifdef __cplusplus ++extern "C" { ++#endif ++ + extern const char g_cmd_attach_desc[]; + extern const char g_cmd_attach_usage[]; + extern struct client_arguments g_cmd_attach_args; + int inspect_container(const struct client_arguments *args, container_inspect **inspect_data); + int cmd_attach_main(int argc, const char **argv); ++ ++#ifdef __cplusplus ++} ++#endif ++ + #endif // CMD_ISULA_STREAM_ATTACH_H +diff --git a/src/cmd/isula/stream/cp.h b/src/cmd/isula/stream/cp.h +index 821a3887..491d5421 100644 +--- a/src/cmd/isula/stream/cp.h ++++ b/src/cmd/isula/stream/cp.h +@@ -17,9 +17,17 @@ + + #include "client_arguments.h" + ++#ifdef __cplusplus ++extern "C" { ++#endif ++ + extern const char g_cmd_cp_desc[]; + extern const char g_cmd_cp_usage[]; + extern struct client_arguments g_cmd_cp_args; + int cmd_cp_main(int argc, const char **argv); + ++#ifdef __cplusplus ++} ++#endif ++ + #endif // CMD_ISULA_STREAM_CP_H +diff --git a/src/cmd/isula/stream/exec.h b/src/cmd/isula/stream/exec.h +index 6161c62f..d507d71e 100644 +--- a/src/cmd/isula/stream/exec.h ++++ b/src/cmd/isula/stream/exec.h +@@ -22,6 +22,10 @@ + #include "attach.h" + #include "command_parser.h" + ++#ifdef __cplusplus ++extern "C" { ++#endif ++ + #define EXEC_OPTIONS(cmdargs) \ + { \ + CMD_OPT_TYPE_CALLBACK, false, "env", 'e', &(cmdargs).extra_env, "Set environment variables", \ +@@ -51,4 +55,8 @@ extern const char g_cmd_exec_usage[]; + extern struct client_arguments g_cmd_exec_args; + int cmd_exec_main(int argc, const char **argv); + ++#ifdef __cplusplus ++} ++#endif ++ + #endif // CMD_ISULA_STREAM_EXEC_H +diff --git a/src/daemon/modules/api/log_gather_api.h b/src/daemon/modules/api/log_gather_api.h +index b72a5800..2c98ff11 100644 +--- a/src/daemon/modules/api/log_gather_api.h ++++ b/src/daemon/modules/api/log_gather_api.h +@@ -22,6 +22,10 @@ + + #define REV_BUF_SIZE 4096 + ++#ifdef __cplusplus ++extern "C" { ++#endif ++ + struct log_gather_conf { + const char *fifo_path; + int *exitcode; +@@ -40,5 +44,9 @@ enum log_gather_driver { + + void *log_gather(void *arg); + ++#ifdef __cplusplus ++} ++#endif ++ + #endif + +diff --git a/src/daemon/modules/api/plugin_api.h b/src/daemon/modules/api/plugin_api.h +index 303ba6bf..bf138ec1 100644 +--- a/src/daemon/modules/api/plugin_api.h ++++ b/src/daemon/modules/api/plugin_api.h +@@ -41,6 +41,10 @@ + #define PLUGIN_EVENT_CONTAINER_POST_STOP (1UL << 2) + #define PLUGIN_EVENT_CONTAINER_POST_REMOVE (1UL << 3) + ++#ifdef __cplusplus ++extern "C" { ++#endif ++ + typedef struct plugin_manifest { + uint64_t init_type; + uint64_t watch_event; +@@ -109,4 +113,8 @@ int plugin_event_container_post_stop(const container_t *cont); + int plugin_event_container_post_remove(const container_t *cont); + int plugin_event_container_post_remove2(const char *cid, const oci_runtime_spec *oci); + ++#ifdef __cplusplus ++} ++#endif ++ + #endif // DAEMON_MODULES_API_PLUGIN_API_H +diff --git a/src/daemon/modules/container/container_events_handler.h b/src/daemon/modules/container/container_events_handler.h +index f38f293d..77cf5d06 100644 +--- a/src/daemon/modules/container/container_events_handler.h ++++ b/src/daemon/modules/container/container_events_handler.h +@@ -22,10 +22,18 @@ + #include "container_api.h" + #include "events_format.h" + ++#ifdef __cplusplus ++extern "C" { ++#endif ++ + container_events_handler_t *container_events_handler_new(); + + void container_events_handler_free(container_events_handler_t *handler); + + int container_events_handler_post_events(const struct isulad_events_format *event); + ++#ifdef __cplusplus ++} ++#endif ++ + #endif // DAEMON_MODULES_CONTAINER_CONTAINER_EVENTS_HANDLER_H +diff --git a/src/daemon/modules/container/restart_manager/restartmanager.h b/src/daemon/modules/container/restart_manager/restartmanager.h +index 1f5f13b3..106343b2 100644 +--- a/src/daemon/modules/container/restart_manager/restartmanager.h ++++ b/src/daemon/modules/container/restart_manager/restartmanager.h +@@ -22,6 +22,10 @@ + #include "isula_libutils/host_config.h" + #include "container_api.h" + ++#ifdef __cplusplus ++extern "C" { ++#endif ++ + void restart_policy_free(host_config_restart_policy *policy); + + restart_manager_t *restart_manager_new(const host_config_restart_policy *policy, int failure_count); +@@ -43,4 +47,8 @@ int restart_manager_wait_cancel(restart_manager_t *rm, uint64_t timeout); + + int container_restart_in_thread(const char *id, uint64_t timeout, int exit_code); + ++#ifdef __cplusplus ++} ++#endif ++ + #endif // DAEMON_MODULES_CONTAINER_RESTART_MANAGER_RESTARTMANAGER_H +diff --git a/src/daemon/modules/container/supervisor/supervisor.h b/src/daemon/modules/container/supervisor/supervisor.h +index e5b5a2e7..2b208c5a 100644 +--- a/src/daemon/modules/container/supervisor/supervisor.h ++++ b/src/daemon/modules/container/supervisor/supervisor.h +@@ -19,8 +19,16 @@ + + #include "container_unix.h" + ++#ifdef __cplusplus ++extern "C" { ++#endif ++ + extern char *exit_fifo_name(const char *cont_state_path); + + extern int new_supervisor(); + ++#ifdef __cplusplus ++} ++#endif ++ + #endif +diff --git a/src/daemon/modules/events/monitord.h b/src/daemon/modules/events/monitord.h +index beace80e..1741983d 100644 +--- a/src/daemon/modules/events/monitord.h ++++ b/src/daemon/modules/events/monitord.h +@@ -20,6 +20,10 @@ + + #include "utils.h" + ++#ifdef __cplusplus ++extern "C" { ++#endif ++ + struct monitord_sync_data { + sem_t *monitord_sem; + int *exit_code; +@@ -27,4 +31,8 @@ struct monitord_sync_data { + + int new_monitord(struct monitord_sync_data *msync); + ++#ifdef __cplusplus ++} ++#endif ++ + #endif +diff --git a/src/daemon/modules/image/embedded/db/db_all.h b/src/daemon/modules/image/embedded/db/db_all.h +index 9fbe2729..e72777c2 100644 +--- a/src/daemon/modules/image/embedded/db/db_all.h ++++ b/src/daemon/modules/image/embedded/db/db_all.h +@@ -20,6 +20,10 @@ + #include + #include "db_common.h" + ++#ifdef __cplusplus ++extern "C" { ++#endif ++ + struct db_sninfo { + char *snid; + char *parent_snid; +@@ -73,5 +77,9 @@ int db_read_all_images_info(struct db_all_images **image_info); + + void db_all_imginfo_free(struct db_all_images *images_info); + ++#ifdef __cplusplus ++} ++#endif ++ + #endif + +diff --git a/src/daemon/modules/image/embedded/db/db_common.h b/src/daemon/modules/image/embedded/db/db_common.h +index ab83599f..8ed1138c 100644 +--- a/src/daemon/modules/image/embedded/db/db_common.h ++++ b/src/daemon/modules/image/embedded/db/db_common.h +@@ -25,9 +25,17 @@ + #define DB_DEREF_ONLY 4 + #define DB_NOT_EXIST 5 + ++#ifdef __cplusplus ++extern "C" { ++#endif ++ + int db_common_init(const char *rootpath); + + void db_common_finish(void); + ++#ifdef __cplusplus ++} ++#endif ++ + #endif // DAEMON_MODULES_IMAGE_EMBEDDED_DB_DB_COMMON_H + +diff --git a/src/daemon/modules/image/embedded/db/db_images_common.h b/src/daemon/modules/image/embedded/db/db_images_common.h +index 1fde16cc..a35ea49f 100644 +--- a/src/daemon/modules/image/embedded/db/db_images_common.h ++++ b/src/daemon/modules/image/embedded/db/db_images_common.h +@@ -17,6 +17,10 @@ + + #include + ++#ifdef __cplusplus ++extern "C" { ++#endif ++ + /* common interface definition for database */ + + struct db_single_image_info { +@@ -32,5 +36,9 @@ struct db_all_images_info { + struct db_single_image_info **images_info; + }; + ++#ifdef __cplusplus ++} ++#endif ++ + #endif + +diff --git a/src/daemon/modules/image/embedded/db/sqlite_common.h b/src/daemon/modules/image/embedded/db/sqlite_common.h +index 7562932c..8c5db83a 100644 +--- a/src/daemon/modules/image/embedded/db/sqlite_common.h ++++ b/src/daemon/modules/image/embedded/db/sqlite_common.h +@@ -19,6 +19,10 @@ + + #define DBNAME "sqlite.db" + ++#ifdef __cplusplus ++extern "C" { ++#endif ++ + typedef int(*sqlite_callback_t)(void *, int, char **, char **); + + sqlite3 *get_global_db(); +@@ -32,5 +36,9 @@ int db_sqlite_request(const char *stmt); + int db_sqlite_request_callback(const char *stmt, + sqlite_callback_t callback, void *data); + ++#ifdef __cplusplus ++} ++#endif ++ + #endif + +diff --git a/src/daemon/modules/image/embedded/embedded_image.h b/src/daemon/modules/image/embedded/embedded_image.h +index 2177a40b..b1fafacf 100644 +--- a/src/daemon/modules/image/embedded/embedded_image.h ++++ b/src/daemon/modules/image/embedded/embedded_image.h +@@ -18,6 +18,10 @@ + #include + #include "image_api.h" + ++#ifdef __cplusplus ++extern "C" { ++#endif ++ + bool embedded_detect(const char *image_name); + + int embedded_prepare_rf(const im_prepare_request *request, char **real_rootfs); +@@ -48,4 +52,8 @@ int embedded_init(const isulad_daemon_configs *args); + + void embedded_exit(); + ++#ifdef __cplusplus ++} ++#endif ++ + #endif +diff --git a/src/daemon/modules/image/embedded/lim.h b/src/daemon/modules/image/embedded/lim.h +index cb21884e..fb5bb414 100644 +--- a/src/daemon/modules/image/embedded/lim.h ++++ b/src/daemon/modules/image/embedded/lim.h +@@ -22,6 +22,10 @@ + #define IMAGE_DATA_TYPE_CONFIG "config" + #define IMAGE_DATA_TYPE_CONFIG_PATH "config_path" + ++#ifdef __cplusplus ++extern "C" { ++#endif ++ + struct image_creator { + char *name; + char *type; +@@ -56,5 +60,9 @@ int lim_query_image_data(const char *name, const char *type, + int lim_create_rw_layer(char *name, const char *id, char **options, + char **mount_string); + ++#ifdef __cplusplus ++} ++#endif ++ + #endif + +diff --git a/src/daemon/modules/image/embedded/snapshot/embedded.h b/src/daemon/modules/image/embedded/snapshot/embedded.h +index eaf4b588..e0cf7bab 100644 +--- a/src/daemon/modules/image/embedded/snapshot/embedded.h ++++ b/src/daemon/modules/image/embedded/snapshot/embedded.h +@@ -19,6 +19,10 @@ + #include "linked_list.h" + #include "snapshot_def.h" + ++#ifdef __cplusplus ++extern "C" { ++#endif ++ + struct snapshot_plugin ebd_plugin(); + + int ebd_create_layer(char *id, char *parent, uint32_t layer_attribute, +@@ -31,5 +35,9 @@ int ebd_apply_diff(char *id, char *parent, char *archive, char *metadata); + int ebd_generate_mount_string(struct db_image *imginfo, + struct db_sninfo **sninfos, char **mount_string); + ++#ifdef __cplusplus ++} ++#endif ++ + #endif + +diff --git a/src/daemon/modules/image/embedded/snapshot/snapshot.h b/src/daemon/modules/image/embedded/snapshot/snapshot.h +index dd2e42e7..fae6c8da 100644 +--- a/src/daemon/modules/image/embedded/snapshot/snapshot.h ++++ b/src/daemon/modules/image/embedded/snapshot/snapshot.h +@@ -22,11 +22,19 @@ + + #include "db_all.h" + ++#ifdef __cplusplus ++extern "C" { ++#endif ++ + int snapshot_init(uint32_t driver_type); + + int snapshot_generate_mount_string(uint32_t driver_type, + struct db_image *imginfo, + struct db_sninfo **sninfos, char **mount_string); + ++#ifdef __cplusplus ++} ++#endif ++ + #endif + +diff --git a/src/daemon/modules/image/embedded/snapshot/snapshot_def.h b/src/daemon/modules/image/embedded/snapshot/snapshot_def.h +index fbc2c791..eaf397a6 100644 +--- a/src/daemon/modules/image/embedded/snapshot/snapshot_def.h ++++ b/src/daemon/modules/image/embedded/snapshot/snapshot_def.h +@@ -26,6 +26,10 @@ + + #define LAYER_NUM_MAX 125 + ++#ifdef __cplusplus ++extern "C" { ++#endif ++ + typedef int(*create_layer_cb)(char *id, char *parent, uint32_t layer_attribute, + char **options, char **mount_string); + +@@ -44,6 +48,9 @@ struct snapshot_plugin { + generate_mount_string_cb gms; + }; + ++#ifdef __cplusplus ++} ++#endif + + #endif + +diff --git a/src/daemon/modules/image/external/ext_image.h b/src/daemon/modules/image/external/ext_image.h +index ded2b8ca..17ef4d98 100644 +--- a/src/daemon/modules/image/external/ext_image.h ++++ b/src/daemon/modules/image/external/ext_image.h +@@ -26,6 +26,10 @@ + + #include "image_api.h" + ++#ifdef __cplusplus ++extern "C" { ++#endif ++ + bool ext_detect(const char *image_name); + int ext_filesystem_usage(const im_container_fs_usage_request *request, imagetool_fs_info **fs_usage); + +@@ -46,4 +50,8 @@ int ext_logout(const im_logout_request *request); + + int ext_init(const isulad_daemon_configs *args); + ++#ifdef __cplusplus ++} ++#endif ++ + #endif +diff --git a/src/daemon/modules/image/oci/registry_type.h b/src/daemon/modules/image/oci/registry_type.h +index 11135250..bfc77f4a 100644 +--- a/src/daemon/modules/image/oci/registry_type.h ++++ b/src/daemon/modules/image/oci/registry_type.h +@@ -29,6 +29,10 @@ + #define MAX_LAYER_NUM 125 + #define ROOTFS_TYPE "layers" + ++#ifdef __cplusplus ++extern "C" { ++#endif ++ + typedef struct { + char *schema; + char *realm; +@@ -132,4 +136,8 @@ void free_challenge(challenge *c); + void free_layer_blob(layer_blob *layer); + void free_pull_desc(pull_descriptor *desc); + ++#ifdef __cplusplus ++} ++#endif ++ + #endif // DAEMON_MODULES_IMAGE_OCI_REGISTRY_TYPE_H +diff --git a/src/daemon/modules/image/oci/storage/layer_store/graphdriver/devmapper/devices_constants.h b/src/daemon/modules/image/oci/storage/layer_store/graphdriver/devmapper/devices_constants.h +index 5b3db2bd..01bbfef7 100644 +--- a/src/daemon/modules/image/oci/storage/layer_store/graphdriver/devmapper/devices_constants.h ++++ b/src/daemon/modules/image/oci/storage/layer_store/graphdriver/devmapper/devices_constants.h +@@ -35,6 +35,10 @@ + + #define DEFAULT_DEVICE_SET_MODE 0700 + ++#ifdef __cplusplus ++extern "C" { ++#endif ++ + typedef struct { + map_t *map; // map string image_devmapper_device_info* key string will be strdup value ptr will not + } metadata_store_t; +@@ -73,4 +77,8 @@ struct device_set { + bool user_base_size; + }; + ++#ifdef __cplusplus ++} ++#endif ++ + #endif +diff --git a/src/daemon/modules/plugin/pspec.h b/src/daemon/modules/plugin/pspec.h +index 618159b1..0ad26848 100644 +--- a/src/daemon/modules/plugin/pspec.h ++++ b/src/daemon/modules/plugin/pspec.h +@@ -19,6 +19,10 @@ + #include "isula_libutils/oci_runtime_spec.h" + #include "isula_libutils/oci_runtime_pspec.h" + ++#ifdef __cplusplus ++extern "C" { ++#endif ++ + /* + * extract pspec from oci. + * return NULL when failed. oci not modified. +@@ -39,5 +43,9 @@ int set_pspec(oci_runtime_spec *oci, const char *data); + */ + char *merge_pspec(const char *base, const char *data); + ++#ifdef __cplusplus ++} ++#endif ++ + #endif // DAEMON_MODULES_PLUGIN_PSPEC_H + +diff --git a/src/daemon/modules/spec/specs_mount.h b/src/daemon/modules/spec/specs_mount.h +index 07c07a37..3283d92b 100644 +--- a/src/daemon/modules/spec/specs_mount.h ++++ b/src/daemon/modules/spec/specs_mount.h +@@ -26,6 +26,10 @@ + #include "isula_libutils/oci_runtime_hooks.h" + #include "isula_libutils/oci_runtime_spec.h" + ++#ifdef __cplusplus ++extern "C" { ++#endif ++ + int adapt_settings_for_mounts(oci_runtime_spec *oci_spec, container_config *container_spec); + + int merge_conf_mounts(oci_runtime_spec *oci_spec, host_config *host_spec, +@@ -43,4 +47,8 @@ int merge_conf_device(oci_runtime_spec *oci_spec, host_config *host_spec); + + int setup_ipc_dirs(host_config *host_spec, container_config_v2_common_config *v2_spec); + ++#ifdef __cplusplus ++} ++#endif ++ + #endif +diff --git a/src/daemon/modules/spec/specs_security.h b/src/daemon/modules/spec/specs_security.h +index f33814d2..37315a95 100644 +--- a/src/daemon/modules/spec/specs_security.h ++++ b/src/daemon/modules/spec/specs_security.h +@@ -25,6 +25,10 @@ + #include "isula_libutils/container_config_v2.h" + #include "isula_libutils/oci_runtime_spec.h" + ++#ifdef __cplusplus ++extern "C" { ++#endif ++ + int merge_default_seccomp_spec(oci_runtime_spec *oci_spec, const defs_process_capabilities *capabilities); + int merge_caps(oci_runtime_spec *oci_spec, const char **adds, size_t adds_len, const char **drops, size_t drops_len); + int refill_oci_process_capabilities(defs_process_capabilities **caps, const char **src_caps, size_t src_caps_len); +@@ -36,4 +40,8 @@ int merge_seccomp(oci_runtime_spec *oci_spec, const char *seccomp_profile); + int merge_selinux(oci_runtime_spec *oci_spec, container_config_v2_common_config *v2_spec); + #endif + ++#ifdef __cplusplus ++} ++#endif ++ + #endif +diff --git a/src/utils/buffer/buffer.h b/src/utils/buffer/buffer.h +index 168a61f6..83276100 100644 +--- a/src/utils/buffer/buffer.h ++++ b/src/utils/buffer/buffer.h +@@ -19,6 +19,10 @@ + #include + #include + ++#ifdef __cplusplus ++extern "C" { ++#endif ++ + struct Buffer { + char *contents; + size_t bytes_used; +@@ -32,4 +36,8 @@ size_t buffer_strlen(const Buffer *buf); + void buffer_free(Buffer *buf); + int buffer_append(Buffer *buf, const char *append, size_t len); + void buffer_empty(Buffer *buf); ++ ++#ifdef __cplusplus ++} ++#endif + #endif +diff --git a/src/utils/cutils/linked_list.h b/src/utils/cutils/linked_list.h +index 59acb2a8..3a87990a 100644 +--- a/src/utils/cutils/linked_list.h ++++ b/src/utils/cutils/linked_list.h +@@ -17,6 +17,10 @@ + + #include + ++#ifdef __cplusplus ++extern "C" { ++#endif ++ + struct linked_list { + void *elem; + struct linked_list *next; +@@ -122,5 +126,9 @@ static inline size_t linked_list_len(struct linked_list *list) + return i; + } + ++#ifdef __cplusplus ++} ++#endif ++ + #endif + +diff --git a/src/utils/http/parser.h b/src/utils/http/parser.h +index 9a37bd7f..ce5fe5e7 100644 +--- a/src/utils/http/parser.h ++++ b/src/utils/http/parser.h +@@ -55,6 +55,10 @@ + + #define MIN(a, b) ((a) < (b) ? (a) : (b)) + ++#ifdef __cplusplus ++extern "C" { ++#endif ++ + struct parsed_http_message { + enum http_method method; + int status_code; +@@ -88,5 +92,9 @@ int parse_http(const char *buf, size_t len, struct parsed_http_message *m, + enum http_parser_type type); + char *get_header_value(const struct parsed_http_message *m, const char *header); + ++#ifdef __cplusplus ++} ++#endif ++ + #endif + +-- +2.25.1 + diff --git a/0038-feat-add-container-cleanup-module.patch b/0038-feat-add-container-cleanup-module.patch new file mode 100644 index 0000000..0cacb8d --- /dev/null +++ b/0038-feat-add-container-cleanup-module.patch @@ -0,0 +1,589 @@ +From 587aa25d7f44f79c28c3331b81bbc77efb7e1eb1 Mon Sep 17 00:00:00 2001 +From: "Neil.wrz" +Date: Thu, 27 Oct 2022 00:45:53 -0700 +Subject: [PATCH 38/39] feat add container cleanup module + +Signed-off-by: Neil.wrz +--- + src/daemon/modules/api/image_api.h | 6 + + src/daemon/modules/container/CMakeLists.txt | 3 + + src/daemon/modules/container/container_unix.c | 2 + + .../container/leftover_cleanup/CMakeLists.txt | 19 +++ + .../container/leftover_cleanup/cleanup.c | 135 ++++++++++++++++++ + .../container/leftover_cleanup/cleanup.h | 49 +++++++ + .../leftover_cleanup/oci_rootfs_clean.c | 71 +++++++++ + .../leftover_cleanup/oci_rootfs_clean.h | 30 ++++ + src/daemon/modules/image/image.c | 26 ++++ + src/daemon/modules/image/oci/oci_image.c | 5 + + src/daemon/modules/image/oci/oci_image.h | 1 + + .../oci/storage/rootfs_store/rootfs_store.c | 5 + + .../oci/storage/rootfs_store/rootfs_store.h | 3 + + .../modules/image/oci/storage/storage.c | 5 + + .../modules/image/oci/storage/storage.h | 2 + + 15 files changed, 362 insertions(+) + create mode 100644 src/daemon/modules/container/leftover_cleanup/CMakeLists.txt + create mode 100644 src/daemon/modules/container/leftover_cleanup/cleanup.c + create mode 100644 src/daemon/modules/container/leftover_cleanup/cleanup.h + create mode 100644 src/daemon/modules/container/leftover_cleanup/oci_rootfs_clean.c + create mode 100644 src/daemon/modules/container/leftover_cleanup/oci_rootfs_clean.h + +diff --git a/src/daemon/modules/api/image_api.h b/src/daemon/modules/api/image_api.h +index 10fa7b5b..a1c6084a 100644 +--- a/src/daemon/modules/api/image_api.h ++++ b/src/daemon/modules/api/image_api.h +@@ -184,6 +184,10 @@ typedef struct { + char *name_id; + } im_export_request; + ++typedef struct { ++ char *type; ++} im_get_rf_dir_request; ++ + typedef struct { + char *name_id; + bool force; +@@ -325,6 +329,8 @@ int im_container_export(const im_export_request *request); + + void free_im_export_request(im_export_request *ptr); + ++char *im_get_rootfs_dir(const im_get_rf_dir_request *request); ++ + int im_resolv_image_name(const char *image_type, const char *image_name, char **resolved_name); + + container_inspect_graph_driver *im_graphdriver_get_metadata_by_container_id(const char *id); +diff --git a/src/daemon/modules/container/CMakeLists.txt b/src/daemon/modules/container/CMakeLists.txt +index fd2a0b10..def602c7 100644 +--- a/src/daemon/modules/container/CMakeLists.txt ++++ b/src/daemon/modules/container/CMakeLists.txt +@@ -5,6 +5,7 @@ add_subdirectory(supervisor) + add_subdirectory(health_check) + add_subdirectory(container_gc) + add_subdirectory(restart_manager) ++add_subdirectory(leftover_cleanup) + + set(MANAGER_SRCS + ${local_manager_srcs} +@@ -13,6 +14,7 @@ set(MANAGER_SRCS + ${HEALTH_CHECK_SRCS} + ${GC_SRCS} + ${RESTART_MANAGER_SRCS} ++ ${LEFTOVER_CLEANUP_SRCS} + PARENT_SCOPE + ) + +@@ -23,5 +25,6 @@ set(MANAGER_INCS + ${HEALTH_CHECK_INCS} + ${GC_INCS} + ${RESTART_MANAGER_INCS} ++ ${LEFTOVER_CLEANUP_INCS} + PARENT_SCOPE + ) +diff --git a/src/daemon/modules/container/container_unix.c b/src/daemon/modules/container/container_unix.c +index 9910b3c8..88c4bf51 100644 +--- a/src/daemon/modules/container/container_unix.c ++++ b/src/daemon/modules/container/container_unix.c +@@ -46,6 +46,7 @@ + #include "utils_string.h" + #include "volume_api.h" + #include "namespace.h" ++#include "cleanup.h" + + static int parse_container_log_configs(container_t *cont); + +@@ -1278,6 +1279,7 @@ int container_module_init(char **msg) + } + + containers_restore(); ++ clean_leftover(); + + if (start_gchandler()) { + *msg = "Failed to start garbage collecotor handler"; +diff --git a/src/daemon/modules/container/leftover_cleanup/CMakeLists.txt b/src/daemon/modules/container/leftover_cleanup/CMakeLists.txt +new file mode 100644 +index 00000000..225ac38f +--- /dev/null ++++ b/src/daemon/modules/container/leftover_cleanup/CMakeLists.txt +@@ -0,0 +1,19 @@ ++# get current directory sources files ++aux_source_directory(${CMAKE_CURRENT_SOURCE_DIR} local_leftover_cleanup_srcs) ++ ++set(LEFTOVER_CLEANUP_SRCS ++ ${local_leftover_cleanup_srcs} ++ PARENT_SCOPE ++ ) ++ ++set(LEFTOVER_CLEANUP_INCS ++ ${CMAKE_CURRENT_SOURCE_DIR} ++ PARENT_SCOPE ++ ) ++ ++if (DISABLE_OCI) ++ list(REMOVE_ITEM ++ local_leftover_cleanup_srcs ++ ${CMAKE_CURRENT_SOURCE_DIR}/oci_rootfs_clean.c ++ ) ++endif() +\ No newline at end of file +diff --git a/src/daemon/modules/container/leftover_cleanup/cleanup.c b/src/daemon/modules/container/leftover_cleanup/cleanup.c +new file mode 100644 +index 00000000..29fa4bfa +--- /dev/null ++++ b/src/daemon/modules/container/leftover_cleanup/cleanup.c +@@ -0,0 +1,135 @@ ++/****************************************************************************** ++ * Copyright (c) Huawei Technologies Co., Ltd. 2018-2022. All rights reserved. ++ * iSulad licensed under the Mulan PSL v2. ++ * You can use this software according to the terms and conditions of the Mulan PSL v2. ++ * You may obtain a copy of Mulan PSL v2 at: ++ * http://license.coscl.org.cn/MulanPSL2 ++ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR ++ * IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR ++ * PURPOSE. ++ * See the Mulan PSL v2 for more details. ++ * Author: wangrunze ++ * Create: 2022-10-31 ++ * Description: provide cleanup functions ++ *********************************************************************************/ ++#include "utils.h" ++#include "cleanup.h" ++#include "oci_rootfs_clean.h" ++ ++static struct cleaners *create_cleaners() ++{ ++ struct cleaners *ret = NULL; ++ ++ ret = util_common_calloc_s(sizeof(struct cleaners)); ++ if (ret == NULL) { ++ ERROR("Out of memory"); ++ return NULL; ++ } ++ ++ linked_list_init(&(ret->cleaner_list)); ++ ++ return ret; ++} ++ ++static void destroy_cleaners(struct cleaners *clns) ++{ ++ struct linked_list *it = NULL; ++ struct linked_list *next = NULL; ++ struct clean_node *c_node = NULL; ++ ++ linked_list_for_each_safe(it, &(clns->cleaner_list), next) { ++ c_node = (struct clean_node *)it->elem; ++ linked_list_del(it); ++ free(c_node); ++ free(it); ++ it = NULL; ++ } ++ ++ free(clns); ++} ++ ++static int add_clean_node(struct cleaners * clns, clean_func_t f, char * desc) ++{ ++ struct linked_list *new_node = NULL; ++ struct clean_node *c_node = NULL; ++ ++ new_node = util_common_calloc_s(sizeof(struct linked_list)); ++ if (new_node == NULL) { ++ ERROR("Out of memory"); ++ return -1; ++ } ++ ++ c_node = util_common_calloc_s(sizeof(struct clean_node)); ++ if (c_node == NULL) { ++ ERROR("Out of memory"); ++ free(new_node); ++ return -1; ++ } ++ c_node->cleaner = f; ++ c_node->desc = desc; ++ ++ linked_list_add_elem(new_node, c_node); ++ linked_list_add_tail(&(clns->cleaner_list), new_node); ++ clns->count++; ++ ++ return 0; ++} ++ ++static int default_cleaner() ++{ ++ return 0; ++} ++ ++static struct cleaners *cleaner_init() ++{ ++ struct cleaners *clns = create_cleaners(); ++ ++ if (clns == NULL) { ++ return NULL; ++ } ++ ++ add_clean_node(clns, default_cleaner, "default clean"); ++#ifdef ENABLE_OCI_IMAGE ++ add_clean_node(clns, oci_rootfs_cleaner, "clean rootfs"); ++#endif ++ ++ return clns; ++} ++ ++static void do_clean(struct cleaners * clns) ++{ ++ struct linked_list *it = NULL; ++ struct linked_list *next = NULL; ++ struct clean_node *c_node = NULL; ++ int ret = 0; ++ ++ linked_list_for_each_safe(it, &(clns->cleaner_list), next) { ++ c_node = (struct clean_node *)it->elem; ++ if ((ret = c_node->cleaner()) != 0) { ++ ERROR("failed to clean for: %s", c_node->desc); ++ } else { ++ DEBUG("do clean success for: %s", c_node->desc); ++ clns->done_clean++; ++ } ++ } ++} ++ ++void clean_leftover() ++{ ++ struct cleaners *clns = cleaner_init(); ++ ++ if (clns == NULL) { ++ ERROR("failed to clean leftovers, because cleaner init error"); ++ return; ++ } ++ ++ do_clean(clns); ++ ++ if (clns->count == clns->done_clean) { ++ DEBUG("all clean up success"); ++ } else { ++ ERROR("Aim to do %d clean, %d clean sucess\n", clns->count, clns->done_clean); ++ } ++ ++ destroy_cleaners(clns); ++} +\ No newline at end of file +diff --git a/src/daemon/modules/container/leftover_cleanup/cleanup.h b/src/daemon/modules/container/leftover_cleanup/cleanup.h +new file mode 100644 +index 00000000..26fc1b0b +--- /dev/null ++++ b/src/daemon/modules/container/leftover_cleanup/cleanup.h +@@ -0,0 +1,49 @@ ++/****************************************************************************** ++ * Copyright (c) Huawei Technologies Co., Ltd. 2018-2022. All rights reserved. ++ * iSulad licensed under the Mulan PSL v2. ++ * You can use this software according to the terms and conditions of the Mulan PSL v2. ++ * You may obtain a copy of Mulan PSL v2 at: ++ * http://license.coscl.org.cn/MulanPSL2 ++ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR ++ * IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR ++ * PURPOSE. ++ * See the Mulan PSL v2 for more details. ++ * Author: wangrunze ++ * Create: 2022-10-31 ++ * Description: provide cleanup definition ++ *********************************************************************************/ ++#ifndef DAEMON_MODULES_CONTAINER_LEFTOVER_CLEANUP_H ++#define DAEMON_MODULES_CONTAINER_LEFTOVER_CLEANUP_H ++ ++#include ++ ++#include "linked_list.h" ++#include "isula_libutils/log.h" ++ ++#if defined(__cplusplus) || defined(c_plusplus) ++extern "C" { ++#endif ++ ++typedef int clean_func_t(void); ++ ++struct clean_node { ++ char *desc; ++ clean_func_t *cleaner; ++ int error_code; ++}; ++ ++struct cleaners { ++ int count; ++ int done_clean; ++ struct linked_list cleaner_list; ++}; ++ ++ ++void clean_leftover(); ++ ++ ++#if defined(__cplusplus) || defined(c_plusplus) ++} ++#endif ++ ++#endif +\ No newline at end of file +diff --git a/src/daemon/modules/container/leftover_cleanup/oci_rootfs_clean.c b/src/daemon/modules/container/leftover_cleanup/oci_rootfs_clean.c +new file mode 100644 +index 00000000..db56870b +--- /dev/null ++++ b/src/daemon/modules/container/leftover_cleanup/oci_rootfs_clean.c +@@ -0,0 +1,71 @@ ++/****************************************************************************** ++ * Copyright (c) Huawei Technologies Co., Ltd. 2018-2022. All rights reserved. ++ * iSulad licensed under the Mulan PSL v2. ++ * You can use this software according to the terms and conditions of the Mulan PSL v2. ++ * You may obtain a copy of Mulan PSL v2 at: ++ * http://license.coscl.org.cn/MulanPSL2 ++ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR ++ * IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR ++ * PURPOSE. ++ * See the Mulan PSL v2 for more details. ++ * Author: wangrunze ++ * Create: 2022-10-31 ++ * Description: provide rootfs cleaner functions ++ *********************************************************************************/ ++#include ++#include ++#include "oci_rootfs_clean.h" ++#include "container_api.h" ++#include "image_api.h" ++#include "utils_file.h" ++#include "utils.h" ++ ++struct cb_result { ++ int clean_err_cnt; ++}; ++ ++static bool walk_dir_cb(const char *path_name, const struct dirent *sub_dir, void *context) ++{ ++ struct cb_result *result = (struct cb_result *)context; ++ container_t *cont = containers_store_get(sub_dir->d_name); ++ int rm_rootfs_ret = 0; ++ ++ if (cont != NULL) { ++ return true; ++ } ++ ++ INFO("cleaning leftover dir: %s", sub_dir->d_name); ++ rm_rootfs_ret = im_remove_container_rootfs(IMAGE_TYPE_OCI, sub_dir->d_name); ++ if (rm_rootfs_ret != 0) { ++ result->clean_err_cnt++; ++ } ++ ++ return true; ++} ++ ++ ++int oci_rootfs_cleaner(void) ++{ ++ struct cb_result res = { 0 }; ++ im_get_rf_dir_request request = { 0 }; ++ char *rf_dir = NULL; ++ int ret = 0; ++ ++ request.type = IMAGE_TYPE_OCI; ++ rf_dir = im_get_rootfs_dir(&request); ++ if (rf_dir == NULL) { ++ return 0; ++ } ++ ++ ret = util_scan_subdirs(rf_dir, walk_dir_cb, &res); ++ if (ret != 0) { ++ ERROR("failed to scan subdirs"); ++ return -1; ++ } ++ ++ if (res.clean_err_cnt == 0) { ++ return 0; ++ } ++ ++ return -1; ++} +diff --git a/src/daemon/modules/container/leftover_cleanup/oci_rootfs_clean.h b/src/daemon/modules/container/leftover_cleanup/oci_rootfs_clean.h +new file mode 100644 +index 00000000..8dff351f +--- /dev/null ++++ b/src/daemon/modules/container/leftover_cleanup/oci_rootfs_clean.h +@@ -0,0 +1,30 @@ ++/****************************************************************************** ++ * Copyright (c) Huawei Technologies Co., Ltd. 2018-2022. All rights reserved. ++ * iSulad licensed under the Mulan PSL v2. ++ * You can use this software according to the terms and conditions of the Mulan PSL v2. ++ * You may obtain a copy of Mulan PSL v2 at: ++ * http://license.coscl.org.cn/MulanPSL2 ++ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR ++ * IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR ++ * PURPOSE. ++ * See the Mulan PSL v2 for more details. ++ * Author: wangrunze ++ * Create: 2022-10-31 ++ * Description: provide rootfs cleaner definition ++ *********************************************************************************/ ++#ifndef DAEMON_MODULES_CONTAINER_ROOTFS_CLEAN_H ++#define DAEMON_MODULES_CONTAINER_ROOTFS_CLEAN_H ++ ++#include "cleanup.h" ++ ++#if defined(__cplusplus) || defined(c_plusplus) ++extern "C" { ++#endif ++ ++int oci_rootfs_cleaner(void); ++ ++#if defined(__cplusplus) || defined(c_plusplus) ++} ++#endif ++ ++#endif +\ No newline at end of file +diff --git a/src/daemon/modules/image/image.c b/src/daemon/modules/image/image.c +index f487f831..3c395c1f 100644 +--- a/src/daemon/modules/image/image.c ++++ b/src/daemon/modules/image/image.c +@@ -49,6 +49,7 @@ struct bim_ops { + int (*delete_rf)(const im_delete_rootfs_request *request); + int (*export_rf)(const im_export_request *request); + char *(*resolve_image_name)(const char *image_name); ++ char *(*get_dir_rf)(void); + + /* merge image config ops */ + int (*merge_conf)(const char *img_name, container_config *container_spec); +@@ -132,6 +133,7 @@ static const struct bim_ops g_embedded_ops = { + .umount_rf = embedded_umount_rf, + .delete_rf = embedded_delete_rf, + .export_rf = NULL, ++ .get_dir_rf = NULL, + + .merge_conf = embedded_merge_conf, + .get_user_conf = embedded_get_user_conf, +@@ -166,6 +168,7 @@ static const struct bim_ops g_oci_ops = { + .umount_rf = oci_umount_rf, + .delete_rf = oci_delete_rf, + .export_rf = oci_export_rf, ++ .get_dir_rf = oci_get_dir_rf, + + .merge_conf = oci_merge_conf_rf, + .get_user_conf = oci_get_user_conf, +@@ -199,6 +202,7 @@ static const struct bim_ops g_ext_ops = { + .umount_rf = ext_umount_rf, + .delete_rf = ext_delete_rf, + .export_rf = NULL, ++ .get_dir_rf = NULL, + + .merge_conf = ext_merge_conf, + .get_user_conf = ext_get_user_conf, +@@ -1768,6 +1772,28 @@ int im_container_export(const im_export_request *request) + } + #endif + ++#ifdef ENABLE_OCI_IMAGE ++char *im_get_rootfs_dir(const im_get_rf_dir_request *request) { ++ if (request->type == NULL) { ++ ERROR("Missing image type"); ++ return NULL; ++ } ++ ++ struct bim *bim = NULL; ++ bim = bim_get(request->type, NULL, NULL, NULL); ++ if (bim->ops->get_dir_rf == NULL) { ++ ERROR("Unimplemnts get rootfs dir in %s", bim->type); ++ return NULL; ++ } ++ ++ return bim->ops->get_dir_rf(); ++} ++#else ++char *im_get_rootfs_dir(const im_get_rf_dir_request *request) { ++ return NULL; ++} ++#endif ++ + void free_im_export_request(im_export_request *ptr) + { + if (ptr == NULL) { +diff --git a/src/daemon/modules/image/oci/oci_image.c b/src/daemon/modules/image/oci/oci_image.c +index 86828f50..e951adb4 100644 +--- a/src/daemon/modules/image/oci/oci_image.c ++++ b/src/daemon/modules/image/oci/oci_image.c +@@ -686,6 +686,11 @@ int oci_export_rf(const im_export_request *request) + return ret; + } + ++char *oci_get_dir_rf(void) ++{ ++ return storage_rootfs_get_dir(); ++} ++ + int oci_login(const im_login_request *request) + { + int ret = 0; +diff --git a/src/daemon/modules/image/oci/oci_image.h b/src/daemon/modules/image/oci/oci_image.h +index 64a4d8e8..aeeb3b65 100644 +--- a/src/daemon/modules/image/oci/oci_image.h ++++ b/src/daemon/modules/image/oci/oci_image.h +@@ -54,6 +54,7 @@ int oci_mount_rf(const im_mount_request *request); + int oci_umount_rf(const im_umount_request *request); + int oci_delete_rf(const im_delete_rootfs_request *request); + int oci_export_rf(const im_export_request *request); ++char *oci_get_dir_rf(void); + int oci_container_filesystem_usage(const im_container_fs_usage_request *request, imagetool_fs_info **fs_usage); + int oci_login(const im_login_request *request); + int oci_logout(const im_logout_request *request); +diff --git a/src/daemon/modules/image/oci/storage/rootfs_store/rootfs_store.c b/src/daemon/modules/image/oci/storage/rootfs_store/rootfs_store.c +index 378d1a96..0270f6a7 100644 +--- a/src/daemon/modules/image/oci/storage/rootfs_store/rootfs_store.c ++++ b/src/daemon/modules/image/oci/storage/rootfs_store/rootfs_store.c +@@ -1319,3 +1319,8 @@ out: + rootfs_store_unlock(); + return ret; + } ++ ++char *rootfs_store_get_data_dir() ++{ ++ return g_rootfs_store->dir; ++} +\ No newline at end of file +diff --git a/src/daemon/modules/image/oci/storage/rootfs_store/rootfs_store.h b/src/daemon/modules/image/oci/storage/rootfs_store/rootfs_store.h +index e13f97bc..c23af091 100644 +--- a/src/daemon/modules/image/oci/storage/rootfs_store/rootfs_store.h ++++ b/src/daemon/modules/image/oci/storage/rootfs_store/rootfs_store.h +@@ -65,6 +65,9 @@ storage_rootfs *rootfs_store_get_rootfs(const char *id); + // Return a slice enumerating the known containers. + int rootfs_store_get_all_rootfs(struct rootfs_list *all_rootfs); + ++// Return rootfs store data dir ++char *rootfs_store_get_data_dir(); ++ + // Free memory of container store, but will not delete the persisted files + void rootfs_store_free(); + +diff --git a/src/daemon/modules/image/oci/storage/storage.c b/src/daemon/modules/image/oci/storage/storage.c +index 57b5fb80..6cb4a51b 100644 +--- a/src/daemon/modules/image/oci/storage/storage.c ++++ b/src/daemon/modules/image/oci/storage/storage.c +@@ -1868,3 +1868,8 @@ int storage_module_init(struct storage_module_init_options *opts) + out: + return ret; + } ++ ++char *storage_rootfs_get_dir() ++{ ++ return rootfs_store_get_data_dir(); ++} +\ No newline at end of file +diff --git a/src/daemon/modules/image/oci/storage/storage.h b/src/daemon/modules/image/oci/storage/storage.h +index 1fe29b45..5914adec 100644 +--- a/src/daemon/modules/image/oci/storage/storage.h ++++ b/src/daemon/modules/image/oci/storage/storage.h +@@ -181,6 +181,8 @@ char *storage_rootfs_mount(const char *container_id); + + int storage_rootfs_umount(const char *container_id, bool force); + ++char *storage_rootfs_get_dir(); ++ + container_inspect_graph_driver *storage_get_metadata_by_container_id(const char *id); + + #ifdef __cplusplus +-- +2.25.1 + diff --git a/0039-bugfix-for-websocket-receive-data-too-long.patch b/0039-bugfix-for-websocket-receive-data-too-long.patch new file mode 100644 index 0000000..d50baae --- /dev/null +++ b/0039-bugfix-for-websocket-receive-data-too-long.patch @@ -0,0 +1,154 @@ +From 3942fb5667077200017a1a7c72672e482e798df6 Mon Sep 17 00:00:00 2001 +From: zhangxiaoyu +Date: Tue, 1 Nov 2022 14:36:02 +0800 +Subject: [PATCH 39/39] bugfix for websocket receive data too long + +Signed-off-by: zhangxiaoyu +--- + .../entry/cri/websocket/service/ws_server.cc | 65 ++++++++++++++++--- + .../entry/cri/websocket/service/ws_server.h | 5 +- + 2 files changed, 59 insertions(+), 11 deletions(-) + +diff --git a/src/daemon/entry/cri/websocket/service/ws_server.cc b/src/daemon/entry/cri/websocket/service/ws_server.cc +index 41bb3fe8..ea320ff4 100644 +--- a/src/daemon/entry/cri/websocket/service/ws_server.cc ++++ b/src/daemon/entry/cri/websocket/service/ws_server.cc +@@ -126,6 +126,32 @@ void SessionData::CloseSession() + sessionMutex->unlock(); + } + ++bool SessionData::IsStdinComplete() ++{ ++ bool c = true; ++ ++ if (sessionMutex == nullptr) { ++ return true; ++ } ++ ++ sessionMutex->lock(); ++ c = completeStdin; ++ sessionMutex->unlock(); ++ ++ return c; ++} ++ ++void SessionData::SetStdinComplete(bool complete) ++{ ++ if (sessionMutex == nullptr) { ++ return; ++ } ++ ++ sessionMutex->lock(); ++ completeStdin = complete; ++ sessionMutex->unlock(); ++} ++ + void SessionData::EraseAllMessage() + { + if (sessionMutex == nullptr) { +@@ -330,6 +356,7 @@ int WebsocketServer::GenerateSessionData(SessionData *session, const std::string + session->sessionMutex = bufMutex; + session->syncCloseSem = syncCloseSem; + session->close = false; ++ session->completeStdin = true; + session->containerID = containerID; + session->suffix = std::string(suffix); + +@@ -524,28 +551,44 @@ int WebsocketServer::ResizeTerminal(int socketID, const char *jsonData, size_t l + return ret; + } + +-void WebsocketServer::Receive(int socketID, void *in, size_t len) ++void WebsocketServer::Receive(int socketID, void *in, size_t len, bool complete) + { + auto it = m_wsis.find(socketID); + if (it == m_wsis.end()) { +- ERROR("invailed websocket session!"); ++ ERROR("Invailed websocket session!"); + return; + } + ++ if (!it->second->IsStdinComplete()) { ++ DEBUG("Receive remaning stdin data with length %zu", len); ++ // Too much data may cause error 'resource temporarily unavaliable' by using 'write' ++ if (util_write_nointr_in_total(m_wsis[socketID]->pipes.at(1), (char *)in, len) < 0) { ++ ERROR("Sub write over! err msg: %s", strerror(errno)); ++ } ++ goto out; ++ } ++ + if (*static_cast(in) == WebsocketChannel::RESIZECHANNEL) { + if (ResizeTerminal(socketID, (char *)in + 1, len, it->second->containerID, it->second->suffix) != 0) { + ERROR("Failed to resize terminal tty"); +- return; + } +- } else if (*static_cast(in) == WebsocketChannel::STDINCHANNEL) { +- if (write(m_wsis[socketID]->pipes.at(1), (void *)((char *)in + 1), len - 1) < 0) { +- ERROR("sub write over!"); +- return; ++ if (!complete) { ++ ERROR("Resize data too long"); + } +- } else { +- ERROR("invalid data: %s", (char *)in); + return; + } ++ ++ if (*static_cast(in) == WebsocketChannel::STDINCHANNEL) { ++ if (util_write_nointr_in_total(m_wsis[socketID]->pipes.at(1), (char *)in + 1, len - 1) < 0) { ++ ERROR("Sub write over! err msg: %s", strerror(errno)); ++ } ++ goto out; ++ } ++ ++ ERROR("Invalid data: %s", (char *)in); ++ ++out: ++ it->second->SetStdinComplete(complete); + } + + int WebsocketServer::Callback(struct lws *wsi, enum lws_callback_reasons reason, void *user, void *in, size_t len) +@@ -605,7 +648,9 @@ int WebsocketServer::Callback(struct lws *wsi, enum lws_callback_reasons reason, + break; + case LWS_CALLBACK_RECEIVE: { + ReadGuard lock(m_mutex); +- WebsocketServer::GetInstance()->Receive(lws_get_socket_fd(wsi), static_cast(in), len); ++ size_t bytesLen = lws_remaining_packet_payload(wsi); ++ WebsocketServer::GetInstance()->Receive(lws_get_socket_fd(wsi), static_cast(in), ++ len, bytesLen == 0); + } + break; + case LWS_CALLBACK_CLOSED: { +diff --git a/src/daemon/entry/cri/websocket/service/ws_server.h b/src/daemon/entry/cri/websocket/service/ws_server.h +index a2a180ec..7da56818 100644 +--- a/src/daemon/entry/cri/websocket/service/ws_server.h ++++ b/src/daemon/entry/cri/websocket/service/ws_server.h +@@ -44,6 +44,7 @@ struct SessionData { + std::list buffer; + std::string containerID; + std::string suffix; ++ volatile bool completeStdin; + + unsigned char *FrontMessage(); + void PopMessage(); +@@ -51,6 +52,8 @@ struct SessionData { + bool IsClosed(); + void CloseSession(); + void EraseAllMessage(); ++ bool IsStdinComplete(); ++ void SetStdinComplete(bool complete); + }; + + class WebsocketServer { +@@ -72,7 +75,7 @@ private: + std::vector split(std::string str, char r); + + int CreateContext(); +- inline void Receive(int socketID, void *in, size_t len); ++ inline void Receive(int socketID, void *in, size_t len, bool complete); + int Wswrite(struct lws *wsi, const unsigned char *message); + inline void DumpHandshakeInfo(struct lws *wsi) noexcept; + int RegisterStreamTask(struct lws *wsi) noexcept; +-- +2.25.1 + diff --git a/iSulad.spec b/iSulad.spec index f5d1422..c8e6840 100644 --- a/iSulad.spec +++ b/iSulad.spec @@ -1,5 +1,5 @@ %global _version 2.0.17 -%global _release 4 +%global _release 5 %global is_systemd 1 %global enable_shimv2 1 %global is_embedded 1 @@ -19,6 +19,39 @@ Patch0003: 0003-refactor-build-system-of-cutils-ut.patch Patch0004: 0004-run-storage-layers-ut-with-non-root.patch Patch0005: 0005-add-extern-C-for-mainloop-header.patch Patch0006: 0006-add-UT-for-mainloop-and-network.patch +Patch0007: 0007-add-check-for-aes-apis.patch +Patch0008: 0008-add-ut-for-cutils-aes.patch +Patch0009: 0009-add-ut-for-cutils-error.patch +Patch0010: 0010-ensure-argument-is-not-null.patch +Patch0011: 0011-add-ut-for-utils_fs.patch +Patch0012: 0012-Add-adaptation-code-for-filters.patch +Patch0013: 0013-Add-parameter-check-to-path.patch +Patch0014: 0014-Add-ut-for-utils_convert.patch +Patch0015: 0015-Add-ut-for-path.patch +Patch0016: 0016-Add-ut-for-filters.patch +Patch0017: 0017-add-static-for-unexport-function.patch +Patch0018: 0018-add-ut-for-cutils-timestamp.patch +Patch0019: 0019-fix-timestamp-ut-error.patch +Patch0020: 0020-improve-code-in-utils_mount_spec.patch +Patch0021: 0021-Add-ut-for-utils_mount_spec.patch +Patch0022: 0022-Add-ut-for-utils_regex.patch +Patch0023: 0023-improve-code-in-utils.c.patch +Patch0024: 0024-add-ut-for-cutils-utils.patch +Patch0025: 0025-make-sure-kill-pid-not-negative.patch +Patch0026: 0026-add-UT-for-atomic-and-map.patch +Patch0027: 0027-remove-unnecessary-goto-and-add-parameter-check-for-.patch +Patch0028: 0028-Add-ut-for-verify.patch +Patch0029: 0029-fix-error-in-utils_verify_ut.patch +Patch0030: 0030-add-more-test-for-string-and-map.patch +Patch0031: 0031-remove-mnt-point-if-add-device-mapper-device-failed.patch +Patch0032: 0032-dec-device-info-ref-in-grow-device-fs.patch +Patch0033: 0033-device-mapper-bugfix.patch +Patch0034: 0034-delete-syncCloseSem-when-close-all-wssession.patch +Patch0035: 0035-improve-debug-information-for-console-io.patch +Patch0036: 0036-add-ut-for-file.patch +Patch0037: 0037-Add-extend-C-for-header-files.patch +Patch0038: 0038-feat-add-container-cleanup-module.patch +Patch0039: 0039-bugfix-for-websocket-receive-data-too-long.patch %ifarch x86_64 aarch64 Provides: libhttpclient.so()(64bit) @@ -245,6 +278,12 @@ fi %endif %changelog +* Tue Nov 01 2022 zhangxiaoyu - 2.0.17-5 +- Type: enhancement +- ID: NA +- SUG: NA +- DESC: add ut and bugfix for device mapper and websocket + * Mon Oct 31 2022 wujing - 2.0.17-4 - Type: enhancement - ID: NA