!10861 ST2

Merge pull request !10861 from 80174847/ST2

.gitignore

@@ -196,7 +196,7 @@ install_manifest.txt
 compile_commands.json
 CTestTestfile.cmake
 _deps
-#CMakeSettings.json
+CMakeSettings.json
 CMakePresets.json
 /Other/libimageproc/RCa15420
 /cpp.hint

CMakeLists.txt

@@ -24,6 +24,7 @@ cmake_minimum_required (VERSION 3.8)
 project(RvcTerminalApp)
 
 set(CMAKE_CXX_STANDARD 11)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
 #  Include extend cmake scripts
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${CMAKE_SOURCE_DIR}/addin/cmake/ )
@@ -65,8 +66,6 @@ set(DEVOPS_ON_CMAKE_UAT FALSE)
 set(DEVOPS_ON_CMAKE_DEV FALSE)
 set(DEVOPS_ON_CMAKE_PRD FALSE)
 set(COMPILED_ENV_TYPE 0)
-#only build devadapter flag
-set(ONLY_BUILD_DEVADAPTER FALSE)
 if(MSVC)
 	set(TARGET_PLATFORM Windows)
 else()
@@ -100,6 +99,15 @@ endif($ENV{PIPELINE_BUILD_ID})
 
 #Set the project(terminal) version
 set(RAW_VERSION_STRING "7.5.1-rc1")
+
+
+if(NOT DEVOPS_ON)
+	if(WITH_GITFUR_LOCALCP)
+		set(RAW_VERSION_STRING "8.5.1-rc1")
+	endif(WITH_GITFUR_LOCALCP)
+endif(NOT DEVOPS_ON)
+
+
 string(STRIP ${RAW_VERSION_STRING} RAW_VERSION_STRING)
 
 set(VERSION_REGEX "^.?([0-9]+)\\.([0-9]+)\\.([0-9]+)-?(.*)")
@@ -168,13 +176,6 @@ if(DEVOPS_ON)
 		set(BUILD_NUMBER ${RVC_DEV_NUM})
 	endif(DEFINED ENV{ENV_VER_Build})
 
-	if(DEFINED ENV{ONLY_DEVADAPTER})
-		if($ENV{ONLY_DEVADAPTER})
-			set(ONLY_BUILD_DEVADAPTER TRUE)
-			message(WARN "only build devadapter")
-		endif($ENV{ONLY_DEVADAPTER})
-	endif(DEFINED ENV{ONLY_DEVADAPTER})
-
 	if(DEVOPS_ON_CMAKE_PRD)
 		set(RVC_VERSION_SUFFIX "PRD")
 		if(PACK_AS_DEB_PKG)
@@ -215,13 +216,6 @@ else()
 endif(RVC_VERSION_SUFFIX)
 set(PACK_VERSION_NAME "${RVC_VERSION_FULL}")
 
-if(ONLY_BUILD_DEVADAPTER)
-	set(BUILD_COREFRAMEWORK OFF)
-	set(BUILD_MODULE OFF)
-	set(BUILD_TOOLS OFF)
-	set(BUILD_DEVADAPTER ON)
-endif(ONLY_BUILD_DEVADAPTER)
-
 if(NOT DEFINED BUILD_SHARED_LIBS)
 	set(BUILD_SHARED_LIBS ON)
 endif()
@@ -390,6 +384,9 @@ if(MSVC)
 	add_compile_options("$<$<CXX_COMPILER_ID:MSVC>:/execution-charset:gbk>")
 	add_compile_options("$<$<C_COMPILER_ID:MSVC>:/execution-charset:gbk>")
 
+else()
+	add_compile_options("-Wno-unused-function")
+	#add_compile_options("-Werror=implicit-function-declaration")
 endif(MSVC)
 
 # Enable 64bit file support on linux and FreeBSD.
@@ -546,11 +543,11 @@ endif(WIN32)
 if(MSVC)
 	# Force to always compile with W4
 	if(CMAKE_CXX_FLAGS MATCHES "/W[0-4]")
-	string(REGEX REPLACE "/W[0-4]" "/W4" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+		string(REGEX REPLACE "/W[0-4]" "/W4" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
 	else()
-	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W4")
+		set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W4")
 	endif()
-
+	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /wd4505")
 	set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /Zi")
 	set(CMAKE_EXE_LINKER_FLAGS_RELEASE "${CMAKE_EXE_LINKER_FLAGS_RELEASE} /DEBUG /OPT:REF /OPT:ICF")
 	set(CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} /DEBUG /OPT:REF /OPT:ICF")
@@ -675,43 +672,38 @@ else(MSVC)
 	endif()
 
 	if(NOT DEVOPS_ON)
-		install(CODE "execute_process(COMMAND chmod 0777 ${CMAKE_SOURCE_DIR}/addin/packaging/UOS/kill.sh)")
-		install(CODE "execute_process(COMMAND bash ${CMAKE_SOURCE_DIR}/addin/packaging/UOS/kill.sh)")
+		if(NOT WITH_GITFUR_LOCALCP)
+			install(CODE "execute_process(COMMAND chmod 0777 ${CMAKE_SOURCE_DIR}/addin/packaging/UOS/kill.sh)")
+			install(CODE "execute_process(COMMAND bash ${CMAKE_SOURCE_DIR}/addin/packaging/UOS/kill.sh)")
+		endif(NOT WITH_GITFUR_LOCALCP)
 	endif(NOT DEVOPS_ON)
 
 	install(CODE "execute_process(COMMAND 'chmod 0777 ${CMAKE_SOURCE_DIR}/addin/packaging/DEBIAN/*')")
 
 endif(MSVC)
 
+install(FILES "${CMAKE_SOURCE_DIR}/addin/assets/VTM.ico"
+	"${CMAKE_SOURCE_DIR}/addin/packaging/DEBIAN/WallPaper1920.png"
+	DESTINATION "${PACK_INSTALL_RVC_DIR}/Resources" COMPONENT resources)
 
-if(NOT ONLY_BUILD_DEVADAPTER)
-
-	install(FILES "${CMAKE_SOURCE_DIR}/addin/assets/VTM.ico"
-		"${CMAKE_SOURCE_DIR}/addin/packaging/DEBIAN/WallPaper1920.png"
-		DESTINATION "${PACK_INSTALL_RVC_DIR}/Resources" COMPONENT resources)
-
-	install(FILES "${CMAKE_SOURCE_DIR}/addin/assets/VTM.ico"
-		"${CMAKE_SOURCE_DIR}/addin/packaging/DEBIAN/WallPaper1920.png"
-		DESTINATION "${PACK_INSTALL_PREFIX_CUR_VER}/res/Media" COMPONENT resources)
+install(FILES "${CMAKE_SOURCE_DIR}/addin/assets/VTM.ico"
+	"${CMAKE_SOURCE_DIR}/addin/packaging/DEBIAN/WallPaper1920.png"
+	DESTINATION "${PACK_INSTALL_PREFIX_CUR_VER}/res/Media" COMPONENT resources)
 
-	if(MSVC)
+if(MSVC)
 		
-	else()
-		install(FILES "${CMAKE_SOURCE_DIR}/addin/packaging/DEBIAN/spexplorerauto.desktop"
-			DESTINATION "${PACK_INSTALL_RVC_DIR}/Resources" COMPONENT resources)
-	endif(MSVC)
-
-	file(GLOB ENTITY_INTERFACE_XML_FILES "${MODULE_BASE_DIR}/mod_*/*.xml")
-	install(FILES ${ENTITY_INTERFACE_XML_FILES} DESTINATION "${PACK_INSTALL_PREFIX_CUR_VER}/res/StructConfig" COMPONENT resources)
-
-	file(GLOB RVC_RESOURCE_FILES LIST_DIRECTORIES FALSE "${CMAKE_SOURCE_DIR}/addin/assets/*")
-	install(FILES ${RVC_RESOURCE_FILES} DESTINATION ${RVC_RUNTIME_PATH} COMPONENT resources)
-
-endif(NOT ONLY_BUILD_DEVADAPTER)
+else()
+	install(FILES "${CMAKE_SOURCE_DIR}/addin/packaging/DEBIAN/spexplorerauto.desktop"
+		DESTINATION "${PACK_INSTALL_RVC_DIR}/Resources" COMPONENT resources)
+endif(MSVC)
 
+file(GLOB ENTITY_INTERFACE_XML_FILES "${MODULE_BASE_DIR}/mod_*/*.xml")
+install(FILES ${ENTITY_INTERFACE_XML_FILES} DESTINATION "${PACK_INSTALL_PREFIX_CUR_VER}/res/StructConfig" COMPONENT resources)
 
+file(GLOB RVC_RESOURCE_FILES LIST_DIRECTORIES FALSE "${CMAKE_SOURCE_DIR}/addin/assets/*")
+install(FILES ${RVC_RESOURCE_FILES} DESTINATION ${RVC_RUNTIME_PATH} COMPONENT resources)
 
-if(MSVC AND NOT ONLY_BUILD_DEVADAPTER)
+if(MSVC)
 	if(MSVC_RUNTIME STREQUAL "dynamic")
 		# the INSTALL command is not called. The user can use the variable 
 		# CMAKE_INSTALL_SYSTEM_RUNTIME_LIBS to use a custom install command and install them however they want.
@@ -740,106 +732,101 @@ if(DEVOPS_ON)
 	endif(DEVOPS_ON_CMAKE_PRD)
 endif(DEVOPS_ON)
 
-if(NOT ONLY_BUILD_DEVADAPTER)
-	if(MSVC)
-		configure_file("${CMAKE_SOURCE_DIR}/addin/packaging/WIN/installbat.in" "${CMAKE_BINARY_DIR}/install.bat" @ONLY NEWLINE_STYLE CRLF)
-		install(PROGRAMS "${CMAKE_BINARY_DIR}/install.bat" DESTINATION "${PACK_INSTALL_RUN_DIR}/./.." COMPONENT scripts)
-		install(FILES "${CMAKE_SOURCE_DIR}/addin/packaging/WIN/Readme.txt" DESTINATION "${PACK_INSTALL_RUN_DIR}/./.." COMPONENT scripts)
-		if(NOT DEVOPS_ON_CMAKE_PRD)
-			install(PROGRAMS "${CMAKE_SOURCE_DIR}/addin/packaging/WIN/kill.bat" DESTINATION ${RVC_BASE_PATH} COMPONENT scripts)
-			install(PROGRAMS "${CMAKE_SOURCE_DIR}/addin/packaging/WIN/test.vbs" DESTINATION ${RVC_BASE_PATH} COMPONENT scripts)
-		endif(NOT DEVOPS_ON_CMAKE_PRD)
-	else(MSVC)
-		install(PROGRAMS "${CMAKE_SOURCE_DIR}/addin/startup_scripts/spexplorer.sh" DESTINATION "${RVC_BASE_PATH}" COMPONENT scripts)
-		if(NOT DEVOPS_ON_CMAKE_PRD)
-			install(PROGRAMS "${CMAKE_SOURCE_DIR}/addin/packaging/UOS/kill.sh" DESTINATION ${RVC_BASE_PATH} COMPONENT scripts)
-			install(PROGRAMS "${CMAKE_SOURCE_DIR}/addin/packaging/UOS/test.sh" DESTINATION ${RVC_BASE_PATH} COMPONENT scripts)
-		endif(NOT DEVOPS_ON_CMAKE_PRD)
-		configure_file("${CMAKE_SOURCE_DIR}/addin/packaging/UOS/installsub.in" "${CMAKE_BINARY_DIR}/installsub.sh" @ONLY NEWLINE_STYLE UNIX)
-		install(PROGRAMS "${CMAKE_BINARY_DIR}/installsub.sh" DESTINATION "${PACK_INSTALL_RVC_DIR}/Resources" COMPONENT scripts)
-
-		install(PROGRAMS "${CMAKE_SOURCE_DIR}/addin/packaging/UOS/install.sh" DESTINATION "${PACK_INSTALL_RUN_DIR}/./.." COMPONENT scripts)
-		install(FILES "${CMAKE_SOURCE_DIR}/addin/packaging/UOS/Readme.txt" DESTINATION "${PACK_INSTALL_RUN_DIR}/./.." COMPONENT scripts)
-		install(PROGRAMS "${CMAKE_SOURCE_DIR}/addin/startup_scripts/spshellstart.sh" DESTINATION "${RVC_RUNTIME_PATH}" COMPONENT scripts)
-	endif(MSVC)
-
-	if(NOT DEVOPS_ON)
-		install(FILES "${CMAKE_SOURCE_DIR}/addin/hardwarecfg/${ROOT_INI_NAME}" 
-			DESTINATION "${PACK_INSTALL_RUN_DIR}/hardwarecfg" 
-			RENAME "root.ini"
-			COMPONENT scripts)
-	endif(NOT DEVOPS_ON)
+if(MSVC)
+	configure_file("${CMAKE_SOURCE_DIR}/addin/packaging/WIN/installbat.in" "${CMAKE_BINARY_DIR}/install.bat" @ONLY NEWLINE_STYLE CRLF)
+	install(PROGRAMS "${CMAKE_BINARY_DIR}/install.bat" DESTINATION "${PACK_INSTALL_RUN_DIR}/./.." COMPONENT scripts)
+	install(FILES "${CMAKE_SOURCE_DIR}/addin/packaging/WIN/Readme.txt" DESTINATION "${PACK_INSTALL_RUN_DIR}/./.." COMPONENT scripts)
+	if(NOT DEVOPS_ON_CMAKE_PRD)
+		install(PROGRAMS "${CMAKE_SOURCE_DIR}/addin/packaging/WIN/kill.bat" DESTINATION ${RVC_BASE_PATH} COMPONENT scripts)
+		install(PROGRAMS "${CMAKE_SOURCE_DIR}/addin/packaging/WIN/test.vbs" DESTINATION ${RVC_BASE_PATH} COMPONENT scripts)
+	endif(NOT DEVOPS_ON_CMAKE_PRD)
+else(MSVC)
+	install(PROGRAMS "${CMAKE_SOURCE_DIR}/addin/startup_scripts/spexplorer.sh" DESTINATION "${RVC_BASE_PATH}" COMPONENT scripts)
+	if(NOT DEVOPS_ON_CMAKE_PRD)
+		install(PROGRAMS "${CMAKE_SOURCE_DIR}/addin/packaging/UOS/kill.sh" DESTINATION ${RVC_BASE_PATH} COMPONENT scripts)
+		install(PROGRAMS "${CMAKE_SOURCE_DIR}/addin/packaging/UOS/test.sh" DESTINATION ${RVC_BASE_PATH} COMPONENT scripts)
+	endif(NOT DEVOPS_ON_CMAKE_PRD)
+	configure_file("${CMAKE_SOURCE_DIR}/addin/packaging/UOS/installsub.in" "${CMAKE_BINARY_DIR}/installsub.sh" @ONLY NEWLINE_STYLE UNIX)
+	install(PROGRAMS "${CMAKE_BINARY_DIR}/installsub.sh" DESTINATION "${PACK_INSTALL_RVC_DIR}/Resources" COMPONENT scripts)
+
+	install(PROGRAMS "${CMAKE_SOURCE_DIR}/addin/packaging/UOS/install.sh" DESTINATION "${PACK_INSTALL_RUN_DIR}/./.." COMPONENT scripts)
+	install(FILES "${CMAKE_SOURCE_DIR}/addin/packaging/UOS/Readme.txt" DESTINATION "${PACK_INSTALL_RUN_DIR}/./.." COMPONENT scripts)
+	install(PROGRAMS "${CMAKE_SOURCE_DIR}/addin/startup_scripts/spshellstart.sh" DESTINATION "${RVC_RUNTIME_PATH}" COMPONENT scripts)
+endif(MSVC)
 
-	install(DIRECTORY "${CMAKE_SOURCE_DIR}/addin/cfg" DESTINATION "${PACK_INSTALL_PREFIX_CUR_VER}" 
-		COMPONENT scripts FILES_MATCHING PATTERN "*.ini")
-	install(DIRECTORY "${CMAKE_SOURCE_DIR}/addin/cfg" DESTINATION "${PACK_INSTALL_PREFIX_CUR_VER}" 
-		COMPONENT scripts FILES_MATCHING PATTERN "*.xml")
-	install(FILES ${CMAKE_BINARY_DIR}/env.ini DESTINATION ${RVC_CONFIG_PATH} COMPONENT scripts)
-
-	install(DIRECTORY "${CMAKE_SOURCE_DIR}/addin/res" DESTINATION "${PACK_INSTALL_PREFIX_CUR_VER}" COMPONENT scripts)
-	file(GLOB RUN_SCRIPTS_FILES LIST_DIRECTORIES true "${CMAKE_SOURCE_DIR}/addin/res/RunScript/*")
-	foreach(item ${RUN_SCRIPTS_FILES})
-			install(FILES ${item} DESTINATION "${PACK_INSTALL_PREFIX_CUR_VER}/res/RunScript" 
-			PERMISSIONS OWNER_EXECUTE OWNER_WRITE OWNER_READ GROUP_EXECUTE GROUP_READ WORLD_READ WORLD_EXECUTE
-			COMPONENT scripts)
-	endforeach()
-endif(NOT ONLY_BUILD_DEVADAPTER)
+if(NOT DEVOPS_ON)
+	install(FILES "${CMAKE_SOURCE_DIR}/addin/hardwarecfg/${ROOT_INI_NAME}" 
+		DESTINATION "${PACK_INSTALL_RUN_DIR}/hardwarecfg" 
+		RENAME "root.ini"
+		COMPONENT scripts)
+endif(NOT DEVOPS_ON)
+
+install(DIRECTORY "${CMAKE_SOURCE_DIR}/addin/cfg" DESTINATION "${PACK_INSTALL_PREFIX_CUR_VER}" 
+	COMPONENT scripts FILES_MATCHING PATTERN "*.ini")
+install(DIRECTORY "${CMAKE_SOURCE_DIR}/addin/cfg" DESTINATION "${PACK_INSTALL_PREFIX_CUR_VER}" 
+	COMPONENT scripts FILES_MATCHING PATTERN "*.xml")
+install(FILES ${CMAKE_BINARY_DIR}/env.ini DESTINATION ${RVC_CONFIG_PATH} COMPONENT scripts)
+
+install(DIRECTORY "${CMAKE_SOURCE_DIR}/addin/res" DESTINATION "${PACK_INSTALL_PREFIX_CUR_VER}" COMPONENT scripts)
+file(GLOB RUN_SCRIPTS_FILES LIST_DIRECTORIES true "${CMAKE_SOURCE_DIR}/addin/res/RunScript/*")
+foreach(item ${RUN_SCRIPTS_FILES})
+		install(FILES ${item} DESTINATION "${PACK_INSTALL_PREFIX_CUR_VER}/res/RunScript" 
+		PERMISSIONS OWNER_EXECUTE OWNER_WRITE OWNER_READ GROUP_EXECUTE GROUP_READ WORLD_READ WORLD_EXECUTE
+		COMPONENT scripts)
+endforeach()
 
 list(REMOVE_DUPLICATES RVC_CONAN_DEP_LIBS)
 
-
-if(NOT ONLY_BUILD_DEVADAPTER)
-	if(MSVC)
-		if(CONAN_BIN_DIRS_CEFCLIENT_MUTABLE)
-			message(STATUS "remove cefclient dirs")
-			list(REMOVE_ITEM RVC_CONAN_DEP_LIBS ${CONAN_BIN_DIRS_CEFCLIENT_MUTABLE})
-			file(GLOB RVC_CHROMIUM_BIN_FILES LIST_DIRECTORIES true "${CONAN_BIN_DIRS_CEFCLIENT_MUTABLE}/Chromium/*")
-			foreach(item ${RVC_CHROMIUM_BIN_FILES})
-				if(IS_DIRECTORY ${item})
-					install(DIRECTORY "${item}" DESTINATION "${RVC_CHROMIUM_PATH}" COMPONENT libraries )
-				else()
-					install(FILES ${item} DESTINATION "${RVC_CHROMIUM_PATH}" 
-					PERMISSIONS OWNER_EXECUTE OWNER_WRITE OWNER_READ GROUP_EXECUTE GROUP_READ WORLD_READ WORLD_EXECUTE
-					COMPONENT libraries)
-				endif()
-			endforeach()
-		endif(CONAN_BIN_DIRS_CEFCLIENT_MUTABLE)
-		if(CONAN_BIN_DIRS_CEFCLIENT_CONST)
-			message(STATUS "remove cefclient dirs")
-			list(REMOVE_ITEM RVC_CONAN_DEP_LIBS ${CONAN_BIN_DIRS_CEFCLIENT_CONST})
-			file(GLOB RVC_CHROMIUM_BIN_FILES LIST_DIRECTORIES true "${CONAN_BIN_DIRS_CEFCLIENT_CONST}/Chromium/*")
-			foreach(item ${RVC_CHROMIUM_BIN_FILES})
-				if(IS_DIRECTORY ${item})
-					install(DIRECTORY "${item}" DESTINATION "${RVC_CHROMIUM_PATH}" COMPONENT libraries )
-				else()
-					install(FILES ${item} DESTINATION "${RVC_CHROMIUM_PATH}" 
-					PERMISSIONS OWNER_EXECUTE OWNER_WRITE OWNER_READ GROUP_EXECUTE GROUP_READ WORLD_READ WORLD_EXECUTE
-					COMPONENT libraries)
-				endif()
-			endforeach()
-		endif(CONAN_BIN_DIRS_CEFCLIENT_CONST)
-		if(CONAN_BIN_DIRS_RUNTIMEBASE)
-			message(STATUS "install runtime base files")
-			file(GLOB RVC_RUNTIME_FILES LIST_DIRECTORIES true "${CONAN_BIN_DIRS_RUNTIMEBASE}/*")
-			install(PROGRAMS ${RVC_RUNTIME_FILES} DESTINATION "${RVC_RUNTIME_PATH}" COMPONENT libraries)
-			#${PACK_INSTALL_RUNTIME_DIR}
-			#RVC_RUNTIME_PATH
-		endif(CONAN_BIN_DIRS_RUNTIMEBASE)
-	endif(MSVC)
-
-	foreach(bin_dir ${RVC_CONAN_DEP_LIBS})
-		message(STATUS "bin dir: ${bin_dir}")
-		# file(GLOB RVC_CONAN_BIN_FILES  LIST_DIRECTORIES false "${bin_dir}/*.so" "${bin_dir}/*.dll")
-		file(GLOB RVC_CONAN_BIN_FILES LIST_DIRECTORIES false "${bin_dir}/*")
-		foreach(filter_elem ${AARCH64_USELESS_LIBRARY_FILE_NAMES})
-			set(filter_args ".*\\${filter_elem}$")
-			list(FILTER RVC_CONAN_BIN_FILES EXCLUDE REGEX ${filter_args})
+if(MSVC)
+	if(CONAN_BIN_DIRS_CEFCLIENT_MUTABLE)
+		message(STATUS "remove cefclient dirs")
+		list(REMOVE_ITEM RVC_CONAN_DEP_LIBS ${CONAN_BIN_DIRS_CEFCLIENT_MUTABLE})
+		file(GLOB RVC_CHROMIUM_BIN_FILES LIST_DIRECTORIES true "${CONAN_BIN_DIRS_CEFCLIENT_MUTABLE}/Chromium/*")
+		foreach(item ${RVC_CHROMIUM_BIN_FILES})
+			if(IS_DIRECTORY ${item})
+				install(DIRECTORY "${item}" DESTINATION "${RVC_CHROMIUM_PATH}" COMPONENT libraries )
+			else()
+				install(FILES ${item} DESTINATION "${RVC_CHROMIUM_PATH}" 
+				PERMISSIONS OWNER_EXECUTE OWNER_WRITE OWNER_READ GROUP_EXECUTE GROUP_READ WORLD_READ WORLD_EXECUTE
+				COMPONENT libraries)
+			endif()
 		endforeach()
-		list(FILTER RVC_CONAN_BIN_FILES EXCLUDE REGEX ".*\\.a$")
-		list(FILTER RVC_CONAN_BIN_FILES EXCLUDE REGEX ".*\\.lib$")
-		install(PROGRAMS ${RVC_CONAN_BIN_FILES} DESTINATION "${RVC_RUNTIME_PATH}" COMPONENT libraries)
+	endif(CONAN_BIN_DIRS_CEFCLIENT_MUTABLE)
+	if(CONAN_BIN_DIRS_CEFCLIENT_CONST)
+		message(STATUS "remove cefclient dirs")
+		list(REMOVE_ITEM RVC_CONAN_DEP_LIBS ${CONAN_BIN_DIRS_CEFCLIENT_CONST})
+		file(GLOB RVC_CHROMIUM_BIN_FILES LIST_DIRECTORIES true "${CONAN_BIN_DIRS_CEFCLIENT_CONST}/Chromium/*")
+		foreach(item ${RVC_CHROMIUM_BIN_FILES})
+			if(IS_DIRECTORY ${item})
+				install(DIRECTORY "${item}" DESTINATION "${RVC_CHROMIUM_PATH}" COMPONENT libraries )
+			else()
+				install(FILES ${item} DESTINATION "${RVC_CHROMIUM_PATH}" 
+				PERMISSIONS OWNER_EXECUTE OWNER_WRITE OWNER_READ GROUP_EXECUTE GROUP_READ WORLD_READ WORLD_EXECUTE
+				COMPONENT libraries)
+			endif()
+		endforeach()
+	endif(CONAN_BIN_DIRS_CEFCLIENT_CONST)
+	if(CONAN_BIN_DIRS_RUNTIMEBASE)
+		message(STATUS "install runtime base files")
+		file(GLOB RVC_RUNTIME_FILES LIST_DIRECTORIES true "${CONAN_BIN_DIRS_RUNTIMEBASE}/*")
+		install(PROGRAMS ${RVC_RUNTIME_FILES} DESTINATION "${RVC_RUNTIME_PATH}" COMPONENT libraries)
+		#${PACK_INSTALL_RUNTIME_DIR}
+		#RVC_RUNTIME_PATH
+	endif(CONAN_BIN_DIRS_RUNTIMEBASE)
+endif(MSVC)
+
+foreach(bin_dir ${RVC_CONAN_DEP_LIBS})
+	message(STATUS "bin dir: ${bin_dir}")
+	# file(GLOB RVC_CONAN_BIN_FILES  LIST_DIRECTORIES false "${bin_dir}/*.so" "${bin_dir}/*.dll")
+	file(GLOB RVC_CONAN_BIN_FILES LIST_DIRECTORIES false "${bin_dir}/*")
+	foreach(filter_elem ${AARCH64_USELESS_LIBRARY_FILE_NAMES})
+		set(filter_args ".*\\${filter_elem}$")
+		list(FILTER RVC_CONAN_BIN_FILES EXCLUDE REGEX ${filter_args})
 	endforeach()
-endif(NOT ONLY_BUILD_DEVADAPTER)
+	list(FILTER RVC_CONAN_BIN_FILES EXCLUDE REGEX ".*\\.a$")
+	list(FILTER RVC_CONAN_BIN_FILES EXCLUDE REGEX ".*\\.lib$")
+	install(PROGRAMS ${RVC_CONAN_BIN_FILES} DESTINATION "${RVC_RUNTIME_PATH}" COMPONENT libraries)
+endforeach()
 
 #pdb save
 if(WITH_PDB_SAVEV2)
@@ -904,10 +891,7 @@ GET_CMAKE_PROPERTY(CPACK_COMPONENTS_ALL COMPONENTS)
 FOREACH(item ${CPACK_COMPONENTS_ALL})
 	message(STATUS "component: ${item}")
 ENDFOREACH()
-if(ONLY_BUILD_DEVADAPTER)
-	#set(CMAKE_INSTALL_DEFAULT_COMPONENT_NAME)
-	list(REMOVE_ITEM CPACK_COMPONENTS_ALL "resources")
-endif(ONLY_BUILD_DEVADAPTER)
+
 list(REMOVE_ITEM CPACK_COMPONENTS_ALL "headers" "tools" "symbols")
 set_property(GLOBAL PROPERTY COMPONENTS ${CPACK_COMPONENTS_ALL})
 GET_CMAKE_PROPERTY(CPACK_COMPONENTS_ALL  COMPONENTS)

DevAdapter/simulator/deps/libSimulaRestful/JsonConvertHelper.hpp

@@ -32,16 +32,6 @@ static int StrBuf2HexBuf(const char* strBuf, PBYTE* hexBuf)
     *hexBuf = buf;
     return j;
 }
-static int HexBuf2StrBuf(PBYTE hexBuf, char** strBuf, DWORD len)
-{
-    char* tmpStr = *strBuf;
-    DWORD count = 0;
-    for (DWORD i = 0; i < len; ++i) {
-        sprintf(tmpStr + count, "%0.2X", hexBuf[i]);
-        count += 2;
-    }
-    return 0;
-}
 
 #define JSONCONVERT2OBJECT_MEMEBER_REGISTER(...)  \
 bool JSONCONVERT2OBJECT_MEMEBER_REGISTER_RESERVERD_IMPLE(const Json::Value& jsonTypeValue, std::vector<std::string> &names) \

DevAdapter/simulator/gpio.1.1/gpio_impl.h

@@ -47,34 +47,34 @@ public:
 #ifndef _MSC_VER
 
     /// <summary>
-    /// 打开指定模块的提示灯
+    /// 鎵撳紑鎸囧畾妯″潡鐨勬彁绀虹伅
     /// </summary>
     /// <param name="dwReq">
-    /// 硬件灯模块序号，见上方定义GPIO_DEV_SN_*，或参考规格说明文档，只会传送模式为”驱动“的序号之一
-    /// 只会设置灯，如果是其他值则返回 Error_NotSupport
+    /// 纭�欢鐏�ā鍧楀簭鍙凤紝瑙佷笂鏂瑰畾涔塆PIO_DEV_SN_*锛屾垨鍙傝€冭�鏍艰�鏄庢枃妗ｏ紝鍙�細浼犻€佹ā寮忎负鈥濋┍鍔ㄢ€滅殑搴忓彿涔嬩竴
+    /// 鍙�細璁剧疆鐏�紝濡傛灉鏄�叾浠栧€煎垯杩斿洖 Error_NotSupport
     /// </param>
     /// <param name="dwMode">
-    /// 入参，指定灯的属性如常亮还是闪烁，是普通灯颜色还是故障灯颜色
-    /// 不同属性可以通过与的方式合并传入，如灯颜色和亮灯模式，同一属性只会传入其中一个值，比如灯常亮和闪烁只会传入其中之一
-    /// 具体值表示的内容参考上方定义的内容 GPIO_DEV_LIGHT_MODE_*
+    /// 鍏ュ弬锛屾寚瀹氱伅鐨勫睘鎬у�甯镐寒杩樻槸闂�儊锛屾槸鏅�€氱伅棰滆壊杩樻槸鏁呴殰鐏��鑹�
+    /// 涓嶅悓灞炴€у彲浠ラ€氳繃涓庣殑鏂瑰紡鍚堝苟浼犲叆锛屽�鐏��鑹插拰浜�伅妯″紡锛屽悓涓€灞炴€у彧浼氫紶鍏ュ叾涓�竴涓�€硷紝姣斿�鐏�父浜�拰闂�儊鍙�細浼犲叆鍏朵腑涔嬩竴
+    /// 鍏蜂綋鍊艰〃绀虹殑鍐呭�鍙傝€冧笂鏂瑰畾涔夌殑鍐呭� GPIO_DEV_LIGHT_MODE_*
     /// </param>
     /// <returns>
-    ///  参数有误或设置失败返回对应的报错
+    ///  鍙傛暟鏈夎�鎴栬�缃�け璐ヨ繑鍥炲�搴旂殑鎶ラ敊
     /// </returns>
     virtual ErrorCodeEnum SetStatus(DWORD dwReq, DWORD dwMode);
 
     /// <summary>
-    /// 获取探测器的状态
+    /// 鑾峰彇鎺㈡祴鍣ㄧ殑鐘舵€�
     /// </summary>
     /// <param name="dwReq">
-    /// 感应模块序号，见上方定义GPIO_DEV_SN_*，或参考规格说明文档，只会传送模式为”接收“的序号
-    /// 这个可能是与的关系，即有可能会一个调用同时获取多个模块的状态
+    /// 鎰熷簲妯″潡搴忓彿锛岃�涓婃柟瀹氫箟GPIO_DEV_SN_*锛屾垨鍙傝€冭�鏍艰�鏄庢枃妗ｏ紝鍙�細浼犻€佹ā寮忎负鈥濇帴鏀垛€滅殑搴忓彿
+    /// 杩欎釜鍙�兘鏄�笌鐨勫叧绯伙紝鍗虫湁鍙�兘浼氫竴涓�皟鐢ㄥ悓鏃惰幏鍙栧�涓�ā鍧楃殑鐘舵€�
     /// </param>
     /// <param name="dwMode">
-    /// 对应模块（有震动、开门、摘机、有人靠近）对应的位，如果是高电平置为1，如果低电平则置为0
+    /// 瀵瑰簲妯″潡锛堟湁闇囧姩銆佸紑闂ㄣ€佹憳鏈恒€佹湁浜洪潬杩戯級瀵瑰簲鐨勪綅锛屽�鏋滄槸楂樼數骞崇疆涓�1锛屽�鏋滀綆鐢靛钩鍒欑疆涓�0
     /// </param>
     /// <returns>
-    /// 无法获取状态则返回报错
+    /// 鏃犳硶鑾峰彇鐘舵€佸垯杩斿洖鎶ラ敊
     /// </returns>
     virtual ErrorCodeEnum DetectStatus(DWORD dwReq, DWORD& dwMode);
 

DevAdapter/simulator/idcer.1.1/idcer_httpans.h

@@ -15,37 +15,37 @@ typedef struct IDCerDevAns
         int dwSize;
         JSONCONVERT2OBJECT_MEMEBER_REGISTER(data, dwSize)
     }sex;
-    struct Nation {//民族（二代证专用）
+    struct Nation {//姘戞棌锛堜簩浠ｈ瘉涓撶敤锛�
         std::string data;
         int dwSize;
         JSONCONVERT2OBJECT_MEMEBER_REGISTER(data, dwSize)
     }nation;
-    struct Birthday {//出生日期，原始格式:19861007
+    struct Birthday {//鍑虹敓鏃ユ湡锛屽師濮嬫牸寮�:19861007
         std::string data;
         int dwSize;
         JSONCONVERT2OBJECT_MEMEBER_REGISTER(data, dwSize)
     }birthday;
-    struct Address {//住址（二代证专用）
+    struct Address {//浣忓潃锛堜簩浠ｈ瘉涓撶敤锛�
         std::string data;
         int dwSize;
         JSONCONVERT2OBJECT_MEMEBER_REGISTER(data, dwSize)
     }address;
-    struct Idno {//证件号码，二代证指身份证号，外国人指永久居留证号
-        std::string data; //拓展至64字节
+    struct Idno {//璇佷欢鍙风爜锛屼簩浠ｈ瘉鎸囪韩浠借瘉鍙凤紝澶栧浗浜烘寚姘镐箙灞呯暀璇佸彿
+        std::string data; //鎷撳睍鑷�64瀛楄妭
         int dwSize;
         JSONCONVERT2OBJECT_MEMEBER_REGISTER(data, dwSize)
     }idno;
-    struct Department {//二代证指签发机关，外国人指当次申请受理机关代码
+    struct Department {//浜屼唬璇佹寚绛惧彂鏈哄叧锛屽�鍥戒汉鎸囧綋娆＄敵璇峰彈鐞嗘満鍏充唬鐮�
         std::string data;
         int dwSize;
         JSONCONVERT2OBJECT_MEMEBER_REGISTER(data, dwSize)
     }department;
-    struct StartDate {//有效期起始日（签发日）原始格式：20200809
+    struct StartDate {//鏈夋晥鏈熻捣濮嬫棩锛堢�鍙戞棩锛夊師濮嬫牸寮忥細20200809
         std::string data;
         int dwSize;
         JSONCONVERT2OBJECT_MEMEBER_REGISTER(data, dwSize)
     }startDate;
-    struct EndDate {//有效期截止日（终止日）原始格式：20200809
+    struct EndDate {//鏈夋晥鏈熸埅姝㈡棩锛堢粓姝㈡棩锛夊師濮嬫牸寮忥細20200809
         std::string data;
         int dwSize;
         JSONCONVERT2OBJECT_MEMEBER_REGISTER(data, dwSize)
@@ -55,62 +55,62 @@ typedef struct IDCerDevAns
         int dwSize;
         JSONCONVERT2OBJECT_MEMEBER_REGISTER(data, dwSize)
     }photoPath;
-    struct NewAddress {//最新地址，二代证专用
+    struct NewAddress {//鏈€鏂板湴鍧€锛屼簩浠ｈ瘉涓撶敤
         std::string data;
         int dwSize;
         JSONCONVERT2OBJECT_MEMEBER_REGISTER(data, dwSize)
     }newAddress;
-    struct EnglishName {//英文姓名，外国人专用
+    struct EnglishName {//鑻辨枃濮撳悕锛屽�鍥戒汉涓撶敤
         std::string data;
         int dwSize;
         JSONCONVERT2OBJECT_MEMEBER_REGISTER(data, dwSize)
     }englishName;
-    struct Nationality {//国籍或地区代码，外国人专用
+    struct Nationality {//鍥界睄鎴栧湴鍖轰唬鐮侊紝澶栧浗浜轰笓鐢�
         std::string data;
         int dwSize;
         JSONCONVERT2OBJECT_MEMEBER_REGISTER(data, dwSize)
     }nationality;
-    struct IdVersion {//证件版本号，外国人专用
+    struct IdVersion {//璇佷欢鐗堟湰鍙凤紝澶栧浗浜轰笓鐢�
         std::string data;
         int dwSize;
         JSONCONVERT2OBJECT_MEMEBER_REGISTER(data, dwSize)
     }idVersion;
-    struct IdType {//证件类型标识，外国人取值'I'，二代证为空
+    struct IdType {//璇佷欢绫诲瀷鏍囪瘑锛屽�鍥戒汉鍙栧€�'I'锛屼簩浠ｈ瘉涓虹┖
         std::string data;
         int dwSize;
         JSONCONVERT2OBJECT_MEMEBER_REGISTER(data, dwSize)
     }idType;
-    struct Reserved {//保留字段，外国人专用
+    struct Reserved {//淇濈暀瀛楁�锛屽�鍥戒汉涓撶敤
         std::string data;
         int dwSize;
         JSONCONVERT2OBJECT_MEMEBER_REGISTER(data, dwSize)
     }reserved;
-    struct TXZCode {//通行证号码（港澳台居住证）
+    struct TXZCode {//閫氳�璇佸彿鐮侊紙娓�境鍙板眳浣忚瘉锛�
         std::string data;
         int dwSize;
         JSONCONVERT2OBJECT_MEMEBER_REGISTER(data, dwSize)
     }txzCode;
-    struct IssuedSN {//签发次数（港澳台居住证）
+    struct IssuedSN {//绛惧彂娆℃暟锛堟腐婢冲彴灞呬綇璇侊級
         std::string data;
         int dwSize;
         JSONCONVERT2OBJECT_MEMEBER_REGISTER(data, dwSize)
     }issuedSN;
-    struct Reserved2 {//备用2（港澳台居住证）
+    struct Reserved2 {//澶囩敤2锛堟腐婢冲彴灞呬綇璇侊級
         std::string data;
         int dwSize;
         JSONCONVERT2OBJECT_MEMEBER_REGISTER(data, dwSize)
     }reserved2;
-    struct Reserved3 {//备用3（港澳台居住证）
+    struct Reserved3 {//澶囩敤3锛堟腐婢冲彴灞呬綇璇侊級
         std::string data;
         int dwSize;
         JSONCONVERT2OBJECT_MEMEBER_REGISTER(data, dwSize)
     }reserved3;
-    struct Reserved4 {//备用4（港澳台居住证）
+    struct Reserved4 {//澶囩敤4锛堟腐婢冲彴灞呬綇璇侊級
         std::string data;
         int dwSize;
         JSONCONVERT2OBJECT_MEMEBER_REGISTER(data, dwSize)
     }reserved4;
-    struct Reserved5 {//备用5（港澳台居住证）
+    struct Reserved5 {//澶囩敤5锛堟腐婢冲彴灞呬綇璇侊級
         std::string data;
         int dwSize;
         JSONCONVERT2OBJECT_MEMEBER_REGISTER(data, dwSize)

DevAdapter/simulator/idcer.1.1/idcer_impl.h

@@ -31,7 +31,7 @@ public:
     ErrorCodeEnum ScanIDAndSaveImage();
     ErrorCodeEnum QueryCardPos(int &pos);
 
-    ///////身份证数据格式转换函数////////
+    ///////韬�唤璇佹暟鎹�牸寮忚浆鎹㈠嚱鏁�////////
     ErrorCodeEnum ex2HttpFunction(IDCerInfoEx2& idCerInfoEx2);
 };
 

DevAdapter/simulator/include/DeviceSimulator.h

@@ -321,7 +321,7 @@ string GetLocalIP()
 	while (intr-- > 0 && ioctl(sfd, SIOCGIFADDR, (char*)&buf[intr]));
 	close(sfd);
 	unsigned long ip = ntohl(((struct sockaddr_in*)(&buf[intr].ifr_addr))->sin_addr.s_addr);
-
+	//TODO: 不用delete ???  [Gifur@202585]
 	char* str = new char[1024];
 	sprintf(str, "%u.%u.%u.%u", ip >> 24 & 0xFF, ip >> 16 & 0xFF, ip >> 8 & 0xFF, ip >> 0 & 0xFF);
 	re = str;

DevAdapter/zcopy/CMakeLists.txt

@@ -27,4 +27,9 @@ if(NOT DEVOPS_ON)
 		endforeach()" 
 	 COMPONENT devadapters)
 
+	if(WITH_GITFUR_LOCALCP)
+		install(CODE "execute_process(COMMAND sshpass -p 123456 ssh vtm@99.12.23.178 \"bash /opt/Run/version/kill.sh\")")
+		install(CODE "execute_process(COMMAND sshpass -p 123456 scp -r /home/chanlp/Run/version/8.5.1.1 vtm@99.12.23.178:/opt/Run/version)")
+	endif(WITH_GITFUR_LOCALCP)
+
 endif(NOT DEVOPS_ON)

Framework/Common/CodeSignVerify.h

@@ -33,7 +33,7 @@ struct CSignInfo
 	CSignInfo() :strProgramName(""), strSignCertIssuer(""), strSignCertSubject(""), strSignCertHash(""){}
 };
 
-#ifdef _WIN32
+#ifdef RVC_OS_WIN
 
 // verify code signature & get file version
 class CCodeSignVerify

Framework/Common/PlatformDef.h

@@ -30,4 +30,50 @@
 
 #endif
 
+#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 202311L)
+	#define RVC_DEPRECATED(obj) [[deprecated]] obj
+	#define RVC_DEPRECATED_VAR(text, obj) [[deprecated(text)]] obj
+	#define RVC_NORETURN(obj) [[noreturn]] obj
+#elif defined(WIN32) && !defined(__CYGWIN__)
+	#define RVC_DEPRECATED(obj) __declspec(deprecated) obj
+	#define RVC_DEPRECATED_VAR(text, obj) __declspec(deprecated(text)) obj
+	#define RVC_NORETURN(obj) __declspec(noreturn) obj
+#elif defined(__GNUC__)
+#define RVC_DEPRECATED(obj) obj __attribute__((deprecated))
+#define RVC_DEPRECATED_VAR(text, obj) obj __attribute__((deprecated(text)))
+#define RVC_NORETURN(obj) __attribute__((__noreturn__)) obj
+#else
+	#define RVC_DEPRECATED(obj) obj
+	#define RVC_DEPRECATED_VAR(text, obj) obj
+	#define RVC_NORETURN(obj) obj
+#endif
+
+#if defined(__cplusplus) && (__cplusplus >= 201703L)
+	#define RVC_ATTR_UNUSED [[maybe_unused]]
+#elif defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 202000L)
+	#define RVC_ATTR_UNUSED [[maybe_unused]]
+#elif defined(__GNUC__) || defined(__clang__)
+	#define RVC_ATTR_UNUSED __attribute__((unused))
+#else
+	#define RVC_ATTR_UNUSED
+#endif
+
+#define RVC_UNUSED(x) (void)(x)
+
+#if !defined(_MSC_VER)
+	#define RVC_DO_PRAGMA(x) _Pragma(#x)
+#else
+	#define RVC_DO_PRAGMA(x) __pragma(#x)
+#endif
+
+#if defined(__GNUC__)
+	#define RVC_PRAGMA_WARNING(msg) RVC_DO_PRAGMA(GCC warning #msg)
+#elif defined(__clang__)
+	#define RVC_PRAGMA_WARNING(msg) RVC_DO_PRAGMA(GCC warning #msg)
+#elif defined(_MSC_VER) && (_MSC_VER >= 1920)
+	#define RVC_PRAGMA_WARNING(msg) RVC_DO_PRAGMA(message \x28 #msg \x29)
+#else
+	#define RVC_PRAGMA_WARNING(msg)
+#endif
+
 #endif //_RVC_PLATFORM_DEFINIED_H__

Framework/Common/RVCComm.h

@@ -163,8 +163,6 @@ public:
 	CSmartPointer<IClientCommFunc> GetFunction(){return m_pClientComm;}
 
 	// 鉴权开始，需提供Token信息和客户端私钥加密的设备信息
-	virtual bool OnAuthRequest(CConnAuthReq *pReq){return true;}
-
 	virtual bool OnAuthRequestSM(CConnAuthSMReq* pReq) { return true; }
 
 	// 临时会话密钥返回，需使用临时私钥解锁，*pBufLen返回0表示解密失败

Framework/Common/SpBase.h

@@ -35,9 +35,9 @@
 
 
 #ifdef RVC_OS_WIN
-#ifndef u__int64_t
-#define u__int64_t unsigned __int64
-#endif //u__int64_t
+	#ifndef u__int64_t
+		#define u__int64_t unsigned __int64
+	#endif //u__int64_t
 #endif
 
 #include <time.h> // for time_t
@@ -115,6 +115,16 @@ enum InstallStateEnum
 	Install_Installed,			// D, only used to LightPack
 };
 
+/* terminal machine type*/
+enum MachineTypeEnum
+{
+	RVC_Unknown = 0,
+	RVC_Stand2S,
+	RVC_Stand1SPlus,
+	RVC_CardStore,
+	RVC_CardPrinter
+};
+
 /** terminal application boot state*/
 enum AppBootStateEnum
 {
@@ -819,6 +829,8 @@ struct IEntityFunction
 {
 	virtual ~IEntityFunction() {}
 
+	/** get Machine Type, the outStrMachine out param will store the MachineType String if not nulll */
+	virtual MachineTypeEnum GetMachineType(CSimpleStringA* outStrMachine = NULL) = 0;
 	/** get CSystemStaticInfo information */
 	virtual ErrorCodeEnum GetSystemStaticInfo(CSystemStaticInfo& Info) = 0;
 	virtual ErrorCodeEnum GetInstallInfo(CVersion Version, CInstallInfo& Info) = 0;	//include latter/current/history version
@@ -934,33 +946,6 @@ struct IEntityFunction
 	/** force shell to dump a log file */
 	virtual ErrorCodeEnum FlushLogFile() = 0;
 
-	/**
-	 * read persist object from framework's serialize directory
-	 * @param pszClass which class the object belongs
-	 * @param pszKey the object key, key is case-sensitive!!!
-	 * note: actually this object stores at dir %syspath%/Objects/<EntityName>/pszClass/pszKey
-	 * so pszClass and pszKey cannot contains chars which os file path specification forbidden, such as *, ?
-	 */
-	virtual ErrorCodeEnum ReadPersistObject(const char* pszClass, const char* pszKey, IEntityPersistObject* pInstance) = 0;
-
-	/** write persist object to framework's serialize directory */
-	virtual ErrorCodeEnum WritePersistObject(const char* pszClass, const char* pszKey, const IEntityPersistObject* pInstance) = 0;
-
-	/** get the number of persist object */
-	virtual ErrorCodeEnum ReadNumOfPersistObject(const char* pClassName, DWORD& dwNum) = 0;
-
-	/** get class all objects keys */
-	virtual ErrorCodeEnum GetPersistClassObjectKeys(const char* pClassName, CAutoArray<CSimpleStringA>& strKeys) = 0;
-
-	/** delete persist object */
-	virtual ErrorCodeEnum DeleteKeyOfPersistObject(const char* pClassName, const char* pszKey) = 0;
-
-	/** walk through class objects of pClassName, Handle=0 find from beginning */
-	virtual ErrorCodeEnum EnumKeyOfPersistObject(const char* pClassName, CSimpleStringA& strKey, DWORD& dwHandle) = 0;
-
-	/** delete all persist object of class pClassName */
-	virtual ErrorCodeEnum CleanAllOfPersistObject(const char* pClassName) = 0;
-
 	/**
 	 * do async connect to remote entity service, after connected, then pClientSession->Onconnected will call
 	 * note: if return succeed, pClientSession will delete by system via OnDestroy
@@ -1692,8 +1677,8 @@ SPBASE_API void LogAssert(const char* pszMessage, const char* pszSourceFile, con
 SPBASE_API void LogTrace(const char* pszMessage, const char* pszSourceFile, const int nLine, const linkContext& t_context);
 
 
-SPBASE_API CSimpleStringA GetSysErrMsg(int nErrCode);
-SPBASE_API const char *_GetFileName(const char *pszFilePath);
+SPBASE_API CSimpleStringA GetSysErrMsg(DWORD nErrCode);
+extern "C" SPBASE_API const char *_GetFileName(const char *pszFilePath);
 
 /*
 基于当前mod中包含有restful模块，需要把数据从framework中传递到librestful，会比较困难
@@ -1713,6 +1698,7 @@ SPBASE_API void SpGetToken(char* channelId, char* token, char* terminalno, char*
 	LogTrace(CSimpleStringA::Format(pMsg, ##__VA_ARGS__), _GetFileName(__FILE__), __LINE__)
 #endif //RVC_OS_WIN
 
+//TODO: to remove  [Gifur@2025730]
 extern "C" SPBASE_API void Dbg(const char *str, ...);
 extern "C" SPBASE_API void vDbg(const char *str, va_list list);
 

Framework/Common/SpCatch.h

@@ -16,6 +16,47 @@
 
 namespace SP {
 
+	namespace Detail
+	{
+
+		struct SourceLineInfo {
+
+			SourceLineInfo() :file(""), line(0) {/*empty*/ }
+			SourceLineInfo(char const* file, std::size_t line) :file(file), line(line) {/*empty*/ }
+
+
+#if defined(_MSC_VER)
+#else
+			SourceLineInfo(SourceLineInfo const& rhs) = default;
+			SourceLineInfo(SourceLineInfo&& rhs) = default;
+			SourceLineInfo& operator = (SourceLineInfo const& rhs) = default;
+			SourceLineInfo& operator =(SourceLineInfo&& rhs) = default;
+#endif //_MSC_VER
+
+			bool operator == (SourceLineInfo const& rhs) const {
+				return line < rhs.line || (line == rhs.line && (std::strcmp(file, rhs.file) < 0));
+			}
+			bool operator < (SourceLineInfo const& rhs) const {
+				return line == rhs.line && (file == rhs.file || std::strcmp(file, rhs.file) == 0);
+			}
+
+			const std::string ToString() const {
+				std::ostringstream oss;
+				oss << "file: {" << _GetFileName(file) << "} ,line: {" << line << "}";
+				return oss.str();
+			}
+
+			char const* file;
+			std::size_t line;
+		};
+
+		inline std::ostream& operator << (std::ostream& os, SourceLineInfo const& info)
+		{
+			os << info.file << '(' << info.line << ')';
+			return os;
+		}
+	}
+
 	namespace Catch {
 
 		class CBaseException : public std::exception
@@ -68,4 +109,6 @@ namespace SP {
 	}
 }
 
+#define SP_INTERNAL_LINEINFO ::SP::Detail::SourceLineInfo( __FILE__, static_cast<std::size_t>( __LINE__ ) )
+
 #endif /** _RVC_CATCH_H__*/

Framework/Common/SpComm.hpp

@@ -15,84 +15,6 @@
 
 namespace SP
 {
-	//depecrated, to use defined at Module/include/CommEntityUtil.hpp
-	struct MachineFormat 
-	{
-		enum Site
-		{
-			CMB_UNKNOWN,
-			CMB_LIB,       /** 行内大堂*/
-			CMB_FLB,      /** 离行机器*/
-		};
-
-#define SITE_ENUM_TYPE(MACRO)	\
-		MACRO(LIB)\
-		MACRO(FLB)
-
-
-#define ENUM_MAP_CONVERT(elem) \
-	if (stricmp(lpcszSiteName, "CMB."#elem) == 0) return CMB_##elem;
-		/*!
-		 * convert cmb site name to enum type.
-		 */
-		static Site Str2Site(LPCSTR lpcszSiteName) 
-		{
-			if (lpcszSiteName == NULL || strlen(lpcszSiteName) == 0)
-				return CMB_UNKNOWN;
-			SITE_ENUM_TYPE(ENUM_MAP_CONVERT)
-			return CMB_UNKNOWN;
-		}
-
-#undef ENUM_MAP_CONVERT
-#define ENUM_MAP_CONVERT(elem) case CMB_##elem: return "CMB."#elem;
-
-		static LPCSTR Site2Str(Site site) {
-			switch (site) {
-				SITE_ENUM_TYPE(ENUM_MAP_CONVERT)
-			default:
-				break;
-			}
-			return "Unkown";
-		}
-
-		enum What
-		{
-			RVC_UNKNOWN,
-			RVC_Stand2S,          /** 落地式大机*/
-			RVC_Stand1SPlus       /** 单屏大机*/
-		};
-
-#define MACHINE_ENUM_TYPE(MACRO)	\
-		MACRO(Stand2S)\
-		MACRO(Stand1SPlus)
-
-#undef ENUM_MAP_CONVERT
-#define ENUM_MAP_CONVERT(elem) \
-	if (stricmp(lpcszTypeName, "RVC."#elem) == 0) return RVC_##elem;
-		/*!
-		 * convert cmb site name to enum type.
-		 */
-		static What Str2Type(LPCSTR lpcszTypeName)
-		{
-			if (lpcszTypeName == NULL || strlen(lpcszTypeName) == 0)
-				return RVC_UNKNOWN;
-			MACHINE_ENUM_TYPE(ENUM_MAP_CONVERT)
-			return RVC_UNKNOWN;
-		}
-
-#undef ENUM_MAP_CONVERT
-#define ENUM_MAP_CONVERT(elem) case RVC_##elem: return "RVC."#elem;
-
-		static LPCSTR Type2Str(What what) {
-			switch (what) {
-				MACHINE_ENUM_TYPE(ENUM_MAP_CONVERT)
-			default:
-				break;
-			}
-			return "Unkown";
-		}
-	};
-
 	/** Leak Detector*/
 	namespace Perf
 	{
@@ -137,58 +59,8 @@ namespace SP
 		};
 	}
 
-	namespace Detail {
-
-		struct SourceLineInfo {
-
-			SourceLineInfo() :file(""), line(0){/*empty*/}
-			SourceLineInfo(char const* file, std::size_t line) :file(file), line(line){/*empty*/}
-
-
-#if defined(_MSC_VER)
-#else
-			SourceLineInfo(SourceLineInfo const& rhs) = default;
-			SourceLineInfo(SourceLineInfo && rhs) = default;
-			SourceLineInfo& operator = (SourceLineInfo const& rhs) = default;
-			SourceLineInfo& operator =(SourceLineInfo && rhs) = default;
-#endif //_MSC_VER
-
-			bool operator == (SourceLineInfo const& rhs) const {
-				return line < rhs.line || (line == rhs.line && (std::strcmp(file, rhs.file) < 0));
-			}
-			bool operator < (SourceLineInfo const& rhs) const {
-				return line == rhs.line && (file == rhs.file || std::strcmp(file, rhs.file) == 0);
-			}
-
-			const std::string ToString() const {
-				std::ostringstream oss;
-				oss << "file: {" << _GetFileName(file) << "} ,line: {" << line << "}";
-				return oss.str();
-			}
-
-			char const* file;
-			std::size_t line;
-		};
-
-		inline std::ostream& operator << (std::ostream& os, SourceLineInfo const& info)
-		{
-			os << info.file << '(' << info.line << ')';
-			return os;
-		}
-
-	}
-
 }
 
-#define SP_INTERNAL_LINEINFO ::SP::Detail::SourceLineInfo( __FILE__, static_cast<std::size_t>( __LINE__ ) )
-
-#ifdef RVC_OS_WIN
-	#define SP_SLEEP(ms) Sleep(ms)
-#else
-	#include <unistd.h>
-	#define SP_SLEEP(ms) usleep((ms) * 1000)
-#endif
-
 #ifndef ASSERT
 #include <assert.h>
 #define ASSERT assert

Framework/Common/SpDefine.h

@@ -1,3 +1,5 @@
+#ifndef _SP_DEFINE_H__
+#define _SP_DEFINE_H__
 
 
 class SpDefine
@@ -56,3 +58,5 @@ public:
 
 
 };
+
+#endif //_SP_DEFINE_H__

Framework/Common/SpHelper.h

@@ -364,7 +364,6 @@ static ErrorCodeEnum SpSendBroadcast(CSmartPointer<IEntityFunction> pFunc, DWORD
 // <class_name>
 SPBASE_API ErrorCodeEnum SpExtractClassFunctionName(const char *pszParam, CSimpleStringA &strClassName, CSimpleStringA &strFunctionName);
 
-
 //SpBase Enum Stringtify
 
 SPBASE_API LPCTSTR SpStrEntityState(const EntityStateEnum state);
@@ -377,6 +376,8 @@ SPBASE_API LPCTSTR SpStrRebootWay(const RebootWayEnum way);
 
 SPBASE_API LPCTSTR SpStrAppBootState(const AppBootStateEnum state);
 
+SPBASE_API MachineTypeEnum SpStr2MachineType(const CSimpleStringA& strMachineType);
+
 #define IS_SUCCEED(hr)	((hr) == Error_Succeed)
 
 #define IS_FAILURED(hr) (!(IS_SUCCEED(hr)))

Framework/Common/SpSecureClient.h

@@ -37,11 +37,6 @@ public:
 	// 手工指定通讯参数，@nOption：1、重新鉴权新建会话密钥；2、通过握手使用缓存会话密钥；3、不使用会话密钥，即非安全通道; 4、不协商，直接使用共享会话密钥
 	bool Connect(const char *pServerAddr, int nPort, int nOption); // wait until all authentication operation has been finished
 
-	// !!!!!!!! 此函数已降级，请使用ConnectFromCentralSetting
-	// 使用实体配置项连接, 连接参数从实体配置文件中读取 [Main::Server]和[Main::Server_Backup]项
-	/** 将接口已废弃 [Gifur@202316]*/
-	bool ConnectFromConfig(int nOption);
-		
 	// 使用集中配置项连接
 	bool ConnectFromCentralSetting();
 	
@@ -71,7 +66,6 @@ private:
 	virtual void OnClose();
 	virtual void OnError(DWORD dwSysCode, DWORD dwUserCode, const char *pErrMsg);
 	virtual void OnAuthPass();
-	virtual bool OnAuthRequest(CConnAuthReq *pReq);
 	virtual bool OnAuthRequestSM(CConnAuthSMReq* pReq);
 	virtual bool OnSessionKeyRet(CConnAuthRet *pRet, BYTE *pBuf, int *pBufLen);
 	virtual bool OnSessionKeySMRet(CConnAuthSMRet* pRet, BYTE* pBuf, int* pBufLen);
@@ -81,7 +75,6 @@ private:
 
 	bool findConnectInfo(const char *pEntityName, ENTITY_CONNECT_INFO *connectInfo);
 	bool readConnectInfoFromCentralSetting(const char *pEntityName, ENTITY_CONNECT_INFO *connectInfo);
-	bool readConnectInfoFromConfig(const char *pEntityName, ENTITY_CONNECT_INFO *connectInfo);
 	bool setConnectInfo(const ENTITY_CONNECT_INFO *connectInfo);
 	void connectClose(const char *pEntityName);
 

Framework/Common/SpTest.h

@@ -5,7 +5,7 @@
 
 #include "SpBase.h"
 #include "SpHelper.h"
-#include "SpComm.hpp"
+#include "SpCatch.h"
 #include "SpUtility.h"
 #include <vector>
 

Framework/Common/SpUtility.h

@@ -12,14 +12,7 @@
 #include "toolkit.h"
 #include "ErrorCode.h"
 #include "SpBase.h"
-
-#ifdef _MSC_VER
-	#define SP_SLEEP(ms) Sleep(ms)
-#else
-#include <unistd.h>
-	#define SP_SLEEP(ms) usleep((ms) * 1000)
-#include <locale.h>
-#endif
+#include <winpr/synch.h>
 
 #ifndef ASSERT
 #include <assert.h>
@@ -80,11 +73,15 @@ namespace SP {
 			return s.find(infix) != std::string::npos;
 		}
 
+		inline bool IsNum(const std::string& value);
+
 		inline char ToLowerCh(char c)
 		{
 			return static_cast<char>(std::tolower(c));
 		}
 
+		inline bool CheckIPv4(const std::string& value);
+
 		inline void toLowerInPlace(std::string& s)
 		{
 			std::transform(s.begin(), s.end(), s.begin(), ToLowerCh);
@@ -205,6 +202,8 @@ namespace SP {
 			return strClassName;
 		}
 
+		inline bool IsValidUrl(const std::string& value);
+
         SPBASE_API std::string W2S(const std::wstring wstr);
         SPBASE_API std::wstring S2W(const std::string str);
         SPBASE_API std::string GBK2UTF8(const std::string str);
@@ -342,7 +341,7 @@ namespace SP {
 				if (!_active) {
 					uint8_t times_ = 0;
 					while (!_active && times_ < 3) {
-						SP_SLEEP(100);
+						Sleep(100);
 						times_++;
 					}
 				}
@@ -356,7 +355,7 @@ namespace SP {
 				if (!_active) {
 					uint8_t times_ = 0;
 					while (!_active && times_ < 3) {
-						SP_SLEEP(100);
+						Sleep(100);
 						times_++;
 					}
 				}

Framework/Common/precompile.h

@@ -49,9 +49,9 @@
 #endif //SPABASE_LINKED_AS_STATIC_LIBRARY
 
 #ifdef RVC_OS_WIN
-#ifndef u__int64_t
-#define u__int64_t unsigned __int64
-#endif //u__int64_t
+	#ifndef u__int64_t
+		#define u__int64_t unsigned __int64
+	#endif //u__int64_t
 #endif //RVC_OS_WIN
 
 #ifndef SPBASE_TAG

Framework/RVCComm/CMakeLists.txt

@@ -36,7 +36,8 @@ target_link_directories(${MODULE_NAME} PRIVATE
 
 target_link_libraries(${MODULE_NAME} 
 	${PRIVATE_KEYWORD} ${KYSM_LIBRARY_NAME} 
-	${PRIVATE_KEYWORD} winpr 
+	${PRIVATE_KEYWORD} winpr
+	${PRIVATE_KEYWORD} libtoolkit
 	${PRIVATE_KEYWORD} ${OPENSSL_SSL_LIBRARY}
 	${PRIVATE_KEYWORD} ${OPENSSL_CRYPTO_LIBRARY}
 	${PRIVATE_KEYWORD} ${CONAN_LIBS_LIBSSH2}

Framework/RVCComm/HTTPClient.cpp

@@ -11,6 +11,7 @@
 #include "toolkit.h"
 #include <winpr/string.h>
 #endif //_MSC_VER
+#include "charset.h"
 
 #define DEBUG_LOG(msg)	\
       do {	\
@@ -56,7 +57,7 @@ static void init_libcurl_once(void)
 	gLibcurlMnt.Init();
 }
 
-#include "charset.h"
+
 static std::string GBK2UTF8(const std::string str)
 {
 	std::string result("");
@@ -114,6 +115,24 @@ void ConvertGBKToUtf8(std::string& str)
 	const std::string result = GBK2UTF8(str);
 	str = result;
 }
+
+#else
+
+void ConvertUtf8ToGBK(std::string& str)
+{
+	char* dst = ConvertUtf8ToGBK(str.c_str());
+	str = dst;
+	if(dst != NULL) free(dst);
+}
+
+void ConvertGBKToUtf8(std::string& str)
+{
+	int len = 0;
+	char* dst = ConvertGBKToUtf8(str.c_str(), &len);
+	str = dst;
+	if (dst != NULL) free(dst);
+}
+
 #endif
 
 // Static members initialization
@@ -194,17 +213,11 @@ CHTTPClient::~CHTTPClient()
    }
 
 #if defined(RVC_OS_WIN)
-   DEBUG_LOG("to lock.");
    Lock(INFINITE);
    if (--s_iCurlSession <= 0) {
-       DEBUG_LOG("to clean curl.");
        curl_global_cleanup();
-       DEBUG_LOG("after clean curl.");
    }
    Unlock();
-   DEBUG_LOG("unlock finished");
-#else
-
 #endif //RVC_OS_WIN
 }
 

Framework/RVCComm/HTTPClient.h

@@ -253,59 +253,6 @@ private:
    CHTTPClient& operator=(const CHTTPClient& Copy);
 };
 
-///*TODO(80374374@3/9/2023): 抽出作为公共函数 */
-#if defined(_MSC_VER)
-char* ConvertUtf8ToGBK(const char* strUtf8)
-{
-    int len = MultiByteToWideChar(CP_UTF8, 0, strUtf8, -1, NULL, 0);
-    WCHAR* wszGBK = new WCHAR[len + 1];
-    memset(wszGBK, 0, len * 2 + 2);
-    MultiByteToWideChar(CP_UTF8, 0, strUtf8, -1, wszGBK, len);
-
-    len = WideCharToMultiByte(CP_ACP, 0, wszGBK, -1, NULL, 0, NULL, NULL);
-    char* szGBK = new char[len + 1];
-    memset(szGBK, 0, len + 1);
-    WideCharToMultiByte(CP_ACP, 0, wszGBK, -1, szGBK, len, NULL, NULL);
-    delete[] wszGBK;
-
-    return szGBK;
-}
-
-void ConvertUtf8ToGBK(std::string& str)
-{
-    char* dst = ConvertUtf8ToGBK(str.c_str());
-    str = dst;
-    delete[] dst;
-}
-
-
-char* ConvertGBKToUtf8(const char* gbk, int* n)
-{
-    int len = MultiByteToWideChar(CP_ACP, 0, gbk, -1, NULL, 0);
-    WCHAR* wszGBK = new WCHAR[len + 1];
-    memset(wszGBK, 0, len * 2 + 2);
-    MultiByteToWideChar(CP_ACP, 0, gbk, -1, wszGBK, len);
-
-    len = WideCharToMultiByte(CP_UTF8, 0, wszGBK, -1, NULL, 0, NULL, NULL);
-    char* szUtf8 = new char[len + 1];
-    memset(szUtf8, 0, len + 1);
-    WideCharToMultiByte(CP_UTF8, 0, wszGBK, -1, szUtf8, len, NULL, NULL);
-
-    delete[] wszGBK;
-    *n = len - 1;
-    return szUtf8;
-}
-
-void ConvertGBKToUtf8(std::string& str)
-{
-    int len = 0;
-    char* dst = ConvertGBKToUtf8(str.c_str(), &len);
-    str = dst;
-    delete[] dst;
-}
-#endif //_MSC_VER
-
-
 RVCCOMM_API IHttpFunc* create_http(LogFnCallback oLogger)
 {
 	return new CHTTPClient(oLogger);

Framework/RvcLogSdk/log_inner_include.h

@@ -105,7 +105,6 @@ typedef int BOOL;
 
 #define Sleep(param) usleep(1000*(param))
 #define strcpy_s(a, b, c) strcpy(a, c)
-#define sprintf_s(a, b, c) sprintf(a, c)
 #define strncpy_s(a, b, c, d) strncpy(a, c, d)
 #define vsprintf_s(a, b, c, d) vsprintf(a, c, d)
 #define _strdup strdup

Framework/RvcLogSdk/log_util.cpp

@@ -146,6 +146,7 @@ void GetUnitedTimeStr(time_t time, char* szTime)
 	);
 }
 
+//TODO: CrossPlaform  相对独立，不用框架库提供的函数进行IP 获取 [Gifur@2025729]
 int GetLocalIP(char* ip_str)
 {
 	

Framework/libtoolkit/charset.c

@@ -1,5 +1,6 @@
 #include "precompile.h"
 #include "charset.h"
+#include "memutil.h"
 #include <stdlib.h>  
 #include <stdio.h>  
 #include <fcntl.h>  
@@ -604,3 +605,252 @@ TOOLKIT_API int  toolkit_detect_utf8_str(const char* str)
     //if (validate_utf8(str, strlen(str)) == UTF8_ACCEPT) return 1;
     return is_utf8(str);
 }
+
+TOOLKIT_API int toolkit_detect_utf8_str2(const char* str)
+{
+	unsigned int nBytes = 0;//UFT8可用1-6个字节编码,ASCII用一个字节  
+	unsigned char chr = *str;
+	int bAllAscii = 1;
+
+	for (unsigned int i = 0; str[i] != '\0'; ++i) {
+		chr = *(str + i);
+		//判断是否ASCII编码,如果不是,说明有可能是UTF8,ASCII用7位编码,最高位标记为0,0xxxxxxx 
+		if (nBytes == 0 && (chr & 0x80) != 0) {
+			bAllAscii = 0;
+		}
+
+		if (nBytes == 0) {
+			//如果不是ASCII码,应该是多字节符,计算字节数  
+			if (chr >= 0x80) {
+
+				if (chr >= 0xFC && chr <= 0xFD) {
+					nBytes = 6;
+				}
+				else if (chr >= 0xF8) {
+					nBytes = 5;
+				}
+				else if (chr >= 0xF0) {
+					nBytes = 4;
+				}
+				else if (chr >= 0xE0) {
+					nBytes = 3;
+				}
+				else if (chr >= 0xC0) {
+					nBytes = 2;
+				}
+				else {
+					return 0;
+				}
+
+				nBytes--;
+			}
+		}
+		else {
+			//多字节符的非首字节,应为 10xxxxxx 
+			if ((chr & 0xC0) != 0x80) {
+				return 0;
+			}
+			//减到为零为止
+			nBytes--;
+		}
+	}
+
+	//违返UTF8编码规则 
+	if (nBytes != 0) {
+		return 0;
+	}
+
+	if (bAllAscii) { //如果全部都是ASCII, 也是UTF8
+		return 1;
+	}
+
+	return 1;
+}
+
+
+
+size_t toolkit_mbs2wcs(const char* src, wchar_t* dst, size_t dst_size)
+{
+#ifdef _MSC_VER
+	wchar_t* wstr = NULL;
+	int n = MultiByteToWideChar(CP_ACP, 0, src, -1, NULL, 0);
+	if (n > 0) {
+		wstr = malloc(sizeof(wchar_t) * (n + 1));
+		if (wstr == NULL) {
+			return 0;
+		}
+		memset(wstr, 0, (n + 1) * sizeof(wchar_t));
+		MultiByteToWideChar(CP_ACP, 0, src, -1, &wstr[0], n);
+		wcscpy(dst, wstr);
+		FREE(wstr);
+		return n;
+	}
+	return 0;
+
+#else
+
+	unsigned len = 0;
+	wchar_t* p = NULL;
+	if (strlen(src) == 0) {
+		return 0;
+	}
+	const char* origin = setlocale(LC_CTYPE, NULL);
+	WLog_DBG(TAG, "%s: origin locale: %s, data:%s", __FUNCTION__, origin, src);
+	setlocale(LC_CTYPE, "");
+
+	len = mbstowcs(NULL, src, 0);
+	if (len == -1) {
+		WLog_DBG(TAG, "mbstowcs failed: %d", errno);
+		goto on_end;
+	}
+	len += 1;
+
+	if (dst == NULL) {
+		WLog_DBG(TAG, "mbstowcs to fetch need capacity: %d", len);
+		goto on_end;
+	}
+
+	p = malloc(sizeof(wchar_t) * len);
+	wmemset(p, 0, len);
+
+	len = mbstowcs(p, src, len);
+	if (len == -1) {
+		WLog_DBG(TAG, "mbstowcs after new malloc failed: %d", errno);
+		goto on_del;
+	}
+	wmemset(dst, 0, dst_size);
+	wcscpy(dst, p);
+	len = wcslen(dst);
+	WLog_DBG(TAG, "after mbstowcs returned: %ls(%d)", dst, len);
+
+on_del:
+
+	free(p);
+
+on_end:
+
+	setlocale(LC_CTYPE, origin);
+	return len;
+
+#endif
+}
+
+size_t toolkit_wcs2mbs(const wchar_t* src, char* dst, size_t dst_size)
+{
+#if defined(_MSC_VER)
+	char* str = NULL;
+	int n = 0;
+
+	n = WideCharToMultiByte(CP_ACP, 0, src, -1, NULL, 0, NULL, NULL);
+	if (n > 0) {
+		str = malloc(sizeof(char) * (n + 1));
+		if (str == NULL) {
+			return 0;
+		}
+		memset(str, 0, sizeof(char) * (n + 1));
+		WideCharToMultiByte(CP_ACP, 0, src, -1, &str[0], n, NULL, NULL);
+		memset(dst, 0, sizeof(char) * (dst_size));
+		strcpy(dst, str);
+		FREE(str);
+		return n;
+	}
+	return 0;
+
+#else
+
+	unsigned len;
+	char* str = NULL;
+	char* origin = NULL;
+
+	len = wcslen(src);
+	if (len == 0) {
+		return 0;
+	}
+	origin = setlocale(LC_CTYPE, NULL);
+	WLog_DBG(TAG, "%s: origin locale: %s, data: %ls", __FUNCTION__, origin, src);
+	setlocale(LC_CTYPE, "");
+
+	len = wcstombs(NULL, src, 0);
+	if (len == -1) {
+		WLog_DBG(TAG, "wcstombs failed: %d", errno);
+		goto on_end;
+	}
+	len += 1;
+
+	if (dst == NULL) {
+		WLog_DBG(TAG, "wcstombs to fetch need capacity: %d", len);
+		goto on_end;
+	}
+
+	str = malloc(sizeof(char) * len);
+	memset(str, 0, len * sizeof(char));
+
+	len = wcstombs(str, src, len);
+	if (len == -1) {
+		WLog_DBG(TAG, "wcstombs after new malloc failed: %d", errno);
+		goto on_del;
+	}
+
+	memset(dst, 0, dst_size * sizeof(char));
+	strcpy(dst, str);
+	len = strlen(dst);
+	WLog_DBG(TAG, "after wcstombs returned: %s(%d)", dst, len);
+
+on_del:
+
+	free(str);
+
+on_end:
+
+	setlocale(LC_CTYPE, origin);
+	return len;
+
+#endif //_MSC_VER
+}
+
+TOOLKIT_API char* ConvertGBKToUtf8(const char* gbk, int* n)
+{
+#ifdef _MSC_VER
+	int len = MultiByteToWideChar(CP_ACP, 0, gbk, -1, NULL, 0);
+	WCHAR* wszGBK = malloc(sizeof(WCHAR) * (len + 1));
+	memset(wszGBK, 0, len * 2 + 2);
+	MultiByteToWideChar(CP_ACP, 0, gbk, -1, wszGBK, len);
+
+	len = WideCharToMultiByte(CP_UTF8, 0, wszGBK, -1, NULL, 0, NULL, NULL);
+	char* szUtf8 = malloc(sizeof(char) * (len + 1));
+	memset(szUtf8, 0, len + 1);
+	WideCharToMultiByte(CP_UTF8, 0, wszGBK, -1, szUtf8, len, NULL, NULL);
+
+	free(wszGBK);
+#else
+	int len = strlen(gbk);
+	char* szUtf8 = malloc(sizeof(char) * (len + 1));
+	memset(szUtf8, 0, len + 1);
+    strcpy(szUtf8, gbk);
+    len += 1;
+#endif
+    * n = len - 1;
+    return szUtf8;
+}
+
+TOOLKIT_API char* ConvertUtf8ToGBK(const char* strUtf8)
+{
+#ifdef _MSC_VER
+	int len = MultiByteToWideChar(CP_UTF8, 0, strUtf8, -1, NULL, 0);
+	WCHAR* wszGBK = malloc(sizeof(WCHAR)*(len + 1));
+	memset(wszGBK, 0, len * 2 + 2);
+	MultiByteToWideChar(CP_UTF8, 0, strUtf8, -1, wszGBK, len);
+
+	len = WideCharToMultiByte(CP_ACP, 0, wszGBK, -1, NULL, 0, NULL, NULL);
+    char* szGBK = malloc(sizeof(char) * (len + 1));
+	memset(szGBK, 0, len + 1);
+	WideCharToMultiByte(CP_ACP, 0, wszGBK, -1, szGBK, len, NULL, NULL);
+	free(wszGBK);
+#else
+    int len = strlen(strUtf8);
+	char* szGBK = malloc(sizeof(char) * (len + 1));
+	memset(szGBK, 0, len + 1);
+    strcpy(szGBK, strUtf8);
+#endif
+    return szGBK;
+}

Framework/libtoolkit/charset.h

@@ -22,7 +22,23 @@ extern "C" {
     //test now
     TOOLKIT_API char_encoding  detect_file_encoding(const char* file_path);
 
-    TOOLKIT_API int  toolkit_detect_utf8_str(const char* str);
+    TOOLKIT_API int toolkit_detect_utf8_str(const char* str);
+    /** from upgradetask  [Gifur@2025725]*/
+    //1:utf8;0:no utf8
+	TOOLKIT_API int toolkit_detect_utf8_str2(const char* str);
+
+	TOOLKIT_API size_t toolkit_mbs2wcs(const char* src, wchar_t* dst, size_t dst_size);
+	TOOLKIT_API size_t toolkit_wcs2mbs(const wchar_t* src, char* dst, size_t dst_size);
+
+    //only valid in win and the user remember to free the return if not null
+    //return malloc(input param) directory in UOS, please use toolkit_utf82gbk if you need
+    //copy from httpclient.h
+    TOOLKIT_API char* ConvertUtf8ToGBK(const char* strUtf8);
+
+	//only valid in win and the user remember to free the return if not null
+	//return malloc(input param) directory in UOS, please use toolkit_gbk2utf8 if you need
+	//copy from httpclient.h
+    TOOLKIT_API char* ConvertGBKToUtf8(const char* gbk, int* n);
 
 #ifdef __cplusplus
 } // extern "C" {

Framework/libtoolkit/fileutil.c

@@ -29,21 +29,31 @@ TOOLKIT_API BOOL ExistsDirA(LPCSTR lpDirPath)
 	DWORD dwRet = GetFileAttributesA(lpDirPath);
 	return (dwRet != INVALID_FILE_ATTRIBUTES) && (dwRet & FILE_ATTRIBUTE_DIRECTORY);
 }
-TOOLKIT_API BOOL ExistsDirW(LPCWSTR lpDirPath)
-{
-	DWORD dwRet = GetFileAttributesW(lpDirPath);
-	return (dwRet != INVALID_FILE_ATTRIBUTES) && (dwRet & FILE_ATTRIBUTE_DIRECTORY);
-}
 
 TOOLKIT_API BOOL ExistsFileA(LPCSTR lpFilePath)
 {
 	DWORD dwRet = GetFileAttributesA(lpFilePath);
 	return (dwRet != INVALID_FILE_ATTRIBUTES) && !(dwRet & FILE_ATTRIBUTE_DIRECTORY);
 }
-TOOLKIT_API BOOL ExistsFileW(LPCWSTR lpFilePath)
+
+TOOLKIT_API DWORD ReadFileSize(LPCSTR pszFile)
 {
-	DWORD dwRet = GetFileAttributesW(lpFilePath);
-	return (dwRet != INVALID_FILE_ATTRIBUTES) && !(dwRet & FILE_ATTRIBUTE_DIRECTORY);
+	DWORD fileSize = (DWORD)-1;
+#ifndef _MSC_VER
+	struct stat statbuf;
+	memset(&statbuf, 0, sizeof(statbuf));
+	if (stat(pszFile, &statbuf) >= 0) {
+		fileSize = statbuf.st_size;
+	}
+#else
+	HANDLE hFile;
+	hFile = CreateFile(pszFile, 0, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
+	if (hFile != INVALID_HANDLE_VALUE) {
+		fileSize = GetFileSize(hFile, NULL);
+		CloseHandle(hFile);
+	}
+#endif
+	return fileSize;
 }
 
 TOOLKIT_API BOOL CreateDirA(LPCSTR lpDirPath, BOOL bRecursive)
@@ -114,71 +124,7 @@ TOOLKIT_API BOOL CreateDirA(LPCSTR lpDirPath, BOOL bRecursive)
 	return TRUE;
 }
 
-TOOLKIT_API BOOL CreateDirW(LPCWSTR lpDirPath, BOOL bRecursive)
-{
-	WCHAR* slashPos = NULL;
-	WCHAR* backSlashPos = NULL;
-	size_t len = wcslen(lpDirPath);
-	if (len <= 2 || len >= MAX_PATH-2) {
-		return FALSE;
-	} else {
-		if (!bRecursive) {
-			return CreateDirectoryW(lpDirPath, NULL) || (GetLastError() == ERROR_ALREADY_EXISTS);
-		} else {
-			WCHAR tmp[MAX_PATH], *p;
-			WCHAR* q = NULL;
-			q = p = &tmp[0];
-			wcsncpy(tmp, lpDirPath, MAX_PATH);
-			tmp[MAX_PATH-1] = 0;
-			if (tmp[len-1] != '\\' && tmp[len-1] != '/') {
-				tmp[len++] = SPLIT_SLASH;
-				tmp[len] = 0;
-			}
-#ifdef _WIN32
-			do {
-				slashPos = wcschr(p, SLASH);
-				backSlashPos = wcschr(p, BACK_SLASH);
-				if (slashPos != NULL && backSlashPos != NULL) {
-					p = slashPos < backSlashPos ? slashPos : backSlashPos;
-				}
-				else if (slashPos != NULL) {
-					p = slashPos;
-				}
-				else {
-					p = backSlashPos;
-				}
-				if (!p) {
-					break;
-				}
-				*p = 0;
-				if (!ExistsDirW(tmp)) {
-					if (!CreateDirectoryW(tmp, NULL) && GetLastError() != ERROR_ALREADY_EXISTS)
-						return FALSE;
-				}
-				*p = SPLIT_SLASH;
-				p++;
-			} while (1);
-#else
-			while ((p = wcschr(p, SPLIT_SLASH)) != NULL) {
-				if (p != q) {//linux compatibility. 
-					*p = 0;
-					if (!ExistsDirW(tmp)) {
-						if (!CreateDirectoryW(tmp, NULL) && GetLastError() != ERROR_ALREADY_EXISTS)
-							return FALSE;
-					}
-					*p = SPLIT_SLASH;
-				}
-				p++;
-				q = p;
-			}
-#endif
-		}
-	}
-	return TRUE;
-}
-
 TOOLKIT_API BOOL CreateDirRecursiveA(LPCSTR lpDirPath) { return CreateDirA(lpDirPath, TRUE); }
-TOOLKIT_API BOOL CreateDirRecursiveW(LPCWSTR lpDirPath) { return CreateDirW(lpDirPath, TRUE); }
 
 TOOLKIT_API BOOL CreateParentDirA(LPCSTR lpPath, BOOL bRecursive)
 {
@@ -196,22 +142,6 @@ TOOLKIT_API BOOL CreateParentDirA(LPCSTR lpPath, BOOL bRecursive)
 	return CreateDirA(pdir, bRecursive);
 }
 
-TOOLKIT_API BOOL CreateParentDirW(LPCWSTR lpPath, BOOL bRecursive)
-{
-	WCHAR pdir[MAX_PATH];
-	const WCHAR *p;
-	p = wcsrchr(lpPath, '\\');
-	if (!p) {
-		p = wcsrchr(lpPath, '/');
-	}
-	if (!p) {
-		return FALSE;
-	}
-	wcsncpy(pdir, lpPath, p-lpPath);
-	pdir[p-lpPath] = 0;
-	return CreateDirW(pdir, bRecursive);
-}
-
 TOOLKIT_API BOOL ClearDirRecursiveA(LPCSTR lpDirPath)
 {
 	array_header_t *arr;
@@ -242,36 +172,6 @@ TOOLKIT_API BOOL ClearDirRecursiveA(LPCSTR lpDirPath)
 	return bRet;
 }
 
-TOOLKIT_API BOOL ClearDirRecursiveW(LPCWSTR lpDirPath)
-{
-	array_header_t *arr;
-	BOOL bRet = TRUE;
-
-	TOOLKIT_ASSERT(lpDirPath);
-
-	arr = fileutil_get_sub_files_w(lpDirPath);
-	if (arr) {
-		int i;
-		for (i = 0; i < arr->nelts; ++i) {
-			wchar_t *tmp = ARRAY_IDX(arr, i, wchar_t*);
-			bRet &= DeleteFileW(tmp);
-		}
-		toolkit_array_free2(arr);
-	}
-
-	arr = fileutil_get_sub_dirs_w(lpDirPath);
-	if (arr) {
-		int i;
-		for (i = 0; i < arr->nelts; ++i) {
-			wchar_t *tmp = ARRAY_IDX(arr, i, wchar_t*);
-			bRet &= ClearDirRecursiveW(tmp);
-		}
-		toolkit_array_free2(arr);
-	}
-
-	return bRet;
-}
-
 TOOLKIT_API BOOL RemoveFileA(LPCSTR pszFile)
 {
 	if(ExistsFileA(pszFile))
@@ -415,61 +315,6 @@ TOOLKIT_API BOOL RemoveDirRecursiveA(LPCSTR lpDirPath)
 
 }
 
-TOOLKIT_API BOOL RemoveDirRecursiveW(LPCWSTR lpDirPath)
-{
-	array_header_t *arr;
-	BOOL bRet = TRUE;
-
-	TOOLKIT_ASSERT(lpDirPath);
-
-	arr = fileutil_get_sub_files_w(lpDirPath);
-	if (arr) {
-		int i;
-		for (i = 0; i < arr->nelts; ++i) {
-			wchar_t *tmp = ARRAY_IDX(arr, i, wchar_t*);
-			bRet &= DeleteFileW(tmp);
-		}
-		toolkit_array_free2(arr);
-	}
-
-	arr = fileutil_get_sub_dirs_w(lpDirPath);
-	if (arr) {
-		int i;
-		for (i = 0; i < arr->nelts; ++i) {
-			wchar_t *tmp = ARRAY_IDX(arr, i, wchar_t*);
-			bRet &= RemoveDirRecursiveW(tmp);
-		}
-		toolkit_array_free2(arr);
-	}
-
-	if (bRet) {
-		bRet = RemoveDirectoryW(lpDirPath);
-	}
-
-	return bRet;
-}
-
-TOOLKIT_API HANDLE ExtCreateFileW(LPCWSTR lpFileName,
-	DWORD dwDesiredAccess,
-	DWORD dwShareMode,
-	LPSECURITY_ATTRIBUTES lpSecurityAttributes,
-	DWORD dwCreationDisposition,
-	DWORD dwFlagsAndAttributes,
-	HANDLE hTemplateFile)
-{
-	if (!lpFileName)
-		return INVALID_HANDLE_VALUE;
-	if (lpFileName[0] != '\\')
-		CreateParentDirW(lpFileName, TRUE);
-	return CreateFileW(lpFileName,
-		dwDesiredAccess,
-		dwShareMode,
-		lpSecurityAttributes,
-		dwCreationDisposition,
-		dwFlagsAndAttributes,
-		hTemplateFile);
-}
-
 TOOLKIT_API HANDLE ExtCreateFileA(LPCSTR lpFileName,
 	DWORD dwDesiredAccess,
 	DWORD dwShareMode,
@@ -616,49 +461,6 @@ static array_header_t *fileutil_get_sub_a(const char *path, int isfile, int limi
 	return arr;
 }
 
-static array_header_t *fileutil_get_sub_w(const wchar_t *path, int isfile, int limitation)
-{
-	array_header_t *arr = NULL;
-    WCHAR tmp[MAX_PATH];
-    int npath;
-
-    if (!path)
-        return NULL;
-    npath = wcslen(path);
-    if (npath < 2)
-        return NULL;
-
-    wcscpy(tmp, path);
-    if (tmp[npath - 1] != '\\' && tmp[npath - 1] != '/') {
-        tmp[npath++] = SPLIT_SLASH;
-        tmp[npath] = 0;
-    }
-    tmp[npath++] = '*';
-    tmp[npath] = 0;
-
-    arr = array_make(3, sizeof(wchar_t*));
-    {
-        WIN32_FIND_DATAW fd;
-        HANDLE hFind = FindFirstFileW(tmp, &fd);
-        if (hFind != INVALID_HANDLE_VALUE) {
-            tmp[--npath] = 0;
-            do {
-                int isdir = !!(fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY);
-                if (isfile ^ isdir) {
-                    wchar_t* v = malloc(sizeof(wchar_t) * (npath + wcslen(fd.cFileName) + 1));
-                    wcscpy(v, tmp);
-                    wcscat(v, fd.cFileName);
-                    ARRAY_PUSH(arr, wchar_t*) = v;
-                }
-            } while (FindNextFileW(hFind, &fd) && arr->nelts < limitation);
-            FindClose(hFind);
-        }
-    }
-
-	return arr;
-
-}
-
 TOOLKIT_API array_header_t *fileutil_get_sub_files_a(const char *path)
 {
 	return fileutil_get_sub_a(path, 1, INT_MAX);
@@ -669,16 +471,6 @@ TOOLKIT_API array_header_t *fileutil_get_sub_dirs_a(const char *path)
 	return fileutil_get_sub_a(path, 0, INT_MAX);
 }
 
-TOOLKIT_API array_header_t *fileutil_get_sub_files_w(const wchar_t *path)
-{
-	return fileutil_get_sub_w(path, 1, INT_MAX);
-}
-
-TOOLKIT_API array_header_t *fileutil_get_sub_dirs_w(const wchar_t *path)
-{
-	return fileutil_get_sub_w(path, 0, INT_MAX);
-}
-
 TOOLKIT_API array_header_t *fileutil_get_sub_files2_a(const char *path, int limitation)
 {
 	return fileutil_get_sub_a(path, 1, limitation);
@@ -689,16 +481,6 @@ TOOLKIT_API array_header_t *fileutil_get_sub_dirs2_a(const char *path, int limit
 	return fileutil_get_sub_a(path, 0, limitation);
 }
 
-TOOLKIT_API array_header_t *fileutil_get_sub_files2_w(const wchar_t *path, int limitation)
-{
-	return fileutil_get_sub_w(path, 1, limitation);
-}
-
-TOOLKIT_API array_header_t *fileutil_get_sub_dirs2_w(const wchar_t *path, int limitation)
-{
-	return fileutil_get_sub_w(path, 0, limitation);
-}
-
 TOOLKIT_API FILE *fileutil_transaction_fopen(const char *filename, const char *mode)
 {
 	DWORD dwAttr;

Framework/libtoolkit/fileutil.h

@@ -20,23 +20,12 @@ extern "C" {
 #endif
 
 TOOLKIT_API BOOL ExistsDirA(LPCSTR lpDirPath);
-TOOLKIT_API BOOL ExistsDirW(LPCWSTR lpDirPath);
-
-#if defined(UNICODE) || defined(_UNICODE)
-#define ExistsDir ExistsDirW
-#else 
 #define ExistsDir ExistsDirA
-#endif
 
 TOOLKIT_API BOOL ExistsFileA(LPCSTR lpFilePath);
-TOOLKIT_API BOOL ExistsFileW(LPCWSTR lpFilePath);
-
-#if defined(UNICODE) || defined(_UNICODE)
-#define ExistsFile ExistsFileW
-#else 
 #define ExistsFile ExistsFileA
-#endif
 
+TOOLKIT_API DWORD ReadFileSize(LPCSTR pszFile);
 
 TOOLKIT_API BOOL RemoveFileA(LPCSTR pszFile);
 TOOLKIT_API BOOL RemoveFileReadOnlyAttributeA(LPCSTR pszFile);
@@ -44,44 +33,19 @@ TOOLKIT_API BOOL RemoveFileReadOnlyAttributeA(LPCSTR pszFile);
 TOOLKIT_API BOOL CopyDirA(LPCSTR pszSourceDir, LPCSTR pszDestDir);
 
 TOOLKIT_API BOOL CreateDirA(LPCSTR lpDirPath, BOOL bRecursive);
-TOOLKIT_API BOOL CreateDirW(LPCWSTR lpDirPath, BOOL bRecursive);
-#if defined(UNICODE) || defined(_UNICODE)
-#define CreateDir CreateDirW
-#else 
 #define CreateDir CreateDirA
-#endif
 
 TOOLKIT_API BOOL CreateDirRecursiveA(LPCSTR lpDirPath);
-TOOLKIT_API BOOL CreateDirRecursiveW(LPCWSTR lpDirPath);
-#if defined(UNICODE) || defined(_UNICODE)
-#define CreateDirRecursive CreateDirRecursiveW
-#else 
 #define CreateDirRecursive CreateDirRecursiveA
-#endif
 
 TOOLKIT_API BOOL ClearDirRecursiveA(LPCSTR lpDirPath);
-TOOLKIT_API BOOL ClearDirRecursiveW(LPCWSTR lpDirPath);
-#if defined(UNICODE) || defined(_UNICODE)
-#define ClearDirRecursive ClearDirRecursiveW
-#else 
 #define ClearDirRecursive ClearDirRecursiveA
-#endif
 
 TOOLKIT_API BOOL RemoveDirRecursiveA(LPCSTR lpDirPath);
-TOOLKIT_API BOOL RemoveDirRecursiveW(LPCWSTR lpDirPath);
-#if defined(UNICODE) || defined(_UNICODE)
-#define RemoveDirRecursive RemoveDirRecursiveW
-#else 
 #define RemoveDirRecursive RemoveDirRecursiveA
-#endif
 
 TOOLKIT_API BOOL CreateParentDirA(LPCSTR lpPath, BOOL bRecursive);
-TOOLKIT_API BOOL CreateParentDirW(LPCWSTR lpPath, BOOL bRecursive);
-#if defined(UNICODE) || defined(_UNICODE)
-#define CreateParentDir CreateParentDirW
-#else 
 #define CreateParentDir CreateParentDirA
-#endif
 
 TOOLKIT_API HANDLE ExtCreateFileA(LPCSTR lpFileName,
 	DWORD dwDesiredAccess,
@@ -91,37 +55,15 @@ TOOLKIT_API HANDLE ExtCreateFileA(LPCSTR lpFileName,
 	DWORD dwFlagsAndAttributes,
 	HANDLE hTemplateFile);
 
-TOOLKIT_API HANDLE ExtCreateFileW(LPCWSTR lpFileName,
-	DWORD dwDesiredAccess,
-	DWORD dwShareMode,
-	LPSECURITY_ATTRIBUTES lpSecurityAttributes,
-	DWORD dwCreationDisposition,
-	DWORD dwFlagsAndAttributes,
-	HANDLE hTemplateFile);
-
-#if defined(UNICODE) || defined(_UNICODE)
-#define ExtCreateFile ExtCreateFileW
-#else 
 #define ExtCreateFile ExtCreateFileA
-#endif
 
 typedef struct array_header_t array_header_t;
 TOOLKIT_API array_header_t *fileutil_get_sub_files_a(const char *path);
 TOOLKIT_API array_header_t *fileutil_get_sub_dirs_a(const char *path);
-TOOLKIT_API array_header_t *fileutil_get_sub_files_w(const wchar_t *path);
-TOOLKIT_API array_header_t *fileutil_get_sub_dirs_w(const wchar_t *path);
 TOOLKIT_API array_header_t *fileutil_get_sub_files2_a(const char *path, int limitation);
 TOOLKIT_API array_header_t *fileutil_get_sub_dirs2_a(const char *path, int limitation);
-TOOLKIT_API array_header_t *fileutil_get_sub_files2_w(const wchar_t *path, int limitation);
-TOOLKIT_API array_header_t *fileutil_get_sub_dirs2_w(const wchar_t *path, int limitation);
-
-#if defined(UNICODE) || defined(_UNICODE)
-#define fileutil_get_sub_files fileutil_get_sub_files_w
-#define fileutil_get_sub_dirs fileutil_get_sub_dirs_w
-#else 
 #define fileutil_get_sub_files fileutil_get_sub_files_a
 #define fileutil_get_sub_dirs fileutil_get_sub_dirs_a
-#endif
 
 /** suc:0, failed: -1*/
 TOOLKIT_API int fileutil_copy_file(const char* dest_file_path, const char* src_file_path);

Framework/libtoolkit/log_periodic.c

@@ -284,6 +284,7 @@ static int periodicfilefactory_record_log(void *self,
 				st.wHour, st.wMinute, st.wSecond, st.wMilliseconds, log_level2str(level));
 			plog->first_record = 0;
 		} else {
+			//TODO: CrossPlaform 这个不太好处理，需要直接修改WINPR中的GetCurrentThreadId原始函数，但这个函数有其他引用  [Gifur@202584]
 #if defined(_MSC_VER)
             n = sprintf(tmp, LINE_BREAK_STR "[%02d:%02d:%02d.%03d][%5u][%s] ",
                         st.wHour, st.wMinute, st.wSecond, st.wMilliseconds, GetCurrentThreadId(), log_level2str(level));

Framework/libtoolkit/memutil.c

@@ -108,21 +108,6 @@ TOOLKIT_API void debug_trace(const char *fmt, ...)
 	va_end(arg);
 }
 
-TOOLKIT_API int GetSystemErrorDesc(int error_code, char *buf, int n)
-{
-	//TODO: implement or compatible
-	DWORD dwRet = FormatMessageA(
-		FORMAT_MESSAGE_IGNORE_INSERTS | FORMAT_MESSAGE_FROM_SYSTEM,
-		NULL,
-		error_code,
-		MAKELANGID(LANG_NEUTRAL,SUBLANG_DEFAULT),
-		buf,
-		n,
-		NULL);
-	buf[dwRet] = 0;
-	return (int)dwRet;
-}
-
 //////////////////////////////////////////////////////////////////////////
 
 struct toolkit_allocator_t

Framework/libtoolkit/memutil.h

@@ -319,10 +319,6 @@ static __inline int timeval_sub(struct timeval *x, struct timeval *y)
 	return (x->tv_sec - y->tv_sec) * 1000 + (1000000 + x->tv_usec - y->tv_usec)/1000 - 1000;
 }
 
-
-TOOLKIT_API int GetSystemErrorDesc(int error_code, char *buf, int n);
-
-
 #ifdef __cplusplus
 } // extern "C" {
 #endif

Framework/libtoolkit/osutil.c

@@ -4,8 +4,6 @@
 #include "strutil.h"
 #include "toolkit.h"
 
-//#define NEW_FEATURE
-
 #ifdef _WIN32
 
 #include <TlHelp32.h>
@@ -126,6 +124,44 @@ TOOLKIT_API int osutil_uname(tk_utsname_t* buffer)
 	return TOOLKIT_UNKNOWN;
 }
 
+
+TOOLKIT_API int osutil_is32r64_platform()
+{
+	int isWow64 = -1;
+	typedef BOOL(WINAPI* LPFN_ISWOW64PROCESS)(HANDLE, PBOOL);
+	BOOL bIsWow64 = FALSE;
+	LPFN_ISWOW64PROCESS fnIsWow64Process = (LPFN_ISWOW64PROCESS)GetProcAddress(GetModuleHandle("kernel32"), "IsWow64Process");
+	if (NULL != fnIsWow64Process) {
+		if (!fnIsWow64Process(GetCurrentProcess(), &bIsWow64)) {
+			return -1;
+		}
+		else {
+			isWow64 = bIsWow64 ? 1 : 0;
+		}
+	}
+	return isWow64;
+}
+
+
+TOOLKIT_API ostuile_void_ptr osutil_sure_redirect_32sys_in_wow64()
+{
+    ostuile_void_ptr value = NULL;
+    if (osutil_is32r64_platform() == 1) {
+        if (!Wow64DisableWow64FsRedirection(&value)) {
+            value = NULL;
+        }
+    }
+    return value;
+}
+
+TOOLKIT_API void osutil_reset_redirect_32sys_in_wow64(ostuile_void_ptr* value)
+{
+    if (value != NULL && (*value) != NULL) {
+        Wow64RevertWow64FsRedirection(*value);
+    }
+    return;
+}
+
 #else
 
 #include <unistd.h>
@@ -470,6 +506,23 @@ error:
 	return r;
 }
 
+TOOLKIT_API int osutil_is32r64_platform()
+{
+    return 0;
+}
+
+TOOLKIT_API ostuile_void_ptr osutil_sure_redirect_32sys_in_wow64()
+{
+    ostuile_void_ptr value = NULL;
+    return value;
+}
+
+
+TOOLKIT_API void osutil_reset_redirect_32sys_in_wow64(ostuile_void_ptr* value)
+{
+    return;
+}
+
 #endif
 
 TOOLKIT_API int osutil_shutdown_system()
@@ -481,3 +534,5 @@ TOOLKIT_API int osutil_shutdown_system()
 
 
 
+
+

Framework/libtoolkit/osutil.h

@@ -13,6 +13,8 @@
 
 #include "config.h"
 
+typedef void* ostuile_void_ptr;
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -50,7 +52,14 @@ TOOLKIT_API void osutil_terminate_related_process(char** process_array, const in
 
 TOOLKIT_API int osutil_uname(tk_utsname_t* buffer);
 
-
+/*
+* -1:failed
+* 0:no
+* 1:yes
+*/
+TOOLKIT_API int osutil_is32r64_platform();
+TOOLKIT_API ostuile_void_ptr osutil_sure_redirect_32sys_in_wow64();
+TOOLKIT_API void osutil_reset_redirect_32sys_in_wow64(ostuile_void_ptr* value);
 #ifdef __cplusplus
 } // extern "C" {
 #endif

Framework/libtoolkit/sockutil.c

@@ -5,6 +5,7 @@
 //define replaced by cmake synatx
 //
 #if defined(_MSC_VER)
+#include <WinSock2.h>
 #pragma comment(lib, "ws2_32.lib")
 #endif //_MSC_VER
 
@@ -19,18 +20,109 @@ TOOLKIT_API int winsock_term()
 	return WSACleanup();
 }
 
-TOOLKIT_API char* get_local_ip(char *buf, int n)
+/*
+1:require
+0:option
+-1:forbid
+*/
+static int is_legal_ip(char* content)
 {
-	char name[64];
-	struct hostent * he;
-	gethostname(name, sizeof(name));
-	he = gethostbyname(name);
-	if (he) {
-		if (he->h_addr_list[0]) {
-			return strncpy(buf, inet_ntoa(*(struct in_addr*)he->h_addr_list[0]), n);
+	
+	int len = 0;
+	if (content == NULL) {
+		return -1;
+	}
+	len = strlen(content);
+	if (len < strlen("0.0.0.0")) {
+		return -1;
+	}
+	//99开头行内办公网，10开头行内业务网。规范出自《招商银行总行网络规范汇编（2017年版）.pdf》
+	if (strstr(content, "99.") == content || strstr(content, "10.") == content) {
+		return 1;
+	}
+
+	if (strcmp(content, "127.0.0.1") == 0 /*sipphone*/
+		|| strcmp(content, "2.0.0.1") == 0 /*ConnecotrFSM*/
+		|| strstr(content, "198.168.") == content /*sipphone 双网卡*/
+		) {
+		return -1;
+	}
+
+	return 0;
+}
+
+TOOLKIT_API int toolkit_getlocalip(char* buf, int len_of_buf)
+{
+	char bak_buf[64];
+#if defined(_MSC_VER)
+	memset(bak_buf, 0, 64);
+	struct hostent* ent = gethostbyname(NULL);
+	if (ent && ent->h_addr_list[0] != NULL)
+	{
+		int i = 0;
+		for (; ent->h_addr_list[i] != NULL; ++i)
+		{
+			char tmp[64];
+			int r;
+			struct in_addr* in = (struct in_addr*)ent->h_addr_list[i];
+			memset(tmp, 0, 64);
+			sprintf_s(tmp, 64, "%d.%d.%d.%d", in->S_un.S_un_b.s_b1, in->S_un.S_un_b.s_b2, in->S_un.S_un_b.s_b3, in->S_un.S_un_b.s_b4);
+			r = is_legal_ip(tmp);
+			if (r == 1) {
+				memset(buf, 0, len_of_buf * sizeof(char));
+				strcpy(buf, tmp);
+				return 0;
+			}
+			else if (r == 0 && strlen(bak_buf) == 0) {
+				strcpy(bak_buf, tmp);
+			}
+		}
+#else
+	// Same implements with:
+	// * DeviceSimulator
+	// * SipPhone
+	// 
+	int sockfd = -1;
+	struct ifconf ifconf;
+	struct ifreq* ifreq = NULL;
+	char strbuf[256] = { 0 };
+	int i;
+	memset(bak_buf, 0, 64);
+	ifconf.ifc_len = 256;
+	ifconf.ifc_buf = strbuf;
+	if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) >= 0) {
+		if (ioctl(sockfd, SIOCGIFCONF, &ifconf) >= 0) { //get all socket info
+			for (i = (ifconf.ifc_len / sizeof(struct ifreq)); i > 0; i--) {
+				ifreq = (struct ifreq*)&ifconf.ifc_req[i];
+				if (ifreq->ifr_addr.sa_family == AF_INET) { //for ipv4
+					struct sockaddr_in* addr = (struct sockaddr_in*)&ifreq->ifr_addr;
+					char tmp[INET_ADDRSTRLEN];
+					int r = 0;
+					memset(tmp, 0, sizeof(tmp));
+					inet_ntop(AF_INET, &addr->sin_addr, tmp, INET_ADDRSTRLEN);
+					r = is_legal_ip(tmp);
+					if (r == 1) {
+						memset(buf, 0, len_of_buf * sizeof(char));
+						strcpy(buf, tmp);
+						close(sockfd);
+						return 0;
+					}
+					else if (r == 0 && strlen(bak_buf) == 0) {
+						strcpy(bak_buf, tmp);
+					}
+				}
+			}
+		}
+		close(sockfd);
+#endif //_MSC_VER
+
+		if (strlen(bak_buf) > 0) {
+			memset(buf, 0, len_of_buf * sizeof(char));
+			strcpy(buf, bak_buf);
+			return 0;
 		}
 	}
-	return NULL;
+	return -1;
 }
 
 // < 0 : error

Framework/libtoolkit/sockutil.h

@@ -15,7 +15,8 @@ TOOLKIT_API int winsock_init();
 
 TOOLKIT_API int winsock_term();
 
-TOOLKIT_API char* get_local_ip(char *buf, int n);
+/*return 0 if get ip succ and the buf store the ip, otherwise return the error */
+TOOLKIT_API int toolkit_getlocalip(char *buf, int len_of_buf);
 
 // < 0 : error
 // < n : timeout

Framework/libtoolkit/synch.c

@@ -1,61 +0,0 @@
-#include "synch.h"
-/*
-
-#include "memutil.h"
-
-TOOLKIT_API int toolkit_mutex_create(toolkit_mutex_t** p_mutex)
-{
-	toolkit_mutex_t* mutex;
-	mutex = MALLOC_T(toolkit_mutex_t);
-	*p_mutex = mutex;
-	return 0;
-}
-
-TOOLKIT_API int toolkit_mutex_init(toolkit_mutex_t* mutex)
-{
-#ifdef _WIN32
-	InitializeCriticalSection(mutex);
-#else
-#endif
-	FREE(mutex);
-	return 0;
-}
-
-TOOLKIT_API void toolkit_mutex_destroy(toolkit_mutex_t* mutex)
-{
-#ifdef _WIN32
-	DeleteCriticalSection(mutex);
-#else
-#endif
-}
-
-TOOLKIT_API void toolkit_mutex_lock(toolkit_mutex_t* mutex)
-{
-#ifdef _WIN32
-	EnterCriticalSection(mutex);
-#else
-#endif
-}
-
-TOOLKIT_API int toolkit_mutex_trylock(toolkit_mutex_t* mutex)
-{
-#ifdef _WIN32
-	if(TryEnterCriticalSection(mutex))
-	{
-		return 0;
-	}
-	return -1;
-#else
-#endif
-	return 0;
-}
-
-TOOLKIT_API void toolkit_mutex_unlock(toolkit_mutex_t* mutex)
-{
-#ifdef _WIN32
-	LeaveCriticalSection(mutex);
-#else
-#endif
-}
-
-*/

Framework/libtoolkit/synch.h

@@ -1,25 +0,0 @@
-#ifndef TOOLKIT_SYNCH_H
-#define TOOLKIT_SYNCH_H
-
-#include "config.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-	
-	//TOOLKIT_API int toolkit_mutex_create(toolkit_mutex_t** p_mutex);
-	//TOOLKIT_API int toolkit_mutex_init(toolkit_mutex_t* mutex);
-	//TOOLKIT_API void toolkit_mutex_destroy(toolkit_mutex_t* mutex);
-
-	//TOOLKIT_API void toolkit_mutex_lock(toolkit_mutex_t* mutex);
-	//TOOLKIT_API int toolkit_mutex_trylock(toolkit_mutex_t* mutex);
-	//TOOLKIT_API void toolkit_mutex_unlock(toolkit_mutex_t* mutex);
-
-
-#ifdef __cplusplus
-}
-#endif
-
-
-#endif //TOOLKIT_SYNCH_H

Framework/libtoolkit/test/test_synch.cpp

@@ -1,7 +0,0 @@
-#include "synch.h"
-#include <gtest/gtest.h>
-
-TEST(SynchronizeObjectTest, MutexTest) {
-	
-	
-}

Framework/libtoolkit/toolkit.c

@@ -153,146 +153,6 @@ void toolkit_free_cpu_info(toolkit_cpu_info_t* cpu_infos, int count)
 }
 
 
-size_t toolkit_mbs2wcs(const char* src, wchar_t* dst, size_t dst_size)
-{
-#ifdef _MSC_VER
-    wchar_t* wstr = NULL;
-    int n = MultiByteToWideChar(CP_ACP, 0, src, -1, NULL, 0);
-    if (n > 0) {
-        wstr = malloc(sizeof(wchar_t) * (n + 1));
-        if (wstr == NULL) {
-            return 0;
-        }
-        memset(wstr, 0, (n + 1) * sizeof(wchar_t));
-        MultiByteToWideChar(CP_ACP, 0, src, -1, &wstr[0], n);
-        wcscpy(dst, wstr);
-        FREE(wstr);
-        return n;
-    }
-    return 0;
-
-#else
-
-    unsigned len = 0;
-    wchar_t* p = NULL;
-    if (strlen(src) == 0) {
-        return 0;
-    }
-    const char* origin = setlocale(LC_CTYPE, NULL);
-    WLog_DBG(TAG, "%s: origin locale: %s, data:%s", __FUNCTION__, origin, src);
-    setlocale(LC_CTYPE, "");
-
-    len = mbstowcs(NULL, src, 0);
-    if (len == -1) {
-        WLog_DBG(TAG, "mbstowcs failed: %d", errno);
-        goto on_end;
-    }
-    len += 1;
-
-    if (dst == NULL) {
-        WLog_DBG(TAG, "mbstowcs to fetch need capacity: %d", len);
-        goto on_end;
-    }
-
-    p = malloc(sizeof(wchar_t) * len);
-    wmemset(p, 0,  len);
-
-    len = mbstowcs(p, src, len);
-    if (len == -1) {
-        WLog_DBG(TAG, "mbstowcs after new malloc failed: %d", errno);
-        goto on_del;
-    }
-    wmemset(dst, 0, dst_size);
-    wcscpy(dst, p);
-    len = wcslen(dst);
-    WLog_DBG(TAG, "after mbstowcs returned: %ls(%d)", dst, len);
-
-on_del:
-
-    free(p);
-
-on_end:
-
-    setlocale(LC_CTYPE, origin);
-    return len;
-
-#endif
-}
-
-size_t toolkit_wcs2mbs(const wchar_t* src, char* dst, size_t dst_size)
-{
-#if defined(_MSC_VER)
-    char* str = NULL;
-    int n = 0;
-
-    n = WideCharToMultiByte(CP_ACP, 0, src, -1, NULL, 0, NULL, NULL);
-    if (n > 0) {
-        str = malloc(sizeof(char) * (n + 1));
-        if (str == NULL) {
-            return 0;
-        }
-        memset(str, 0, sizeof(char) * (n + 1));
-        WideCharToMultiByte(CP_ACP, 0, src, -1, &str[0], n, NULL, NULL);
-        memset(dst, 0, sizeof(char) * (dst_size));
-        strcpy(dst, str);
-        FREE(str);
-        return n;
-    }
-    return 0;
-
-#else
-
-    unsigned len;
-    char* str = NULL;
-    char* origin = NULL;
-
-    len = wcslen(src);
-    if (len == 0) {
-        return 0;
-    }
-    origin = setlocale(LC_CTYPE, NULL);
-    WLog_DBG(TAG, "%s: origin locale: %s, data: %ls", __FUNCTION__, origin, src);
-    setlocale(LC_CTYPE, "");
-
-    len = wcstombs(NULL, src, 0);
-    if (len == -1) {
-        WLog_DBG(TAG, "wcstombs failed: %d", errno);
-        goto on_end;
-    }
-    len += 1;
-
-    if (dst == NULL) {
-        WLog_DBG(TAG, "wcstombs to fetch need capacity: %d", len);
-        goto on_end;
-    }
-
-    str = malloc(sizeof(char) * len);
-    memset(str, 0, len * sizeof(char));
-
-    len = wcstombs(str, src, len);
-    if (len == -1) {
-        WLog_DBG(TAG, "wcstombs after new malloc failed: %d", errno);
-        goto on_del;
-    }
-
-    memset(dst, 0, dst_size * sizeof(char));
-    strcpy(dst, str);
-    len = strlen(dst);
-    WLog_DBG(TAG, "after wcstombs returned: %s(%d)", dst, len);
-
-on_del:
-
-    free(str);
-
-on_end:
-
-    setlocale(LC_CTYPE, origin);
-    return len;
-
-#endif //_MSC_VER
-}
-
-
 /** WARNING: need to FREE the copy msg!!!!*/
 static const char* toolkit__unknown_err_code(int err)
 {

Framework/libtoolkit/toolkit.h

@@ -286,9 +286,6 @@ extern "C" {
 
     TOOLKIT_API void toolkit_sleep(int msec);
 
-    TOOLKIT_API size_t toolkit_mbs2wcs(const char* src, wchar_t* dst, size_t dst_size);
-    TOOLKIT_API size_t toolkit_wcs2mbs(const wchar_t* src, char* dst, size_t dst_size);
-
     TOOLKIT_API int toolkit_os_getpriority(toolkit_pid_t pid, int* priority);
     TOOLKIT_API int toolkit_os_setpriority(toolkit_pid_t pid, int priority);
 
@@ -296,6 +293,4 @@ extern "C" {
 } // extern "C" {
 #endif
 
-#include "winfit.h"
-
 #endif //__TOOLKIT_GLOBAL_H__

Framework/libtoolkit/win/bus.c

@@ -513,7 +513,6 @@ TOOLKIT_API int bus_endpt_create(const char* url, int epid, const bus_endpt_call
 		goto on_error;
 	rc = recv_pkt_raw(endpt, &ans_buf);
 	if (rc != 0) {
-		DWORD dwError = GetLastError();
 		goto on_error;
 	}
 	iobuffer_read(ans_buf, IOBUF_T_I4, &v, 0);
@@ -731,7 +730,6 @@ static int recv_until(bus_endpt_t* endpt, int type, iobuffer_t** p_ansbuf)
 		if (!endpt->rx_pending) {
 			rc = start_read_pkt(endpt, &ans_pkt);
 			if (rc < 0) {
-				DWORD dwError = WSAGetLastError();
 				break;
 			}
 		}

Framework/libtoolkit/win/error.c

@@ -112,7 +112,7 @@ int toolkit_translate_sys_error(int sys_errno) {
 
 
 /*
- * Display an error message and abort the event loop.
+ * Display an error message and abort the routine.
  */
 void toolkit_fatal_error(const int errorno, const char* syscall) 
 {

Framework/libtoolkit/win/ioqueue.c

@@ -391,8 +391,6 @@ static void dispatch_acceptor(int err,
 							  ioqueue_acceptor_t *acceptor, 
 							  ioqueue_accept_overlapped_t *overlapped)
 {
-	ioqueue_t *ioq = acceptor->owner;
-
 	if (err == 0) {
 		/* only valid for winxp or later, ignore return value */
 		setsockopt(overlapped->client, SOL_SOCKET, SO_UPDATE_ACCEPT_CONTEXT, 
@@ -415,7 +413,6 @@ static void dispatch_pipe_acceptor(int err,
 								   ioqueue_pipe_acceptor_t *acceptor, 
 								   ioqueue_connectpipe_overlapped_t *overlapped)
 {
-	ioqueue_t *ioq = acceptor->owner;
 	int accepted;
 
 	CloseHandle(overlapped->hevt);

Framework/libtoolkit/win/util.c

@@ -473,7 +473,9 @@ void toolkit_free_interface_addresses(toolkit_interface_address_t* addresses, in
 {
     FREE(addresses);
 }
-
+/* Emulate snprintf() on MSVC<2015, _snprintf() doesn't zero-terminate the buffer
+ * on overflow...
+ */
 #if (!defined(_MSC_VER )) || (_MSC_VER < 1928)
 int snprintf(char* buf, size_t len, const char* fmt, ...)
 {

Framework/libtoolkit/winfit.h

@@ -1,20 +0,0 @@
-#ifndef _TOOLKIT_WIN_FIT_H_
-#define _TOOLKIT_WIN_FIT_H_
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-	static uint64_t get_tick_count() 
-	{
-		
-		/** nano sec to sec*/
-		return toolkit_hrtime() / 1000000;
-
-	}
-
-#ifdef __cplusplus
-} // extern "C" {
-#endif
-
-#endif // !_TOOLKIT_WIN_FIT_H_

Framework/spbase/SpBase.cpp

@@ -28,8 +28,6 @@
 
 #ifdef RVC_OS_WIN
 #include "sp_checkEntity.h"
-
-#pragma comment(lib, "dbghelp.lib")
 #include <DbgHelp.h>
 #else
 #include <exception>
@@ -113,7 +111,7 @@ static LONG WINAPI SuppressError(struct _EXCEPTION_POINTERS* ExceptionInfo)
 
 		MINIDUMP_TYPE mdt       = MiniDumpWithIndirectlyReferencedMemory; 
 
-		BOOL rv = MiniDumpWriteDump( GetCurrentProcess(), GetCurrentProcessId(), 
+		MiniDumpWriteDump( GetCurrentProcess(), GetCurrentProcessId(), 
 			hDumpFile, mdt, (ExceptionInfo != 0) ? &mdei : 0, 0, 0 ); 
 		CloseHandle( hDumpFile );
 	}
@@ -388,7 +386,7 @@ SPBASE_API void LogAssert(const char* pszMessage, const char* pszFile, const int
 		pModule->LogMessage(Log_Debug, Severity_Middle, 0, 0,
 			CSimpleStringA::Format("assert fail: {%s}, file: {%s}, line: {%d}, stack: {%s}",
 				pszMessage, _GetFileName(pszFile), nLine,
-#ifdef _WIN32
+#ifdef RVC_OS_WIN
                 (const char*)DumpStack(2)
 #else
                  "not implement, TODO:"
@@ -399,7 +397,7 @@ SPBASE_API void LogAssert(const char* pszMessage, const char* pszFile, const int
 	// write a copy in dbg log
 	DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__).setVtmCode(DWORD2Hex(ERR_ENTITY_ASSERT).GetData())("Assert fail: {%s}, file: {%s}, line: {%d}, stack: {%s}",
 		pszMessage, _GetFileName(pszFile), nLine,
-#ifdef _WIN32
+#ifdef RVC_OS_WIN
         (const char*)DumpStack(2)
 #else
          "not implement, TODO:"
@@ -725,8 +723,9 @@ extern "C" SPBASE_API const char* SpStrError(ErrorCodeEnum errorCode)
 	return sp_strerror((int)errorCode);
 }
 
-SPBASE_API CSimpleStringA GetSysErrMsg(int nErrCode)
+SPBASE_API CSimpleStringA GetSysErrMsg(DWORD nErrCode)
 {
+#if defined(RVC_OS_WIN)
 	char szBuf[2048] = {};
 	DWORD dwRet = FormatMessageA(
 		FORMAT_MESSAGE_IGNORE_INSERTS | FORMAT_MESSAGE_FROM_SYSTEM,
@@ -734,21 +733,28 @@ SPBASE_API CSimpleStringA GetSysErrMsg(int nErrCode)
 		nErrCode,
 		MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
 		szBuf,
-		sizeof(szBuf)-1,
+		sizeof(szBuf) - 1,
 		NULL);
 
-	char *p = strrchr(szBuf, '\r');
+	char* p = strrchr(szBuf, '\r');
 	if (p != NULL)
 		*p = ' ';
-	
+
 	p = strrchr(szBuf, '\n');
 	if (p != NULL)
 		*p = ' ';
 
 	return dwRet > 0 ? szBuf : CSimpleStringA::Format("get error message fail: %d", GetLastError());
+
+#else
+	
+	std::string szBuf(strerror(nErrCode));
+	return szBuf.c_str();
+
+#endif //RVC_OS_WIN
 }
 
-SPBASE_API const char *_GetFileName(const char *pszFilePath)
+extern "C" SPBASE_API const char *_GetFileName(const char *pszFilePath)
 {
 	int i=strlen(pszFilePath);
 	for( ; i>0 && pszFilePath[i-1]!=SPLIT_SLASH; i--)NULL;

Framework/spbase/SpEntity.cpp

@@ -4,7 +4,6 @@
 #include "SpTimer.h"
 #include "SpMisc.h"
 #include "SpHelper.h"
-#include "SpBinaryPersistStream.h"
 #include "SpEntity.h"
 #include "SpModule.h"
 #include "SpAsyncWait.h"
@@ -28,13 +27,13 @@
 #include "toolkit.h"
 #include "dbgutil.h"
 #include "def.h"
-#ifdef _WIN32
+#ifdef RVC_OS_WIN
 #include "CodeSignVerify.h"
 #include "sp_checkEntity.h"
 #include "sp_firewallControl.h"
 #else
 #include "sp_dbg_export.h"
-#endif //_WIN32
+#endif //RVC_OS_WIN
 #include "sp_httpDefine.h"
 #include <iostream>
 #include <sstream>
@@ -54,12 +53,12 @@ static void var_callback(sp_var_listener_t *listener,
 	ISysVarListener *pListener = (ISysVarListener *)user_data;
 	SpEntity *pEntity = (SpEntity*)sp_var_listener_get_tag(listener);
 
-#ifdef _WIN32
+#ifdef RVC_OS_WIN
 	SetthreadGroup(GetCurrentThreadId(), pEntity->get_cfg_ent()->name);
 	getEntityResource()->m_Entity = pEntity;
 #else
 	GetSpModule()->SetThreadEntity(pEntity);
-#endif //_WIN32
+#endif //RVC_OS_WIN
 
 	sp_env_t *env = sp_get_env();
 	sp_entity_t *ent = sp_mod_mgr_find_entity_by_idx(env->mod_mgr, client_id);
@@ -89,12 +88,12 @@ static void bcm_callback(sp_bcm_listener_t *listener,
 	SpEntity *pEntity = (SpEntity*)sp_bcm_listener_get_tag(listener);
 	sp_uid_t uid;
 
-#ifdef _WIN32
+#ifdef RVC_OS_WIN
 	SetthreadGroup(GetCurrentThreadId(), pEntity->get_cfg_ent()->name);
 	getEntityResource()->m_Entity = pEntity;
 #else
 	GetSpModule()->SetThreadEntity(pEntity);
-#endif //_WIN32
+#endif //RVC_OS_WIN
 
 	sp_bcm_listener_get_uid(listener, &uid);
 
@@ -172,7 +171,7 @@ static void task_callback(threadpool_t *threadpool, void *arg, param_size_t para
 	ITaskSp *pTask = (ITaskSp*)arg;
 	SpEntity *pEntity = (SpEntity*)param1;
 
-#ifdef _WIN32
+#ifdef RVC_OS_WIN
 	SetthreadGroup(GetCurrentThreadId(), pEntity->GetEntityBase()->GetEntityName());
 	try {
 		getEntityResource()->m_Entity = pEntity;
@@ -188,7 +187,7 @@ static void task_callback(threadpool_t *threadpool, void *arg, param_size_t para
 	GetSpModule()->SetThreadEntity(pEntity);
 	pTask->Process();
 	pTask->DecRef();
-#endif //_WIN32
+#endif //RVC_OS_WIN
 }
 
 static void tpool_log(threadpool_t *threadpool, const char* str)
@@ -235,9 +234,9 @@ SpEntity::~SpEntity()
 {
 	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("run ~SpEntity()");
     if (m_ent != nullptr && m_pEntityBase != nullptr) {
-#ifdef _WIN32
+#ifdef RVC_OS_WIN
         getEntityResource()->m_Entity = NULL;
-#endif //_WIN32
+#endif //RVC_OS_WIN
     }
 }
 
@@ -261,9 +260,9 @@ ErrorCodeEnum SpEntity::Init()
 	threadpool_set_thread_decorator(m_tpool, &SpEntity::__on_thread_init, &SpEntity::__on_thread_term, this);
 	threadpool_start(m_tpool, 0, 64, 5*60*1000, 0);
 
-#ifdef _WIN32
+#ifdef RVC_OS_WIN
 	setModuleAliasName(GetEntityBase()->GetEntityName());
-#endif //_WIN32
+#endif //RVC_OS_WIN
 
 	rc = sp_svc_start(m_svc);
 	if (rc != 0) {
@@ -517,44 +516,47 @@ int SpEntity::on_accept(int epid, int svc_id, int conn_id, iobuffer_t **conn_pkt
 
 void SpEntity::on_thread_init()
 {
-#ifdef _WIN32
+#ifdef RVC_OS_WIN
 	SetthreadGroup(GetCurrentThreadId(), this->get_cfg_ent()->name);
 	getEntityResource()->m_Entity = this;
 #else
 	m_pModule->SetThreadEntity(this);
-#endif //_WIN32
+#endif //RVC_OS_WIN
 }
 
 void SpEntity::on_thread_term()
 {
-#ifdef _WIN32
+#ifdef RVC_OS_WIN
 	SetthreadGroup(GetCurrentThreadId(), this->get_cfg_ent()->name);
 	getEntityResource()->m_Entity = NULL;
 #else
 	m_pModule->SetThreadEntity(NULL);
-#endif //_WIN32
+#endif //RVC_OS_WIN
 }
 
 void SpEntity::__on_thread_init(threadpool_t *, void *arg)
 {
 	SpEntity *pThis = static_cast<SpEntity*>(arg);
 	pThis->on_thread_init();
-#ifndef _WIN32
-	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("thread init, thread id:%u", GetCurrentThreadIdFromSys());
+	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("thread init, thread id:%u",
+#ifndef RVC_OS_WIN
+	 GetCurrentThreadIdFromSys());
 #else
-	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("thread init, thread id:%d", GetCurrentThreadId());
-#endif //NOT _WIN32
+	 GetCurrentThreadId());
+#endif //NOT RVC_OS_WIN
 }
 
 void SpEntity::__on_thread_term(threadpool_t *, void *arg)
 {
 	SpEntity *pThis = static_cast<SpEntity*>(arg);
 	pThis->on_thread_term();
-#if defined(_MSC_VER)
-	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("thread term, thread id:%d", GetCurrentThreadId());
+
+	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("thread term, thread id:%d", 
+#if defined(RVC_OS_WIN)
+		GetCurrentThreadId());
 #else
-	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("thread term, thread id:%u", GetCurrentThreadIdFromSys());
-#endif //_MSC_VER
+	GetCurrentThreadIdFromSys());
+#endif //RVC_OS_WIN
 }
 
 ErrorCodeEnum SpEntity::SetTimer(DWORD nTimerID, ITimerListener *pListener, DWORD dwInterval)
@@ -681,140 +683,6 @@ ErrorCodeEnum SpEntity::GetTimerInterval(DWORD nTimerID, DWORD &dwInterval)
 	return Error;
 }
 
-ErrorCodeEnum SpEntity::ReadPersistObject(const char *pszClass, const char *pszKey, IEntityPersistObject *pInstance)
-{
-	sp_env_t *env = sp_get_env();
-	sp_pst_tree_t *tree;
-	int rc;
-
-	if (!pszClass || !pszKey || !pInstance)
-		return Error_Param;
-
-	rc = sp_pst_tree_load(env->dir->obj_path, m_ent->cfg->name, pszClass, pszKey, &tree);
-	if (rc == 0) {
-		sp_pst_elem_t *root = sp_pst_tree_get_root(tree);
-		CSmartPointer<IEntityPersistStreamRead> pStream;
-		pStream.Attach(new SpBinaryPersistStream(SpBinaryPersistStream::Read, root));
-		rc = (int)pInstance->OnRead(pStream);
-		sp_pst_tree_destroy(tree);
-	}
-	
-	return SpTranslateError(rc);
-}
-
-ErrorCodeEnum SpEntity::WritePersistObject(const char *pszClass, const char *pszKey, const IEntityPersistObject *pInstance)
-{
-	sp_env_t *env = sp_get_env();
-	sp_pst_elem_t *root;
-	int rc;
-
-	if (!pszClass || !pszKey || !pInstance)
-		return Error_Param;
-
-	root = sp_pst_elem_create(NULL, pszKey);
-	CSmartPointer<IEntityPersistStreamWrite> pStream;
-	pStream.Attach(new SpBinaryPersistStream(SpBinaryPersistStream::Write, root));
-	rc = (int)pInstance->OnWrite(pStream);
-	if (rc == 0) {
-		sp_pst_tree_t *tree;
-		sp_pst_tree_create(&tree);
-		sp_pst_tree_set_root(tree, root);
-		rc = sp_pst_tree_save(env->dir->obj_path, m_ent->cfg->name, pszClass, pszKey, tree);
-		sp_pst_tree_destroy(tree);
-	} else {
-		sp_pst_elem_destroy(root);
-	}
-
-	return SpTranslateError(rc);
-}
-
-ErrorCodeEnum SpEntity::ReadNumOfPersistObject(const char *pszClassName,DWORD &nNum)
-{
-	if (!pszClassName)
-		return Error_Param;
-	sp_env_t *env = sp_get_env();
-	int cnt;
-	int rc = sp_pst_get_object_count(env->dir->obj_path, m_ent->cfg->name, pszClassName, &cnt);
-	if (rc == 0) 
-		nNum = (DWORD)cnt;
-	return SpTranslateError(rc);
-}
-
-ErrorCodeEnum SpEntity::GetPersistClassObjectKeys(const char *pszClassName, CAutoArray<CSimpleStringA> &strKeys)
-{
-	if (!pszClassName)
-		return Error_Param;
-	sp_env_t *env = sp_get_env();
-	array_header_t *arr = sp_pst_get_object_keys(env->dir->obj_path, m_ent->cfg->name, pszClassName);
-	if (arr) {
-		strKeys.Init(arr->nelts);
-		for (int i = 0; i < arr->nelts; ++i)
-			strKeys[i] = ARRAY_IDX(arr, i, char*);
-		array_free2(arr);
-	} else {
-		strKeys.Init(0);
-	}
-	return Error_Succeed;
-}
-
-ErrorCodeEnum SpEntity::DeleteKeyOfPersistObject(const char *pszClassName,const char *pszKey)
-{
-	if (!pszClassName || !pszKey)
-		return Error_Param;
-	sp_env_t *env = sp_get_env();
-	int rc = sp_pst_delete_object(env->dir->obj_path, m_ent->cfg->name, pszClassName, pszKey);
-	return SpTranslateError(rc);
-}
-
-ErrorCodeEnum SpEntity::EnumKeyOfPersistObject(const char *pszClass,CSimpleStringA &strKey,DWORD &handle)
-{
-	if (!pszClass)
-		return Error_Param;
-	int rc = 0;
-	sp_env_t *env = sp_get_env();
-	struct HelperIterator {
-		array_header_t *arr;
-		int Current;
-	} * pIterator = NULL;
-	if (handle == 0) {
-		pIterator = new HelperIterator();
-		pIterator->arr = sp_pst_get_object_keys(env->dir->obj_path, m_ent->cfg->name, pszClass);
-		if (!pIterator->arr) {
-			delete pIterator;
-			return Error_NotExist;
-		}
-		pIterator->Current = 0;
-#if defined(_MSC_VER)
-		handle = (DWORD)pIterator;
-#else
-		//TODO: x64 environment, depend on how to use the out-param
-		handle = (uintptr_t)(static_cast<void*>(pIterator));
-#endif //_MSC_VER
-	} else {
-		pIterator = (HelperIterator *)handle;
-	}
-	if (pIterator->Current < pIterator->arr->nelts) {
-		strKey = ARRAY_IDX(pIterator->arr, pIterator->Current, char*);
-		pIterator->Current++;
-	} else {
-		if (pIterator->arr)
-			array_free2(pIterator->arr);
-		delete pIterator;
-		handle = 0; // zero handle
-		rc = Error_NotExist;// the end
-	}
-	return SpTranslateError(rc);
-}
-
-ErrorCodeEnum SpEntity::CleanAllOfPersistObject(const char *pszClass)
-{
-	if (!pszClass)
-		return Error_Param;
-	sp_env_t *env = sp_get_env();
-	int rc = sp_pst_delete_class_objects(env->dir->obj_path, m_ent->cfg->name, pszClass);
-	return SpTranslateError(rc);
-}
-
 ErrorCodeEnum SpEntity::SubscribeLog(CUUID &SubscribeID, ILogListener *pListener,LogTypeEnum eLogType,
 					                  SeverityLevelEnum eLevel, ErrorCodeEnum eSysError,DWORD dwUserCode,
 					                  const char *pszEntityName,bool bIgnoreMessage)
@@ -1255,6 +1123,22 @@ DWORD SpEntity::GetUserDefineState()
     return (DWORD)(m_ent->user_state);
 }
 
+MachineTypeEnum SpEntity::GetMachineType(CSimpleStringA* outStrMachine)
+{
+	MachineTypeEnum machineType(RVC_Unknown);
+	CSystemStaticInfo stStaticinfo;
+	CSimpleStringA strMachineType(true);
+	auto rc = GetSystemStaticInfo(stStaticinfo);
+	if (rc == Error_Succeed) {
+		strMachineType = stStaticinfo.strMachineType;
+		machineType = SpStr2MachineType(strMachineType);
+	}
+	if (outStrMachine != NULL) {
+		(*outStrMachine) = strMachineType.GetData();
+	}
+	return machineType;
+}
+
 ErrorCodeEnum SpEntity::GetSystemStaticInfo(CSystemStaticInfo &Info)
 {
 	sp_env_t *env = sp_get_env();
@@ -1756,7 +1640,7 @@ ErrorCodeEnum SpEntity::SetNewPathToFirewall(CSimpleString &pszPath, int maxWait
 	}
 
 
-#ifdef _WIN32
+#ifdef RVC_OS_WIN
 	auto addFirewall_worker = [this](std::string path)
 	{
 		return sp_AddFirewallRuleByPath(path.c_str()) ? Error_Succeed : Error_Bug;
@@ -2046,7 +1930,7 @@ ErrorCodeEnum SpEntity::VerifySignature(const char *pszSignedFile, CSimpleString
 
 ErrorCodeEnum SpEntity::ShowFatalError(const char *pszMsg, SeverityLevelEnum eLevel)
 {
-
+	//TODO:   [Gifur@2025730]
 #if defined(RVC_OS_WIN)
 	LogError(Severity_High, Error_Unrecover, 0, pszMsg);
 #endif //RVC_OS_WIN

Framework/spbase/SpEntity.h

@@ -64,15 +64,6 @@ public:
 	virtual ErrorCodeEnum ResetTimer(DWORD dwTimerID, DWORD dwInterval);
 	virtual ErrorCodeEnum GetTimerInterval(DWORD dwTimerID, DWORD &dwInterval);
 
-	// persist
-	virtual ErrorCodeEnum ReadPersistObject(const char *pszClass, const char *pszKey, IEntityPersistObject *pInstance);
-	virtual ErrorCodeEnum WritePersistObject(const char *pszClass, const char *pszKey, const IEntityPersistObject *pInstance);
-	virtual ErrorCodeEnum ReadNumOfPersistObject(const char *pClassName,DWORD &nNum);
-	virtual ErrorCodeEnum GetPersistClassObjectKeys(const char *pClassName, CAutoArray<CSimpleStringA> &Keys);
-	virtual ErrorCodeEnum DeleteKeyOfPersistObject(const char *pClassName,const char *pszKey);
-	virtual ErrorCodeEnum EnumKeyOfPersistObject(const char *pClassName,CSimpleStringA &strKey,DWORD &Handle);
-	virtual ErrorCodeEnum CleanAllOfPersistObject(const char *pClassName);
-
 	// log
 	virtual ErrorCodeEnum SubscribeLog(CUUID &SubscribeID, ILogListener *pListener,LogTypeEnum eLogType=Log_Ignore,SeverityLevelEnum eLevel=Severity_None, 
 		ErrorCodeEnum eSysError=Error_IgnoreAll,DWORD dwUserCode=0,const char *pszEntityName=NULL,bool bIgnoreMessage=true);
@@ -103,6 +94,7 @@ public:
 	virtual ErrorCodeEnum OpenConfig(ConfigTypeEnum eConfigType,CSmartPointer<IConfigInfo> &pConfigInfo, bool forceFile);
 
 	// gets
+	virtual MachineTypeEnum GetMachineType(CSimpleStringA* outStrMachine = NULL);
 	virtual ErrorCodeEnum GetSystemStaticInfo(CSystemStaticInfo &Info);
 	virtual ErrorCodeEnum GetInstallInfo(CVersion Version,CInstallInfo &Info);
 	virtual ErrorCodeEnum GetPath(const char *pszKey,CSimpleStringA &strPath);

Framework/spbase/SpFSM.cpp

@@ -43,9 +43,9 @@ static void __fsm_cb(threadpool_t *threadpool, void *arg, param_size_t param1, p
 static void __tmr_cb(sp_tmr_t *timer, int err, void *user_data)
 {
 	FSMTimer *pTimer = static_cast<FSMTimer*>(user_data);
-#ifdef _WIN32
+#ifdef RVC_OS_WIN
 	SetThreadGroupByResource(GetCurrentProcessId(), timer);
-#endif //_WIN32
+#endif //RVC_OS_WIN
 	try
 	{
 		if (!err) {

Framework/spbase/SpHelper.cpp

@@ -883,5 +883,25 @@ SPBASE_API LPCTSTR SpStrAppBootState(const AppBootStateEnum state)
 	return content;
 }
 
+SPBASE_API MachineTypeEnum SpStr2MachineType(const CSimpleStringA& strMachineType)
+{
+	MachineTypeEnum machineType(RVC_Unknown);
+	if (!strMachineType.IsNullOrEmpty()) {
+		if (_stricmp(strMachineType, "RVC.Stand2S") == 0) {
+			machineType = RVC_Stand2S;
+		}
+		else if (_stricmp(strMachineType, "RVC.Stand1SPlus") == 0) {
+			machineType = RVC_Stand1SPlus;
+		}
+		else if (_stricmp(strMachineType, "RVC.CardStore") == 0) {
+			machineType = RVC_CardStore;
+		}
+		else if (_stricmp(strMachineType, "RVC.CardPrinter") == 0) {
+			machineType = RVC_CardPrinter;
+		}
+	}
+	return machineType;
+}
+
 #undef ENT_ENUM_MAP
 

Framework/spbase/SpSecureClient.cpp

@@ -167,107 +167,6 @@ bool SpSecureClient::Connect(const char *pServerAddr, int nPort, int nOption) //
 	return result;
 }
 
-// 使用配置项连接, 连接参数从实体配置文件中读取 [Main]/Server和[Main]/Server_Backup项
-// @option：1、重新鉴权新建会话密钥；2、通过握手使用缓存会话密钥；
-// 3、不使用会话密钥，即非安全通道;	 4、不协商，直接使用共享会话密钥
-bool SpSecureClient::ConnectFromConfig(int nOption)
-{
-	DbgWithLink_DualActive("ConnectFromConfig has been deprecated.");
-	return false;
-
-	if (IsConnectionOK())
-		return true;
-
-	const char* pEntityName = m_pEntity->GetEntityName();
-	ENTITY_CONNECT_INFO connectInfo;
-	if (!readConnectInfoFromConfig(pEntityName, &connectInfo))
-	{
-		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("Read %s Info Failed", pEntityName);
-		return false;
-	}
-
-	// 判断当前是否已经准入，已准入时强制使用加密通道
-	int nActOption = nOption;
-
-	CSimpleStringA strVal;
-	const ErrorCodeEnum result = m_pEntity->GetFunction()->GetSysVar("EntryPermit", strVal);
-	if (Error_Succeed == result) {
-        if (strVal == "L" && stricmp(pEntityName, "AccessAuthorization") != 0 && stricmp(pEntityName, "Initializer") != 0)
-            nActOption = 2;	// 优先使用缓存密钥
-	}
-
-	if (1 == connectInfo.m_DualActive)
-		return Connect_Dual(&connectInfo, nOption);
-	else
-		return Connect_Single(&connectInfo, nOption);
-}
-
-bool SpSecureClient::readConnectInfoFromConfig(const char *pEntityName, ENTITY_CONNECT_INFO *connectInfo)
-{
-	if (NULL == pEntityName || NULL == connectInfo)
-		return false;
-
-	connectControl *entityConnect = connectControl::getInstance();
-	bool readSuccess = entityConnect->getEntityInfo(pEntityName, connectInfo);
-
-	auto pFunc = m_pEntity->GetFunction();
-	CSmartPointer<IConfigInfo> spConfig;
-	if (Error_Succeed != pFunc->OpenConfig(Config_CenterSetting, spConfig))
-	{
-		//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("open center setting config fail");
-		return false;
-	}
-
-	CSimpleStringA str;
-	int readEach = 0;
-	if (Error_Succeed == spConfig->ReadConfigValue("SpBase", "ReadEach", str) && !str.IsNullOrEmpty())
-		readEach = atoi(str);
-	if (0 == readEach && readSuccess)
-		return true;//不是每次都读取新的Entity的IP和Port，只在实体启动时读取一次
-
-	int dualActive = -1;
-	if (Error_Succeed == spConfig->ReadConfigValue("SpBase", "DualActive", str) && !str.IsNullOrEmpty())
-		dualActive = atoi(str);
-
-
-	if (Error_Succeed != pFunc->OpenConfig(Config_Software, spConfig))
-	{
-		//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("open entity config fail");
-		return false;
-	}
-
-	if (Error_Succeed != spConfig->ReadConfigValue("Main", "Server", str) || str.IsNullOrEmpty())
-	{
-		//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("read Main::Server config fail");
-		return false;
-	}
-
-	CSimpleStringA strServer1;
-	int nServer1Port;
-	if (Error_Succeed != ParseIPAddress(str, strServer1, nServer1Port))
-	{
-		//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("parse ip addr fail: %s", (const char*)str);
-		return false;
-	}
-
-	CSimpleStringA strServer2;
-	int nServer2Port = 0;
-	if (Error_Succeed == spConfig->ReadConfigValue("Main", "Server_Backup", str) && !str.IsNullOrEmpty())
-		ParseIPAddress(str, strServer2, nServer2Port);
-
-
-	if (readSuccess)
-		connectInfo->setParam(pEntityName, strServer1.GetData(), nServer1Port, strServer2.GetData(), nServer2Port, dualActive, connectInfo->m_currentLink);
-	else
-	{
-		connectInfo->clear();
-		connectInfo->setParam(pEntityName, strServer1.GetData(), nServer1Port, strServer2.GetData(), nServer2Port, dualActive);
-	}
-	entityConnect->setEntityInfo(connectInfo);
-
-	return true;
-}
-
 void SpSecureClient::connectClose(const char *pEntityName)
 {
 	if (NULL == pEntityName)
@@ -686,123 +585,6 @@ void SpSecureClient::OnAuthPass()
 {
 }
 
-bool SpSecureClient::OnAuthRequest(CConnAuthReq *pReq)
-{
-	ErrorCodeEnum Error = Error_Unexpect;
-
-	// prepare verify info 
-	CSystemStaticInfo si;
-	m_pEntity->GetFunction()->GetSystemStaticInfo(si);
-	CVerifyInfo info;
-	memset(&info, 0, sizeof(info));
-	strncpy(info.m_arrTerminalNo, (LPCSTR)si.strTerminalID, sizeof(info.m_arrTerminalNo)-1);
-	strcpy(info.m_arrServiceType, "CMBRVC");
-	{
-#ifdef RVC_OS_WIN
-		hostent *ent = _gethostbyname(NULL);
-		if (ent && ent->h_addr_list[0] != NULL)
-		{
-			int i = 0;
-			for (; ent->h_addr_list[i] != NULL; ++i) {
-				struct in_addr* in = (struct in_addr*)ent->h_addr_list[i];
-				if (in->S_un.S_un_b.s_b1 == 99 || in->S_un.S_un_b.s_b1 == 10)
-					break;
-			}
-			if (ent->h_addr_list[i] == NULL)
-				i = 0;
-
-			auto in = (struct in_addr*)ent->h_addr_list[i];
-			info.m_arrIP[0] = in->S_un.S_un_b.s_b1;
-			info.m_arrIP[1] = in->S_un.S_un_b.s_b2;
-			info.m_arrIP[2] = in->S_un.S_un_b.s_b3;
-			info.m_arrIP[3] = in->S_un.S_un_b.s_b4;
-		}
-#else
-        char buf[512];
-        toolkit_interface_address_t* addr;
-        int count, i, aim = -1, backup = -1, third = -1;
-        toolkit_interface_addresses(&addr, &count);
-        i = count;
-        WLog_DBG(TAG, "Number of interfaces: %d", count);
-        while (i--) {
-            toolkit_interface_address_t interface = addr[i];
-            WLog_DBG(TAG, "Name: %s", interface.name);
-            WLog_DBG(TAG, "Internal? %s", interface.is_internal ? "Yes" : "No");
-            if (interface.address.address4.sin_family == AF_INET) {
-                third = i;
-                toolkit_ip4_name(&interface.address.address4, buf, sizeof(buf));
-                WLog_DBG(TAG, "IPv4 address: %s", buf);
-                CSimpleStringA s(buf);
-                if (s.IsStartWith("99.") || s.IsStartWith("10.")) {
-                    aim = i;
-                    break;
-                }
-                if (!interface.is_internal && backup != -1) {
-                    backup = i;
-                }
-            } else if (interface.address.address4.sin_family == AF_INET6) {
-                toolkit_ip6_name(&interface.address.address6, buf, sizeof(buf));
-                WLog_DBG(TAG, "IPv6 address: %s", buf);
-            }
-        }
-        if (aim == -1 && backup != -1) {
-            aim = backup;
-        }
-        if (aim == -1 && third != -1)
-            aim = third;
-        memset(info.m_arrIP, 0, sizeof(info.m_arrIP));
-        if (aim != -1) {
-            char ipStr[32];
-            int b1, b2, b3, b4;
-            b1 = b2 = b3 = b4 = 0;
-            toolkit_ip4_name(&addr[aim].address.address4, ipStr, sizeof(ipStr));
-            WLog_DBG(TAG, "specified local ip: %s", ipStr);
-            sscanf(ipStr, "%d.%d.%d.%d", &b1, &b2, &b3, &b4);
-            info.m_arrIP[0] = (BYTE)b1;
-            info.m_arrIP[1] = (BYTE)b2;
-            info.m_arrIP[2] = (BYTE)b3;
-            info.m_arrIP[3] = (BYTE)b4;
-        }
-        toolkit_free_interface_addresses(addr, count);
-#endif
-	}
-	if (pReq != NULL)
-	{
-		// call token service to encrypt verify info
-		int nDestLen = sizeof(pReq->m_arrVerifyInfo);
-		TokenService_ClientBase *client = new TokenService_ClientBase(m_pEntity);
-		Error = client->Connect();
-		if (Error == Error_Succeed) {
-			TokenService_EncryptWithPubKey_Req Req;
-			TokenService_EncryptWithPubKey_Ans Ans;
-			Req.raw_data.m_pData = (char*)&info;
-			Req.raw_data.m_iLength = sizeof(info);	//28
-				
-			Error = client->EncryptWithPubKey(Req, Ans, -1);
-			if (Error != Error_Succeed) {
-				LOG_TRACE("EncryptWithPriKey for VerifyInfo failed! Error = %s", SpStrError(Error));
-			} else {
-				memcpy_s(pReq->m_arrVerifyInfo, sizeof(pReq->m_arrVerifyInfo), Ans.enc_data.m_pData, Ans.enc_data.m_iLength);
-				// get token
-				TokenService_GetToken_Req Req1;
-				TokenService_GetToken_Ans Ans1;
-				Error = client-> GetToken(Req1, Ans1, -1);
-				if (Error != Error_Succeed) {
-					LOG_TRACE("GetToken for VerifyInfo failed! Error = %s", SpStrError(Error));
-				} else {
-					memcpy_s(pReq->m_arrVerifyToken, sizeof(pReq->m_arrVerifyToken), Ans1.token.m_pData, Ans1.token.m_iLength);
-				}
-			}
-			client->GetFunction()->CloseSession();
-		} else {
-			LOG_TRACE("connect to tokenservice failed! Error = %s", SpStrError(Error));
-			client->SafeDelete();
-		}
-	}
-
-	return Error == Error_Succeed;
-}
-
 bool SpSecureClient::OnAuthRequestSM(CConnAuthSMReq* pReq)
 {
 	ErrorCodeEnum Error = Error_Unexpect;
@@ -814,6 +596,7 @@ bool SpSecureClient::OnAuthRequestSM(CConnAuthSMReq* pReq)
 	strncpy(info.m_arrTerminalNo, (LPCSTR)si.strTerminalID, sizeof(info.m_arrTerminalNo) - 1);
 	strcpy(info.m_arrServiceType, "CMBRVC");
 	{
+		//TODO: CrossPlaform IP [Gifur@2025730]
 #ifdef RVC_OS_LINUX
         char buf[512];
         toolkit_interface_address_t* addr;
@@ -890,7 +673,6 @@ bool SpSecureClient::OnAuthRequestSM(CConnAuthSMReq* pReq)
 	if(pReq != NULL)
 	{
 		// call token service to encrypt verify info
-		int nDestLen = sizeof(pReq->m_arrVerifyInfo);
 		TokenService_ClientBase* client = new TokenService_ClientBase(m_pEntity);
 
 		Error = client->Connect();
@@ -991,7 +773,7 @@ bool SpSecureClient::OnSessionKeySMRet(CConnAuthSMRet* pRet, BYTE* pBuf, int* pB
 
 bool SpSecureClient::OnGetSharedSK(char *pTerminalNo, int *pTerminalNoLen, BYTE *pBuf, int *pBufLen)
 {
-#ifdef _MSC_VER
+#ifdef RVC_OS_WIN
 	ErrorCodeEnum Error = Error_Unexpect;
 	CSystemStaticInfo si;
 	{

Framework/spbase/SpUtility.cpp

@@ -2,6 +2,7 @@
 #include "SpUtility.h"
 #include "charset.h"
 #include "dbgutil.h"
+#include <regex>
 #define TAG SPBASE_TAG("SpUtility")
 
 namespace SP
@@ -146,6 +147,77 @@ std::string UTF8ToGBK(const std::string str)
     return result;
 }
 
+bool IsNum(const std::string& value)
+{
+	if (value.empty()) {
+		return false;
+	}
+    std::regex pattern("^[0-9]+$");
+	if (std::regex_match(value, pattern)) {
+        return true;
+	}
+	else {
+        return false;
+	}
+}
+
+bool CheckIPv4(const std::string& value)
+{
+	if (value.empty()) {
+		return false;
+	}
+	std::vector<std::string> elems = SP::Utility::Split(value, '.');
+	if (elems.size() != 4) {
+		return false;
+	}
+	for (int i = 0; i < 4; i++) {
+		if (!IsNum(elems[i])) {
+			return false;
+		}
+		if (elems[i].find(' ') != std::string::npos) {
+			return false;
+		}
+		if ((elems[i].find('0') == 0) && (elems[i].length() != 1)) {
+			return false;
+		}
+	}
+
+	if ((stoi(elems[0]) < 0 || stoi(elems[0]) > 255) ||
+		(stoi(elems[1]) < 0 || stoi(elems[1]) > 255) ||
+		(stoi(elems[2]) < 0 || stoi(elems[2]) > 255) ||
+		(stoi(elems[3]) < 0 || stoi(elems[3]) > 255)) {
+		return false;
+	}
+	return true;
+}
+
+bool IsValidUrl(const std::string& value)
+{
+	if (value.empty()) {
+		return false;
+	}
+	else {
+		std::string strUrl = ToLower(value.c_str());
+		std::string pattern = "^((https|http)://)";
+		pattern += "(([0-9a-z_!~*\\'().&=+$%-]+: )?[0-9a-z_!~*\\'().&=+$%-]+@)?";
+		pattern += "(([0-9]{1,3}\\.){3}[0-9]{1,3}";
+		pattern += "|";
+		pattern += "([0-9a-z_!~*\\'()-]+\\.)*";
+		pattern += "([0-9a-z][0-9a-z-]{0,61})?[0-9a-z]\\.";
+		pattern += "[a-z]{2,6})";
+		pattern += "(:[0-9]{1,4})?";
+		pattern += "((/?)|";
+		pattern += "(/[0-9a-z_!~*\\'().;?:@&=+$,%#-]+)+/?)$";
+        std::regex patternReg(pattern);
+		if (std::regex_match(strUrl, patternReg)) {
+            return true;
+		}
+		else {
+            return false;
+		}
+	}
+}
+
 std::string W2S(const std::wstring wstr)
 {
     std::string result("");

Framework/spbase/StartUpBase.cpp

@@ -43,7 +43,7 @@ public:
 
     static StartupLogManager& getInstance();
     //StartupLogManager::getInstance().addLog(entityName, entity_id);
-    void addLog(const std::string& module_entity, int idx); // 新增 addLog 方法
+    void addLog(const std::string& module_entity, int idx); // 鏂板� addLog 鏂规硶
     bool checkLogExist(int idx);
     StartupLog& getLog(int idx);
     /*
@@ -193,13 +193,13 @@ StartupLogManager::~StartupLogManager() {}
 void StartupLogManager::addLog(const std::string& module_entity, int idx) {
     recordStartTime();
     if (logs_.find(idx) == logs_.end()) {
-        logs_[idx] = StartupLog(module_entity, idx); // 直接拷贝 log 对象
-    } // 如果已存在，则忽略
+        logs_[idx] = StartupLog(module_entity, idx); // 鐩存帴鎷疯礉 log 瀵硅薄
+    } // 濡傛灉宸插瓨鍦�紝鍒欏拷鐣�
 }
 
 StartupLog& StartupLogManager::getLog(int idx) {
     if (logs_.find(idx) == logs_.end()) {
-        logs_[idx] = StartupLog("", idx); // 仍然保留隐式创建的逻辑，方便使用
+        logs_[idx] = StartupLog("", idx); // 浠嶇劧淇濈暀闅愬紡鍒涘缓鐨勯€昏緫锛屾柟渚夸娇鐢�
     }
     return logs_[idx];
 }

Framework/spbase/spShareMemoryBase.cpp

@@ -499,14 +499,13 @@ void CMyLogFile::PrintCurTime()
 	TCHAR dateString[256];
 	SYSTEMTIME cur;
 	GetLocalTime(&cur);
-#if defined(_MSC_VER)
     sprintf(dateString, "[%4d-%.2d-%.2d,%.2d:%.2d:%.2d][%u][%u]  ", cur.wYear, cur.wMonth,
-            cur.wDay, cur.wHour, cur.wMinute, cur.wSecond, GetCurrentProcessId(), GetCurrentThreadId());
+            cur.wDay, cur.wHour, cur.wMinute, cur.wSecond, GetCurrentProcessId(), 
+#if defined(RVC_OS_WIN)
+		GetCurrentThreadId());
 #else
-    sprintf(dateString, "[%4d-%.2d-%.2d,%.2d:%.2d:%.2d][%u][%u]  ", cur.wYear, cur.wMonth,
-            cur.wDay, cur.wHour, cur.wMinute, cur.wSecond, GetCurrentProcessId(), GetCurrentThreadIdFromSys());
-#endif //_MSC_VER
-
+	 GetCurrentThreadIdFromSys());
+#endif //RVC_OS_WIN
 	Output(dateString);
 }
 

Framework/spbase/sp_bcm.c

@@ -281,13 +281,6 @@ static void daemon_unlock(sp_bcm_daemon_t *daemon)
 	LeaveCriticalSection(&daemon->lock);
 }
 
-static const char *_GetFileName(const char *pszFilePath)
-{
-	int i=strlen(pszFilePath);
-	for( ; i>0 && pszFilePath[i-1]!='\\'; i--)NULL;
-	return pszFilePath+i;
-}
-
 static int daemon_on_pkt(sp_svc_t *svc,int epid, int svc_id, int pkt_type, int pkt_id, iobuffer_t **p_pkt, void *user_data)
 {
 	sp_bcm_daemon_t *daemon = (sp_bcm_daemon_t *)user_data;

Framework/spbase/sp_btr.c

@@ -207,9 +207,7 @@ WriteLog:
 	WriteFile(hFile, line, strlen(line), &dwBytesWritten, NULL);
 	if (dwBytesWritten == 0)
 	{
-		char szTmp[512] = { 0 };
-		GetSystemErrorDesc(GetLastError(), szTmp, sizeof(szTmp));
-		DbgWithLinkForC(LOG_LEVEL_ERROR, LOG_TYPE_SYSTEM,"write boot start fail: %s", szTmp);
+		DbgWithLinkForC(LOG_LEVEL_ERROR, LOG_TYPE_SYSTEM,"write boot start fail: %d", GetLastError());
 	}
 
 	FlushFileBuffers(hFile);
@@ -268,9 +266,7 @@ int sp_btr_write_on_shutdown(const char *bootrec_path, sp_btr_context_t *ctx, in
 	WriteFile(hFile, line, strlen(line), &dwBytesWritten, NULL);
 	if (dwBytesWritten == 0)
 	{
-		char szTmp[512] = { 0 };
-		GetSystemErrorDesc(GetLastError(), szTmp, sizeof(szTmp));
-		DbgWithLinkForC(LOG_LEVEL_ERROR, LOG_TYPE_SYSTEM,"write reboot rec fail: %s", szTmp);
+		DbgWithLinkForC(LOG_LEVEL_ERROR, LOG_TYPE_SYSTEM,"write reboot rec fail: %d", GetLastError());
 	}
 
 	FlushFileBuffers(hFile);
@@ -413,12 +409,7 @@ sp_btr_reocrd_t* sp_btr_get_rec_before(const char *bootrec_path, sp_btr_context_
 	y2k_to_localtime(before_this_time, &st);
 	while (nTryCount++ <= 12)
 	{
-		#ifdef _WIN32
-		sprintf(szBootLog, "%s\\%04d%02d.log", bootrec_path, st.wYear, st.wMonth);
-        #else
-		sprintf(szBootLog, "%s/%04d%02d.log", bootrec_path, st.wYear, st.wMonth);
-		#endif
-
+		sprintf(szBootLog, "%s" SPLIT_SLASH_STR "%04d%02d.log", bootrec_path, st.wYear, st.wMonth);
 		if (!ExistsFileA(szBootLog))
 		{
 			DbgWithLinkForC(LOG_LEVEL_ERROR, LOG_TYPE_SYSTEM,"boot log %s not exists", szBootLog);

Framework/spbase/sp_cfg.cpp

@@ -588,12 +588,7 @@ SPBASE_API int sp_cfg_getVer(char *ver)
 
 		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("read active.txt, version[%s]", s_terminalVer.GetData());
 	}
-	
-#ifdef RVC_OS_LINUX
-	sprintf(ver, "%s", s_terminalVer.GetData());
-#else
 	sprintf_s(ver, SP_MAX_VER_LEN, "%s", s_terminalVer.GetData());
-#endif
 	return Error_Succeed;
 }
 
@@ -729,11 +724,7 @@ int sp_tryReadFromCacheConfig(int cfgType, const char* section, const char* key,
 		return ErrorCodeEnum::Error_NoDefine;
 	else
 	{
-#ifdef RVC_OS_LINUX
-		sprintf(dst, "%s", curSection[key].c_str());
-#else
 		sprintf_s(dst, max_len, "%s", curSection[key].c_str());
-#endif
 		return Error_Succeed;
 	}
 }
@@ -757,6 +748,7 @@ int sp_tryRefreshLogLevelFromCacheConfig()
 	return 0;
 }
 
+//TODO: 建议废弃采用上面的综合函数  sp_tryReadFromCacheConfig  [Gifur@202584]
 int sp_tryReadFromCenterSetting(const char* section, const char* key, char *dst, int max_len)
 {
 	char tmp[MAX_PATH];
@@ -779,11 +771,7 @@ int sp_tryReadFromCenterSetting(const char* section, const char* key, char *dst,
 		return ErrorCodeEnum::Error_NoDefine;
 	else
 	{
-#ifdef RVC_OS_LINUX
-		sprintf(dst, "%s", curSection[key].c_str());
-#else
 		sprintf_s(dst, max_len, "%s", curSection[key].c_str());
-#endif
 		return Error_Succeed;
 	}
 }
@@ -2060,6 +2048,7 @@ ErrorCodeEnum init_shell_byHttp(sp_dir_t* dir, sp_cfg_shell_ini_t* shell, sp_cfg
 
 	//init entity arr,去除以;开头的实体
 	std::map<std::string, std::string> entityArr = clearUnExistConfig(shellConfig[SHELL_ENTITY_HEAD]);
+	//TODO: CrossPlaform  [Gifur@2025730]
 #ifdef _WIN32
 	CSimpleStringA sectionNameWithType = CSimpleStringA::Format("%s_%s", SHELL_ENTITY_HEAD, root->machine_type);
 #else

Framework/spbase/sp_dir.c

@@ -360,6 +360,7 @@ int sp_dir_inner_get_content(const char* file, char* ver)
 		n = fread(szTemp, 1, 256, pFile);
 		fclose(pFile);
 		memset(ver, 0, SP_MAX_VER_LEN);
+		//TODO: CrossPlaform  [Gifur@2025730]
 #if defined(RVC_OS_WIN)
 		strncpy_s(ver, SP_MAX_VER_LEN, szTemp, _TRUNCATE);
 #else

Framework/spbase/sp_gui.cpp

@@ -10,7 +10,6 @@
 #include "resource1.h"
 #include <atlbase.h>
 #include <gdiplus.h>
-#pragma comment(lib,"gdiplus")
 using namespace Gdiplus;
 
 #include "resource1.h"

Framework/spbase/sp_logwithlink.cpp

@@ -444,10 +444,8 @@ void DbgWithLink::operator () (const char* str, ...)  const  {
         }
     }
 #endif //GBK_COMPACT
-
+    log_item log;
     if (m_priPtr->IsAllowToRecord()) {
-
-        log_item log;
         log_producer_result rst;
         log.Level = m_priPtr->Level;
         log.Type = m_priPtr->Type;
@@ -484,21 +482,22 @@ void DbgWithLink::operator () (const char* str, ...)  const  {
         return;
     }
 
+
     switch (m_priPtr->Level) {
     case LOG_LEVEL_DEBUG:
-        sp_dbg_debugNoOut("%s", &buf[0]);
+        sp_dbg_debugNoOut("[API:%s][ResultCode:%s]%s", log.API, log.ResultCode, &buf[0]);
         break;
     case LOG_LEVEL_INFO:
-        sp_dbg_infoNoOut("%s", &buf[0]);
+        sp_dbg_infoNoOut("[API:%s][ResultCode:%s]%s", log.API, log.ResultCode, &buf[0]);
         break;
     case LOG_LEVEL_WARN:
-        sp_dbg_warnNoOut("%s", &buf[0]);
+        sp_dbg_warnNoOut("[API:%s][ResultCode:%s]%s", log.API, log.ResultCode, &buf[0]);
         break;
     case LOG_LEVEL_ERROR:
-        sp_dbg_errorNoOut("%s", &buf[0]);
+        sp_dbg_errorNoOut("[API:%s][ResultCode:%s]%s", log.API, log.ResultCode, &buf[0]);
         break;
     case LOG_LEVEL_FATAL:
-        sp_dbg_fatalNoOut("%s", &buf[0]);
+        sp_dbg_fatalNoOut("[API:%s][ResultCode:%s]%s", log.API, log.ResultCode, &buf[0]);
         break;
     default:
         break;
@@ -546,19 +545,19 @@ void DbgWithLink::operator () ()  const  {
 
     switch (log.Level) {
     case LOG_LEVEL_DEBUG:
-        sp_dbg_debugNoOut("%s", log.ResultMsg);
+        sp_dbg_debugNoOut("[API:%s][ResultCode:%s]%s", log.API, log.ResultCode, log.ResultMsg);
         break;
     case LOG_LEVEL_INFO:
-        sp_dbg_infoNoOut("%s", log.ResultMsg);
+        sp_dbg_infoNoOut("[API:%s][ResultCode:%s]%s", log.API, log.ResultCode, log.ResultMsg);
         break;
     case LOG_LEVEL_WARN:
-        sp_dbg_warnNoOut("%s", log.ResultMsg);
+        sp_dbg_warnNoOut("[API:%s][ResultCode:%s]%s", log.API, log.ResultCode, log.ResultMsg);
         break;
     case LOG_LEVEL_ERROR:
-        sp_dbg_errorNoOut("%s", log.ResultMsg);
+        sp_dbg_errorNoOut("[API:%s][ResultCode:%s]%s", log.API, log.ResultCode, log.ResultMsg);
         break;
     case LOG_LEVEL_FATAL:
-        sp_dbg_fatalNoOut("%s", log.ResultMsg);
+        sp_dbg_fatalNoOut("[API:%s][ResultCode:%s]%s", log.API, log.ResultCode, log.ResultMsg);
         break;
     default:
         break;
@@ -614,6 +613,7 @@ SPBASE_API void* create_log_producer_storage(CSimpleStringA entityName, CSimpleS
 {
     WLog_DBG(TAG, "create log producer storage for %s, %s, %s", entityName.GetData(), item.GetData(), filePath.GetData());
     log_producer_config* config = create_log_producer_config();
+    //TODO: CrossPlaform  [Gifur@2025730]
 #ifdef _WIN32
     std::string t_entityName = toLowerCase(entityName.GetData());
 #else

Framework/spbase/sp_mod.c

@@ -872,6 +872,7 @@ static int create_module_process(const char *mod_name, int epid, int range, int
 		return -1;
 	}
 
+	//TODO: CrossPlaform  [Gifur@2025729]
 	if (runType == 1)
 		sprintf(app, ".\\bin\\sphost.exe {%s} %d", mutexName, shellId);
 	else

Framework/spbase/sp_pst.c

@@ -29,28 +29,17 @@ struct sp_pst_elem_t {
 
 static const char *get_full_path(const char *base_dir, const char *ent, const char *cls, const char *obj, char *buf)
 {
-#ifdef _WIN32
 	if (cls) {
 		if (obj) {
-			sprintf(buf, "%s\\objects\\%s\\%s\\%s.dat", base_dir, ent, cls, obj);
-		} else {
-			sprintf(buf, "%s\\objects\\%s\\%s", base_dir, ent, cls);
+			sprintf(buf, "%s" SPLIT_SLASH_STR "objects" SPLIT_SLASH_STR "%s" SPLIT_SLASH_STR "%s" SPLIT_SLASH_STR "%s.dat", base_dir, ent, cls, obj);
 		}
-	} else {
-		sprintf(buf, "%s\\objects\\%s", base_dir, ent);
-	}
-#else
-	if (cls) {
-		if (obj) {
-			sprintf(buf, "%s/objects/%s/%s/%s.dat", base_dir, ent, cls, obj);
-		} else {
-			sprintf(buf, "%s/objects/%s/%s", base_dir, ent, cls);
+		else {
+			sprintf(buf, "%s" SPLIT_SLASH_STR "objects" SPLIT_SLASH_STR "%s" SPLIT_SLASH_STR "%s", base_dir, ent, cls);
 		}
-	} else {
-		sprintf(buf, "%s/objects/%s", base_dir, ent);
 	}
-#endif
-	
+	else {
+		sprintf(buf, "%s" SPLIT_SLASH_STR "objects" SPLIT_SLASH_STR "%s", base_dir, ent);
+	}
 	return buf;
 }
 
@@ -517,12 +506,7 @@ static void recover_persist_dir_files(const char *dir)
 	WIN32_FIND_DATAA fd;
 
 	strcpy(szFile, dir);
-	#ifdef _WIN32
-	strcat(szFile, "\\*");
-    #else
-	strcat(szFile, "/*");
-	#endif
-
+	strcat(szFile, SPLIT_SLASH_STR "*");
 	hFind = FindFirstFileA(szFile, &fd);
 	if (hFind != INVALID_HANDLE_VALUE) {
 		do {

Framework/spbase/sp_pst.h

@@ -2,7 +2,7 @@
 #define SP_PST_H
 
 #pragma once
-
+//TODO: CrossPlaform ÎļþÒƳý£¬Ã»ÓÐʹÓà  [Gifur@202584]
 #ifdef __cplusplus
 extern "C" {
 #endif

Framework/spbase/sp_sps.c

@@ -57,6 +57,7 @@ static void __on_accept(SOCKET policy_fd)
 	DbgWithLinkForC(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM, "accept from %s:%d", inet_ntoa(from_addr.sin_addr), ntohs(from_addr.sin_port));
 
 	WSAEventSelect(conn_fd, NULL, 0);
+	//TODO: CrossPlaform  [Gifur@2025729]
 #ifdef _WIN32
 	ioctlsocket(conn_fd, FIONBIO, &iMode);
 #else
@@ -97,13 +98,6 @@ on_error:
 	closesocket(conn_fd);
 }
 
-static const char *_GetFileName(const char *pszFilePath)
-{
-	int i=strlen(pszFilePath);
-	for( ; i>0 && pszFilePath[i-1]!='\\'; i--)NULL;
-	return pszFilePath+i;
-}
-
 static unsigned int __stdcall __sps_worker_proc(void *arg)
 {
 	sp_sps_t *sps = (sp_sps_t*)arg;

Framework/spbase/sp_tbs_unix.cpp

@@ -26,6 +26,7 @@
 #include "fileutil.h"
 #include "memutil.h"
 #include "toolkit.h"
+#include "charset.h"
 #include "uuid4.h"
 #include "dbgutil.h"
 #include <winpr/winsock.h>
@@ -362,15 +363,6 @@ static const wchar_t *get_user_err_msg(int rc)
 	toolkit_mbs2wcs(msg, wmsg, 512);
 	return wmsg;
 }
-/*
-static const char *_GetFileName(const char *pszFilePath)
-{
-	int i=strlen(pszFilePath);
-	for( ; i>0 && pszFilePath[i-1]!='\\'; i--)NULL;
-	return pszFilePath+i;
-}
-*/
-
 
 static int create_connection(sp_tbs_t *tbs)
 {

Framework/spbase/test/SpSecureClientTest.cxx

@@ -69,8 +69,6 @@ class CMockSecureClient : public SpSecureClient
 public:
 	CMockSecureClient(CEntityBase* pEntityBase):SpSecureClient(pEntityBase){}
 	
-	//MOCK_METHOD3(Connect, bool(const char* pServerAddr, int nPort, int nOption));
-	MOCK_METHOD1(ConnectFromConfig, bool(int nOption));
 	MOCK_METHOD0(ConnectFromCentralSetting, bool());
 	MOCK_METHOD0(IsConnectionOK, bool());
 	MOCK_METHOD0(IsSecureConn, bool());

Framework/sphost/SpHostLog.cpp

@@ -178,8 +178,12 @@ void CMyLogFile::PrintCurTime()
 	SYSTEMTIME cur;
 	GetLocalTime(&cur);
 	sprintf(dateString, "[%4d%.2d%.2d %.2d:%.2d:%.2d.%03d][%u][%u] - ", cur.wYear, cur.wMonth,
-		cur.wDay, cur.wHour, cur.wMinute, cur.wSecond, cur.wMilliseconds, GetCurrentProcessId(), GetCurrentThreadId());
-
+		cur.wDay, cur.wHour, cur.wMinute, cur.wSecond, cur.wMilliseconds, GetCurrentProcessId(),
+#if defined(_MSC_VER)
+	GetCurrentThreadId());
+#else
+	GetCurrentThreadIdFromSys());
+#endif //_MSC_VER
 	Output(dateString);
 }
 

Framework/spshell/app.cpp

@@ -79,11 +79,13 @@ static void sig_handle(int signo)
 static int get_child_range()
 {
 	char tmp[32];
+	return _spawnl(_P_WAIT, 
 #ifdef RVC_OS_WIN
-	return _spawnl(_P_WAIT, ".\\bin\\sphost.exe", "sphost.exe", _itoa(sp_shm_get_range(0xffffffff), tmp, 10), NULL);
+		".\\bin\\sphost.exe", "sphost.exe",
 #else
-	return _spawnl(_P_WAIT, "./bin/sphost", "sphost", _itoa(sp_shm_get_range(0xffffffff), tmp, 10), NULL);
-#endif //RVC_OS_WIN
+		"./bin/sphost", "sphost",
+#endif
+		_itoa(sp_shm_get_range(0xffffffff), tmp, 10), NULL);
 }
 
 static void on_info(sp_rpc_server_t *server, int epid, int svc_id, int call_type, iobuffer_t **info_pkt, void *user_data)
@@ -247,7 +249,6 @@ int app_init(const sp_cfg_start_args_t* args, std::function<void(const char* msg
 	int rc;
 	int flag;
 	sp_rpc_server_callback callback;
-	int costTime = 0;
 
 	auto getClockDual = []() -> int {
 		static clock_t t_begin = clock();

Framework/spshell/spshell.cpp

@@ -24,7 +24,6 @@
 
 #ifdef RVC_OS_WIN
 #include <io.h>
-#pragma comment(lib, "dbghelp.lib")
 #include "sp_firewallControl.h"
 #else
 #include <unistd.h>
@@ -375,6 +374,7 @@ const char *GetMachineType()
 
 #ifdef RVC_OS_WIN
 
+//TODO: CrossPlaform 11111  [Gifur@2025730]
 const char *GetCenterSettingNameBySite(const char *pszSite)
 {
 	///*TODO(80374374@3/23/2023): CenterSettings */

Framework/spshell/svc.cpp

@@ -170,7 +170,7 @@ static int KickoffSpRestartInner(int options)
 		char exepath[MAX_PATH] = "";
 		getExePath(exepath);
 
-		CSimpleStringA csRestart, csVerPath, csAll, csSep("\""), csBlank(" "), csScript("wscript.exe"), csReFlag("r");
+		CSimpleStringA csRestart, csVerPath, csAll, csBlank(" "), csReFlag("r");
 		csRestart = CSimpleStringA(exepath) + "\\sprestart.exe";
 
 		sp_env_t* env = sp_get_env();
@@ -184,11 +184,11 @@ static int KickoffSpRestartInner(int options)
 		LPTSTR szCmdline = _strdup(csAll);
 		if (!CreateProcess(NULL, szCmdline, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi))
 		{
-			DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("CreateProcess failed (%d).\n", GetLastError());
+			DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("CreateProcess failed (%d).", GetLastError());
 			return -1;
 		}
 
-		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("CreateProcess Success PID:%d.\n", pi.dwProcessId);
+		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("CreateProcess Success PID:%d.", pi.dwProcessId);
 		DWORD dwErr = GetLastError();
 
 		// Close process and thread handles. 

Framework/winpr/include/winpr/error.h

@@ -2974,12 +2974,53 @@
 #define WS_E_SECURITY_SYSTEM_FAILURE 0x803D0023
 #endif
 
+#define NTE_BAD_UID WINPR_CXX_COMPAT_CAST(LONG, 0x80090001)
+#define NTE_BAD_HASH WINPR_CXX_COMPAT_CAST(LONG, 0x80090002)
+#define NTE_BAD_KEY WINPR_CXX_COMPAT_CAST(LONG, 0x80090003)
+#define NTE_BAD_LEN WINPR_CXX_COMPAT_CAST(LONG, 0x80090004)
+#define NTE_BAD_DATA WINPR_CXX_COMPAT_CAST(LONG, 0x80090005)
+#define NTE_BAD_SIGNATURE WINPR_CXX_COMPAT_CAST(LONG, 0x80090006)
+#define NTE_BAD_VER WINPR_CXX_COMPAT_CAST(LONG, 0x80090007)
+#define NTE_BAD_ALGID WINPR_CXX_COMPAT_CAST(LONG, 0x80090008)
+#define NTE_BAD_FLAGS WINPR_CXX_COMPAT_CAST(LONG, 0x80090009)
+#define NTE_BAD_TYPE WINPR_CXX_COMPAT_CAST(LONG, 0x8009000A)
+#define NTE_BAD_KEY_STATE WINPR_CXX_COMPAT_CAST(LONG, 0x8009000B)
+#define NTE_BAD_HASH_STATE WINPR_CXX_COMPAT_CAST(LONG, 0x8009000C)
+#define NTE_NO_KEY WINPR_CXX_COMPAT_CAST(LONG, 0x8009000D)
+#define NTE_NO_MEMORY WINPR_CXX_COMPAT_CAST(LONG, 0x8009000E)
+#define NTE_EXISTS WINPR_CXX_COMPAT_CAST(LONG, 0x8009000F)
+#define NTE_PERM WINPR_CXX_COMPAT_CAST(LONG, 0x80090010)
+#define NTE_NOT_FOUND WINPR_CXX_COMPAT_CAST(LONG, 0x80090011)
+#define NTE_DOUBLE_ENCRYPT WINPR_CXX_COMPAT_CAST(LONG, 0x80090012)
+#define NTE_BAD_PROVIDER WINPR_CXX_COMPAT_CAST(LONG, 0x80090013)
+#define NTE_BAD_PROV_TYPE WINPR_CXX_COMPAT_CAST(LONG, 0x80090014)
+#define NTE_BAD_PUBLIC_KEY WINPR_CXX_COMPAT_CAST(LONG, 0x80090015)
+#define NTE_BAD_KEYSET WINPR_CXX_COMPAT_CAST(LONG, 0x80090016)
+#define NTE_PROV_TYPE_NOT_DEF WINPR_CXX_COMPAT_CAST(LONG, 0x80090017)
+#define NTE_PROV_TYPE_ENTRY_BAD WINPR_CXX_COMPAT_CAST(LONG, 0x80090018)
+#define NTE_KEYSET_NOT_DEF WINPR_CXX_COMPAT_CAST(LONG, 0x80090019)
+#define NTE_KEYSET_ENTRY_BAD WINPR_CXX_COMPAT_CAST(LONG, 0x8009001A)
+#define NTE_PROV_TYPE_NO_MATCH WINPR_CXX_COMPAT_CAST(LONG, 0x8009001B)
+#define NTE_SIGNATURE_FILE_BAD WINPR_CXX_COMPAT_CAST(LONG, 0x8009001C)
+#define NTE_PROVIDER_DLL_FAIL WINPR_CXX_COMPAT_CAST(LONG, 0x8009001D)
+#define NTE_PROV_DLL_NOT_FOUND WINPR_CXX_COMPAT_CAST(LONG, 0x8009001E)
+#define NTE_BAD_KEYSET_PARAM WINPR_CXX_COMPAT_CAST(LONG, 0x8009001F)
+#define NTE_FAIL WINPR_CXX_COMPAT_CAST(LONG, 0x80090020)
+#define NTE_SYS_ERR WINPR_CXX_COMPAT_CAST(LONG, 0x80090021)
+#define NTE_SILENT_CONTEXT WINPR_CXX_COMPAT_CAST(LONG, 0x80090022)
+#define NTE_TOKEN_KEYSET_STORAGE_FULL WINPR_CXX_COMPAT_CAST(LONG, 0x80090023)
+#define NTE_TEMPORARY_PROFILE WINPR_CXX_COMPAT_CAST(LONG, 0x80090024)
+#define NTE_FIXEDPARAMETER WINPR_CXX_COMPAT_CAST(LONG, 0x80090025)
+#define NTE_NO_MORE_ITEMS ERROR_NO_MORE_ITEMS
+#define NTE_NOT_SUPPORTED ERROR_NOT_SUPPORTED
+#define NTE_INVALID_PARAMETER WINPR_CXX_COMPAT_CAST(LONG, 0x80090027)
+
 #define EXCEPTION_MAXIMUM_PARAMETERS 15
 
-typedef struct _EXCEPTION_RECORD EXCEPTION_RECORD;
-typedef struct _EXCEPTION_RECORD* PEXCEPTION_RECORD;
+typedef struct s_EXCEPTION_RECORD EXCEPTION_RECORD;
+typedef struct s_EXCEPTION_RECORD* PEXCEPTION_RECORD;
 
-struct _EXCEPTION_RECORD
+struct s_EXCEPTION_RECORD
 {
 	DWORD ExceptionCode;
 	DWORD ExceptionFlags;
@@ -2991,7 +3032,7 @@ struct _EXCEPTION_RECORD
 
 typedef void* PCONTEXT;
 
-typedef struct _EXCEPTION_POINTERS
+typedef struct s_EXCEPTION_POINTERS
 {
 	PEXCEPTION_RECORD ExceptionRecord;
 	PCONTEXT ContextRecord;

Framework/winpr/include/winpr/string.h

@@ -76,7 +76,7 @@ WINPR_API WCHAR* wcstok_s(WCHAR* strToken, const WCHAR* strDelimit, WCHAR** cont
 #define stricmp _stricmp
 #define strnicmp _strnicmp
 #define strcpy_s(dst, size, src) strcpy(dst, src)
-
+#define strncpy_s(a, b, c, d) strncpy(a, c, d)
 #else
 
 #define _wcscmp wcscmp
@@ -185,14 +185,11 @@ WINPR_API WCHAR* wcstok_s(WCHAR* strToken, const WCHAR* strDelimit, WCHAR** cont
 
 #define	 sprintf_s	snprintf
 #define	 _snprintf	snprintf
-#define _scprintf(...) snprintf(NULL, 0, __VA_ARGS__)
-
-#define _scprintf(...) snprintf(NULL, 0, __VA_ARGS__)
-
+#define	 _vsnprintf	vsnprintf
 #define _scprintf(...) snprintf(NULL, 0, __VA_ARGS__)
 
 #if 0
-#define _vscprintf(...) vsnprintf(NULL, 0, __VA_ARGS__)
+	#define _vscprintf(...) vsnprintf(NULL, 0, __VA_ARGS__)
 #else
 	WINPR_API int _vscprintf(const char* format, va_list pargs);
 #endif

Framework/winpr/libwinpr/crt/unicode.c

@@ -416,7 +416,6 @@ int ConvertToUnicode(UINT CodePage, DWORD dwFlags, LPCSTR lpMultiByteStr, int cb
 
 		if (!(*lpWideCharStr))
 		{
-			// SetLastError(ERROR_INSUFFICIENT_BUFFER);
 			return 0;
 		}
 	}
@@ -486,7 +485,6 @@ int ConvertFromUnicode(UINT CodePage, DWORD dwFlags, LPCWSTR lpWideCharStr, int
 
 		if (!(*lpMultiByteStr))
 		{
-			// SetLastError(ERROR_INSUFFICIENT_BUFFER);
 			return 0;
 		}
 	}

Framework/winpr/libwinpr/error/error.c

@@ -44,7 +44,14 @@ DWORD GetLastError(VOID)
 	PTEB pt = NtCurrentTeb();
 	if (pt)
 	{
-		return NtCurrentTeb()->LastErrorValue;
+		DWORD tmp = NtCurrentTeb()->LastErrorValue;
+		if (tmp == 0) {
+			tmp = errno;
+		}
+		else {
+			pt->LastErrorValue = 0;
+		}
+		return tmp;
 	}
 	return ERROR_OUTOFMEMORY;
 }

Framework/winpr/libwinpr/nt/nt.c

@@ -101,8 +101,10 @@ PTEB NtCurrentTeb(void)
 		if ((teb = pthread_getspecific(_TebKey)) == NULL)
 		{
 			teb = calloc(1, sizeof(TEB));
-			if (teb)
+			if (teb) {
+				/*calloc作用是为数组分配内存，并确保分配的内存区域被初始化为零*/
 				pthread_setspecific(_TebKey, teb);
+			}
 		}
 	}
 	return teb;

Module/include/CommEntityHelpAgge.hpp

@@ -1,115 +0,0 @@
-#ifndef RVC_MOD_COMM_ENTITY_HELP_AGGERATE_HPP_
-#define RVC_MOD_COMM_ENTITY_HELP_AGGERATE_HPP_
-
-#include <string>
-#include <regex.h>
-#include "SimpleString.h"
-
-namespace SP
-{
-namespace Module
-{
-namespace Ulitily
-{
-
-bool IsValidUrl(const CSimpleStringA& value)
-{
-    if (value.IsNullOrEmpty()) {
-        return false;
-    } else {
-        std::string strUrl = SP::Utility::ToLower(value.GetData());
-        regex_t reg;
-        CSimpleStringA pattern = "^((https|http)://)";
-        pattern += "(([0-9a-z_!~*\\'().&=+$%-]+: )?[0-9a-z_!~*\\'().&=+$%-]+@)?";
-        pattern += "(([0-9]{1,3}\\.){3}[0-9]{1,3}";
-        pattern += "|";
-        pattern += "([0-9a-z_!~*\\'()-]+\\.)*";
-        pattern += "([0-9a-z][0-9a-z-]{0,61})?[0-9a-z]\\.";
-        pattern += "[a-z]{2,6})";
-        pattern += "(:[0-9]{1,4})?";
-        pattern += "((/?)|";
-        pattern += "(/[0-9a-z_!~*\\'().;?:@&=+$,%#-]+)+/?)$";
-
-        int ret = regcomp(&reg, pattern, REG_EXTENDED | REG_NOSUB);
-        if (ret) {
-            char ebuff[256];
-            regerror(ret, &reg, ebuff, 256);
-            DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("regex failed: %s", ebuff);
-            return false;
-        }
-
-        ret = regexec(&reg, strUrl.c_str(), 0, NULL, 0);
-        if (0 == ret) {
-            DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("correct url format: %s", strUrl.c_str());
-            return true;
-        } else {
-            char ebuff[256];
-            regerror(ret, &reg, ebuff, 256);
-            DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("%s not match: %s", strUrl.c_str(), ebuff);
-            return false;
-        }
-    }
-}
-
-bool IsNum(const std::string& value)
-{
-    if (value.empty()) {
-        return false;
-    }
-    regex_t reg;
-    const std::string pattern = "^[0-9]+$";
-    int ret = regcomp(&reg, pattern.c_str(), REG_EXTENDED | REG_NOSUB);
-    if (ret) {
-        char ebuff[256];
-        regerror(ret, &reg, ebuff, 256);
-        DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("regex failed: %s", ebuff);
-        return false;
-    }
-
-    ret = regexec(&reg, value.c_str(), 0, NULL, 0);
-    if (0 == ret) {
-        return true;
-    } else {
-        char ebuff[256];
-        regerror(ret, &reg, ebuff, 256);
-        DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("%s not match: %s", value.c_str(), ebuff);
-        return false;
-    }
-}
-
-bool CheckIPv4(const std::string& value)
-{
-    if (value.empty()) {
-        return false;
-    }
-    std::vector<std::string> elems = SP::Utility::Split(value, '.');
-    if (elems.size() != 4) {
-        return false;
-    }
-    for (int i = 0; i < 4; i++) {
-        if (!IsNum(elems[i])) {
-            return false;
-        }
-        if (elems[i].find(' ') != std::string::npos) {
-            return false;
-        }
-        if ((elems[i].find('0') == 0) && (elems[i].length() != 1)) {
-            return false;
-        }
-    }
-
-    if ((stoi(elems[0]) < 0 || stoi(elems[0]) > 255) ||
-        (stoi(elems[1]) < 0 || stoi(elems[1]) > 255) ||
-        (stoi(elems[2]) < 0 || stoi(elems[2]) > 255) ||
-        (stoi(elems[3]) < 0 || stoi(elems[3]) > 255)) {
-        return false;
-    }
-    return true;
-}
-
-
-}
-}
-}
-
-#endif //RVC_MOD_COMM_ENTITY_HELP_AGGERATE_HPP_

Module/include/CommEntitySettings.hpp

@@ -1,113 +0,0 @@
-#ifndef RVC_MOD_COMM_ENTITY_SETTINGS_HPP_
-#define RVC_MOD_COMM_ENTITY_SETTINGS_HPP_
-
-#include "SpBase.h"
-#include "fileutil.h"
-
-namespace SP
-{
-namespace Module
-{
-namespace Comm
-{
-
-namespace Settings
-{
-
-static inline void InitializeOtherLogSwitch(CEntityBase* pEntity, const CSimpleStringA& strModuleName)
-{
-	LOG_FUNCTION();
-	if (pEntity == NULL || strModuleName.IsNullOrEmpty()) {
-		return;
-	}
-
-	struct OtherLogConfig
-	{
-		OtherLogConfig() :strLevel("OFF"), strType("FILE"), strDllName(""), strLogPath("") {}
-		OtherLogConfig(const CSimpleStringA& strModuleName) :strLevel("OFF"), strType("FILE"), strDllName(strModuleName), strLogPath("") {}
-
-		CSimpleStringA strLevel;
-		CSimpleStringA strType;
-		CSimpleStringA strDllName;
-		CSimpleStringA strLogPath;
-
-		void Settle()
-		{
-			toolkit_setenv("VENDOR_RECODE_LEVEL", strLevel);
-			toolkit_setenv("VENDOR_RECODE_TYPE", strType);
-			toolkit_setenv("VENDOR_DLL_NAME", strDllName);
-			toolkit_setenv("VENDOR_LOG_PATH", strLogPath);
-		}
-
-	} stLogConfig(strModuleName);
-
-	CSmartPointer<IConfigInfo> centerConfig;
-	pEntity->GetFunction()->OpenConfig(Config_CenterSetting, centerConfig);
-
-	int nSaveFileOrNot(0);
-
-	centerConfig->ReadConfigValueInt("Common", "SaveFile", nSaveFileOrNot);
-	stLogConfig.strType = "UPLOAD";
-	if ((nSaveFileOrNot & 1) == 1) {
-		if (!stLogConfig.strType.IsNullOrEmpty()) stLogConfig.strType += "|";
-		stLogConfig.strType += "FILE";
-	}
-
-	int nUploadLogLevel(1); /*INFO*/
-
-	CSimpleStringA strUploadLogLevelEntity(true);
-	centerConfig->ReadConfigValue(strModuleName.GetData(), "UpLoadLogLevel", strUploadLogLevelEntity);
-	if (strUploadLogLevelEntity.IsNullOrEmpty()) {
-		CSimpleStringA strUploadLogLevelComm(true);
-		centerConfig->ReadConfigValue("Common", "UpLoadLogLevel", strUploadLogLevelComm);
-		strUploadLogLevelEntity = strUploadLogLevelComm;
-	}
-	bool isValidDigit = !strUploadLogLevelEntity.IsNullOrEmpty();
-	for (int i = 0; i < strUploadLogLevelEntity.GetLength(); ++i) {
-		if (!(strUploadLogLevelEntity[i] >= '0' && strUploadLogLevelEntity[i] <= '9')) {
-			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("invalid param: %s", strUploadLogLevelEntity.GetData());
-			isValidDigit = false;
-			break;
-		}
-	}
-	if (isValidDigit) {
-		nUploadLogLevel = atoi(strUploadLogLevelEntity.GetData());
-	}
-	switch (nUploadLogLevel)
-	{
-	case 0: /*LOG_LEVEL_DEBUG*/
-		stLogConfig.strLevel = "ALL";
-		break;
-	case 1: /*LOG_LEVEL_INFO*/
-		stLogConfig.strLevel = "INFO";
-		break;
-	case 2: /*LOG_LEVEL_WARN*/
-		stLogConfig.strLevel = "WARN";
-		break;
-	case 3: /*LOG_LEVEL_ERROR*/
-		stLogConfig.strLevel = "ERROR";
-		break;
-	case 4: /*LOG_LEVEL_FATAL*/
-		stLogConfig.strLevel = "FATAL";
-		break;
-	default:
-		stLogConfig.strLevel = "OFF";
-		break;
-	}
-
-	pEntity->GetFunction()->GetPath("Dbg", stLogConfig.strLogPath);
-	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("DbgPath: %s", stLogConfig.strLogPath.GetData());
-	stLogConfig.Settle();
-
-	LogEvent(Severity_Low, 0, CSimpleStringA::Format("{\"RecordLevel\":\"%s\", \"RecordType\":\"%s\}", stLogConfig.strLevel.GetData(), stLogConfig.strType.GetData()));
-}
-
-
-} //namespace Settings
-} //namespace Comm
-} //namespace Module
-} //SP
-
-
-
-#endif //RVC_MOD_COMM_ENTITY_SETTINGS_HPP_

Module/include/CommEntityUtil.hpp

@@ -32,6 +32,7 @@
 
 #include "path.h"
 #include "toolkit.h"
+#include "charset.h"
 #include <string>
 #include <iostream>
 #include <sstream>
@@ -47,9 +48,6 @@
 
 typedef unsigned long long ULLINT;
 
-
-#define SLEEP(interval) std::this_thread::sleep_for(std::chrono::milliseconds(interval))
-
 namespace SP
 {
 namespace Module
@@ -168,96 +166,6 @@ namespace Module
 
 namespace Comm
 {
-
-/** Rely on  ${OTHER_LIB_BASE_DIR}/libpublicFun and library target libpublicFun*/
-struct LogNotiyMessageStruct
-{
-	std::string Reason;
-	std::string ErrMsg;
-	std::string RebootTime;
-
-	LogNotiyMessageStruct(const CSimpleStringA& reason, const CSimpleStringA& errmsg, const CSimpleStringA& rebootTime)
-		:Reason(reason.GetData()), ErrMsg(reason.GetData()), RebootTime(reason.GetData())
-	{
-	}
-    LogNotiyMessageStruct(const std::string& reason, const std::string& errmsg, const std::string& rebootTime)
-        :Reason(reason), ErrMsg(errmsg), RebootTime(rebootTime)
-    {
-    }
-    LogNotiyMessageStruct(const char* reason, const char* errmsg, char* rebootTime)
-        :Reason(reason), ErrMsg(errmsg), RebootTime(rebootTime)
-    {
-    }
-
-    LogNotiyMessageStruct(const char* errmsg)
-        :Reason(""), ErrMsg(errmsg), RebootTime("")
-    {
-    }
-
-	std::string ToJsonString() const {
-        std::map<std::string, std::string> srcData;
-        srcData.insert(std::make_pair("reason", Reason));
-        srcData.insert(std::make_pair("errmsg", ErrMsg));
-        srcData.insert(std::make_pair("rebootTime", RebootTime));
-		auto ret = generateJsonStr(srcData);
-        if (ret.first) {
-			return ret.second;
-		} else {
-			return ErrMsg;
-		}
-	}
-
-};
-
-struct LogCommNotiyStruct
-{
-	NotifyLevelEnum eLevel;
-	ErrorCodeEnum eSysCode;
-	DWORD dwUserCode;
-	LogCommNotiyStruct() :eLevel(Notify_None), eSysCode(Error_Unexpect), dwUserCode(0) {}
-
-	LogCommNotiyStruct(NotifyLevelEnum level, ErrorCodeEnum errorCode, DWORD dwUserCode)
-		:eLevel(level), eSysCode(errorCode), dwUserCode(dwUserCode) {}
-
-    LogCommNotiyStruct(NotifyLevelEnum level, ErrorCodeEnum errorCode)
-        :eLevel(level), eSysCode(errorCode), dwUserCode(0)
-    { }
-
-	virtual ~LogCommNotiyStruct() {}
-
-	virtual void Notify(const LogNotiyMessageStruct& notifyMessage)
-	{
-		LogNotify(eLevel, eSysCode, dwUserCode, notifyMessage.ToJsonString().c_str());
-	}
-};
-
-struct LogInfoNotiyStruct : public LogCommNotiyStruct
-{
-	LogInfoNotiyStruct(ErrorCodeEnum errorCode, DWORD dwUserCode) 
-		:LogCommNotiyStruct(Notify_Info, errorCode, dwUserCode){}
-    ~LogInfoNotiyStruct() {}
-
-};
-
-struct LogWarnNotiyStruct : public LogCommNotiyStruct
-{
-	LogWarnNotiyStruct(ErrorCodeEnum errorCode, DWORD dwUserCode)
-        :LogCommNotiyStruct(Notify_Warn, errorCode, dwUserCode)
-    {
-    }
-    ~LogWarnNotiyStruct() {}
-
-};
-
-struct LogErrorNotiyStruct : public LogCommNotiyStruct
-{
-	LogErrorNotiyStruct(ErrorCodeEnum errorCode, DWORD dwUserCode)
-        :LogCommNotiyStruct(Notify_Error, errorCode, dwUserCode)
-    {
-    }
-    ~LogErrorNotiyStruct() {}
-};
-
 static BOOL IsFirsRunAppAfterSystemBoot(CEntityBase* pEntity, DWORD theReportUserCode = 0)
 {
 	BOOL result(FALSE);
@@ -284,119 +192,6 @@ static BOOL IsFirsRunAppAfterSystemBoot(CEntityBase* pEntity, DWORD theReportUse
 	return result;
 }
 
-inline
-CSimpleStringA GetCurrMachineType(CEntityBase* pEntity)
-{
-    CSystemStaticInfo sysInfo;
-    pEntity->GetFunction()->GetSystemStaticInfo(sysInfo);
-    return sysInfo.strMachineType;
-}
-            enum Site
-            {
-                CMB_UNKNOWN,
-                CMB_LIB,       /** 行内大堂*/
-                CMB_FLB,      /** 离行机器*/
-            };
-
-#define SITE_ENUM_TYPE(MACRO)	\
-		MACRO(LIB)\
-		MACRO(FLB)
-
-
-#define ENUM_MAP_CONVERT(elem) \
-	if (streq(lpcszSiteName, "CMB."#elem) == 0) return CMB_##elem;
-/*!
- * convert cmb site name to enum type.
- */
-static Site Str2Site(LPCSTR lpcszSiteName)
-{
-	if (lpcszSiteName == NULL || strlen(lpcszSiteName) == 0)
-		return CMB_UNKNOWN;
-	SITE_ENUM_TYPE(ENUM_MAP_CONVERT)
-		return CMB_UNKNOWN;
-}
-
-#undef ENUM_MAP_CONVERT
-#define ENUM_MAP_CONVERT(elem) case CMB_##elem: return "CMB."#elem;
-
-static LPCSTR Site2Str(Site site)
-{
-	switch (site) {
-		SITE_ENUM_TYPE(ENUM_MAP_CONVERT)
-	default:
-		break;
-	}
-	return "Unkown";
-}
-
-            enum What
-            {
-                RVC_UNKNOWN,
-                RVC_Stand2S,          /** 落地式大机*/
-                RVC_PAD,                /** PAD*/
-                RVC_Desk2S,           /** 低柜双屏*/
-                RVC_CardStore,		/** 卡库*/
-                RVC_CardPrinter,     /** 制卡机*/
-				RVC_Stand1SPlus     /** 单屏大机*/
-            };
-
-#define MACHINE_ENUM_TYPE(MACRO)	\
-		MACRO(Stand2S)\
-		MACRO(PAD)\
-		MACRO(Desk2S)\
-		MACRO(CardStore)\
-		MACRO(CardPrinter)\
-		MACRO(Stand1SPlus)
-
-#undef ENUM_MAP_CONVERT
-#define ENUM_MAP_CONVERT(elem) \
-	if (streq(lpcszTypeName, "RVC."#elem) == 0) return RVC_##elem;
-/*!
- * convert cmb site name to enum type.
- */
-static What Str2Type(LPCSTR lpcszTypeName)
-{
-	if (lpcszTypeName == NULL || strlen(lpcszTypeName) == 0)
-		return RVC_UNKNOWN;
-	MACHINE_ENUM_TYPE(ENUM_MAP_CONVERT)
-	return RVC_UNKNOWN;
-}
-
-#undef ENUM_MAP_CONVERT
-#define ENUM_MAP_CONVERT(elem) case RVC_##elem: return "RVC."#elem;
-
-static LPCSTR Type2Str(What what)
-{
-	switch (what) {
-		MACHINE_ENUM_TYPE(ENUM_MAP_CONVERT)
-	default:
-		break;
-	}
-	return "Unkown";
-}
-
-struct TerminalMachineInfo
-{
-	Site site;
-	What type;
-    struct {
-        WORD minor;
-        WORD major;
-    } gen;
-};
-
-inline TerminalMachineInfo GetTerminalMachineInfo(CEntityBase* pEntity)
-{
-    CSystemStaticInfo sysInfo;
-	TerminalMachineInfo termInfo;
-	pEntity->GetFunction()->GetSystemStaticInfo(sysInfo);
-	termInfo.site = Str2Site(sysInfo.strSite);
-	termInfo.type = Str2Type(sysInfo.strMachineType);
-	termInfo.gen.major = sysInfo.MachineVersion.GetMajor();
-	termInfo.gen.minor = sysInfo.MachineVersion.GetMinor();
-	return termInfo;
-}
-
 inline ULLINT RVCGetTickCount()
 {
 #ifdef RVC_OS_WIN
@@ -414,6 +209,9 @@ inline ULLINT RVCGetTickCount()
 
 namespace Util
 {
+	/**
+	 * Need to delete *hexBuf if (*hexBuf) not null
+	 */
 static int StrBuf2HexBuf(const char* strBuf, PBYTE* hexBuf)
 {
     int len = strlen(strBuf);
@@ -443,7 +241,7 @@ static int HexBuf2StrBuf(PBYTE hexBuf, char** strBuf, DWORD len)
     }
     return 0;
 }
-
+/*
 //tips: need to delete result char*
 static char* ConvertBytesToHexStr(BYTE* pBuf, int nLen)
 {
@@ -531,31 +329,7 @@ static bool IsNoStr(const char* str)
 			return false;
 	}
 	return true;
-}
-
-static DWORD GetDuration(const SYSTEMTIME& time1, const SYSTEMTIME& time2)
-{
-#if defined(RVC_OS_WIN)
-
-    ULARGE_INTEGER fTime1;/*FILETIME*/
-    ULARGE_INTEGER fTime2;/*FILETIME*/
-
-    SystemTimeToFileTime(&time1, (FILETIME*)&fTime1);
-    SystemTimeToFileTime(&time2, (FILETIME*)&fTime2);
-
-    unsigned __int64 dft = fTime2.QuadPart - fTime1.QuadPart;
-    return DWORD(dft / 10000);
-
-#else
-    ///**TODO(Gifur@9/3/2021): Bug 不能这样简单的实现，考虑凌晨，切换月份甚至是年份 */
-    DWORD s1, s2;
-    s1 = (time1.wMinute * 60 + time1.wSecond) * 1000 + time1.wMilliseconds;
-    s2 = (time2.wMinute * 60 + time2.wSecond) * 1000 + time2.wMilliseconds;
-
-    return s2 - s1;
-
-#endif //RVC_OS_WIN
-}
+}*/
 
 static std::string formatTime(const SYSTEMTIME& time)
 {
@@ -575,26 +349,12 @@ static bool ShellExecute(const std::string& cmd, std::string& succResult, std::s
 
 	ZeroMemory(&si, sizeof(si));
 	si.cb = sizeof(si);
-	// 设置STARTUPINFO的wShowWindow成员为SW_HIDE，以隐藏窗口
 	si.wShowWindow = SW_HIDE;
 	ZeroMemory(&pi, sizeof(pi));
-
-	// 使用CreateProcess启动程序
-	if (!CreateProcess(NULL,   // 不使用模块名
-		ps, // 命令行
-		NULL,           // 不继承进程句柄
-		NULL,           // 不继承线程句柄
-		FALSE,          // 不继承句柄
-		CREATE_NO_WINDOW,              // 没有创建标志
-		NULL,           // 使用父进程的环境块
-		NULL,           // 使用父进程的当前目录
-		&si,            // 指向STARTUPINFO的指针
-		&pi)            // 指向PROCESS_INFORMATION的指针
-		) {
+	if (!CreateProcess(NULL, ps, NULL, NULL, FALSE, CREATE_NO_WINDOW, NULL, NULL, &si, &pi)) {
 		errResult = errResult + "CreateProcess failed with error:" + strerror(GetLastError());
 		return false;
 	}
-
 	// 等待程序结束，并获取其退出状态
 	WaitForSingleObject(pi.hProcess, INFINITE);
 	DWORD exitCode;
@@ -602,7 +362,6 @@ static bool ShellExecute(const std::string& cmd, std::string& succResult, std::s
 		errResult = errResult + "GetExitCodeProcess failed with error code " + strerror(GetLastError());
 		return false;
 	}
-	// 关闭进程和线程句柄
 	CloseHandle(pi.hProcess);
 	CloseHandle(pi.hThread);
 
@@ -611,7 +370,6 @@ static bool ShellExecute(const std::string& cmd, std::string& succResult, std::s
 		errResult = errResult + "The program exited with code:" + strerror(exitCode);
 		return false;
 	}
-
 	return true;
 #else
 	char buf_ps[1024];
@@ -645,98 +403,23 @@ static CSimpleStringA generateConsumeTimeJson(const CSimpleStringA& entityName,
 }
 
 #if defined(_MSC_VER)
-static char* ConvertUtf8ToGBK(const char* strUtf8)
-{
-	int len = MultiByteToWideChar(CP_UTF8, 0, strUtf8, -1, NULL, 0);
-	WCHAR* wszGBK = new WCHAR[len + 1];
-	memset(wszGBK, 0, len * 2 + 2);
-	MultiByteToWideChar(CP_UTF8, 0, strUtf8, -1, wszGBK, len);
-
-	len = WideCharToMultiByte(CP_ACP, 0, wszGBK, -1, NULL, 0, NULL, NULL);
-	char* szGBK = new char[len + 1];
-	memset(szGBK, 0, len + 1);
-	WideCharToMultiByte(CP_ACP, 0, wszGBK, -1, szGBK, len, NULL, NULL);
-	delete[] wszGBK;
-
-	return szGBK;
-}
 
-static void ConvertUtf8ToGBK(std::string& str)
+static void ConvertUtf82GBK(std::string& str)
 {
 	char* dst = ConvertUtf8ToGBK(str.c_str());
 	str = dst;
-	delete[] dst;
-}
-
-static char* ConvertGBKToUtf8(const char* gbk, int* n)
-{
-	int len = MultiByteToWideChar(CP_ACP, 0, gbk, -1, NULL, 0);
-	WCHAR* wszGBK = new WCHAR[len + 1];
-	memset(wszGBK, 0, len * 2 + 2);
-	MultiByteToWideChar(CP_ACP, 0, gbk, -1, wszGBK, len);
-
-	len = WideCharToMultiByte(CP_UTF8, 0, wszGBK, -1, NULL, 0, NULL, NULL);
-	char* szUtf8 = new char[len + 1];
-	memset(szUtf8, 0, len + 1);
-	WideCharToMultiByte(CP_UTF8, 0, wszGBK, -1, szUtf8, len, NULL, NULL);
-
-	delete[] wszGBK;
-	*n = len - 1;
-	return szUtf8;
+	if(dst) free(dst);
 }
 
-static void ConvertGBKToUtf8(std::string& str)
+static void ConvertGBK2Utf8(std::string& str)
 {
 	int len = 0;
 	char* dst = ConvertGBKToUtf8(str.c_str(), &len);
 	str = dst;
-	delete[] dst;
+	if (dst) free(dst);
 }
-#endif //_MSC_VER
 
-static std::string W2S(const std::wstring wstr)
-{
-#if defined(_MSC_VER)
-	char* str = NULL;
-	int n = ::WideCharToMultiByte(CP_ACP, 0, wstr.c_str(), -1, NULL, 0, NULL, NULL);
-	if (n > 0) {
-		str = new char[n + 1];
-		if (str == NULL) {
-			return std::string();
-		}
-		std::memset(str, 0, sizeof(char) * (n + 1));
-		::WideCharToMultiByte(CP_ACP, 0, wstr.c_str(), -1, &str[0], n, NULL, NULL);
-		std::string strr(str);
-		delete [] str;
-		return strr;
-	}
-#else
-	///*TODO(80374374@3/7/2023):  */
 #endif //_MSC_VER
-	return std::string();
-}
-
-static std::wstring S2W(const std::string str)
-{
-#if defined(_MSC_VER)
-	wchar_t* wstr = NULL;
-	int n = ::MultiByteToWideChar(CP_ACP, 0, str.c_str(), -1, NULL, 0);
-	if (n > 0) {
-		wstr = new wchar_t[n + 1];
-		if (wstr == NULL) {
-			return std::wstring();
-		}
-		std::memset(wstr, 0, (n + 1) * sizeof(wchar_t));
-		::MultiByteToWideChar(CP_ACP, 0, str.c_str(), -1, &wstr[0], n);
-		std::wstring strr(wstr);
-		delete [] wstr;
-		return strr;
-	}
-#else
-	///*TODO(80374374@3/7/2023):  */
-#endif //_MSC_VER
-	return std::wstring();
-}
 
 enum DataTypeToMask
 {
@@ -1076,219 +759,8 @@ static ErrorCodeEnum GetINETMacAddresses(CAutoArray<NetworkAdapterItem>& netList
 
 }
 
-
-static std::vector<NetworkAdapterItem> GetNetAdapterItems()
-{
-	std::vector<NetworkAdapterItem> results;
-#if defined(_MSC_VER)
-	ULONG flags = GAA_FLAG_INCLUDE_PREFIX | GAA_FLAG_INCLUDE_GATEWAYS;
-	ULONG family = AF_UNSPEC;
-	PIP_ADAPTER_ADDRESSES address_ptr = nullptr;
-	ULONG out_buf_len = 15000;
-	DWORD ret_val = 0;
-	PIP_ADAPTER_ADDRESSES cur_addr_ptr = nullptr;
-	PIP_ADAPTER_UNICAST_ADDRESS unicast_ptr = nullptr;
-	PIP_ADAPTER_ANYCAST_ADDRESS anycast_ptr = nullptr;
-	PIP_ADAPTER_MULTICAST_ADDRESS multicast_ptr = nullptr;
-	PIP_ADAPTER_DNS_SERVER_ADDRESS dns_server_ptr = nullptr;
-	IP_ADAPTER_PREFIX* prefix_ptr = nullptr;
-
-	do {
-		address_ptr = (PIP_ADAPTER_ADDRESSES)malloc(out_buf_len);
-		if (address_ptr == nullptr) {
-			return results;
-		}
-		ret_val = GetAdaptersAddresses(family, flags, NULL, address_ptr, &out_buf_len);
-		if (ERROR_BUFFER_OVERFLOW == ret_val) {
-			free(address_ptr);
-		}
-	} while (ret_val == ERROR_BUFFER_OVERFLOW);
-
-	if (NO_ERROR == ret_val) {
-		cur_addr_ptr = address_ptr;
-		while (cur_addr_ptr) {
-			std::string description = Util::W2S(cur_addr_ptr->Description);
-			bool is_local = IsLocalAdapter(cur_addr_ptr->AdapterName);
-			std::string friend_name = Util::W2S(cur_addr_ptr->FriendlyName);
-			NetworkAdapterItem item;
-			item.idx = cur_addr_ptr->IfIndex;
-			item.adapter_name = cur_addr_ptr->AdapterName;
-			item.description = description;
-			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)(">>>>>>>>>>>>>>> friendly name: %s", friend_name.c_str());
-			item.friend_name = friend_name;
-			if (is_local) {
-				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Adapter Desc: %s", description.c_str());
-				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Adapter Name: %s", cur_addr_ptr->AdapterName);
-				item.isLocal = true;
-			}
-			if (cur_addr_ptr->PhysicalAddressLength != 0) {
-				char sz_addr[32] = { 0 };
-				std::stringstream str;
-				for (int i = 0; i < (int)cur_addr_ptr->PhysicalAddressLength; i++) {
-					if (i == ((int)cur_addr_ptr->PhysicalAddressLength - 1))
-						sprintf_s(sz_addr, "%.2X", (int)cur_addr_ptr->PhysicalAddress[i]);
-					else
-						sprintf_s(sz_addr, "%.2X:", (int)cur_addr_ptr->PhysicalAddress[i]);
-					str << sz_addr;
-				}
-				item.mac = str.str();
-			}
-			item.type = cur_addr_ptr->IfType;
-			item.operStatus = cur_addr_ptr->OperStatus;
-			switch (cur_addr_ptr->IfType) {
-			case MIB_IF_TYPE_OTHER:
-				break;
-			case MIB_IF_TYPE_ETHERNET:
-				break;
-			case MIB_IF_TYPE_TOKENRING:
-				break;
-			case MIB_IF_TYPE_FDDI:
-				break;
-			case MIB_IF_TYPE_PPP:
-				break;
-			case MIB_IF_TYPE_LOOPBACK:
-				break;
-			case MIB_IF_TYPE_SLIP:
-				break;
-			case IF_TYPE_IEEE80211:
-				break;
-			case IF_TYPE_WWANPP:
-			case IF_TYPE_WWANPP2:
-				//WWAN devices
-				break;
-			default:
-				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Unknown type %d", cur_addr_ptr->IfType);
-				break;
-			}
-			unicast_ptr = cur_addr_ptr->FirstUnicastAddress;
-			while (unicast_ptr) {
-				char ip[120] = { 0 };
-				if (AF_INET == unicast_ptr->Address.lpSockaddr->sa_family) {
-					inet_ntop(PF_INET, &((sockaddr_in*)unicast_ptr->Address.lpSockaddr)->sin_addr, ip, sizeof(ip));
-				} else if (AF_INET6 == unicast_ptr->Address.lpSockaddr->sa_family) {
-					inet_ntop(PF_INET6, &((sockaddr_in*)unicast_ptr->Address.lpSockaddr)->sin_addr, ip, sizeof(ip));
-				}
-				unicast_ptr = unicast_ptr->Next;
-			}
-			if (cur_addr_ptr->Dhcpv4Server.lpSockaddr) {
-				char ip[120] = { 0 };
-				if (AF_INET == cur_addr_ptr->Dhcpv4Server.lpSockaddr->sa_family) {
-					inet_ntop(PF_INET, &((sockaddr_in*)cur_addr_ptr->Dhcpv4Server.lpSockaddr)->sin_addr, ip, sizeof(ip));
-				} else if (AF_INET6 == cur_addr_ptr->Dhcpv4Server.lpSockaddr->sa_family) {
-					inet_ntop(PF_INET6, &((sockaddr_in*)cur_addr_ptr->Dhcpv4Server.lpSockaddr)->sin_addr, ip, sizeof(ip));
-				}
-				item.dhcp = ip;
-			}
-			dns_server_ptr = cur_addr_ptr->FirstDnsServerAddress;
-			while (dns_server_ptr) {
-				char ip[120] = { 0 };
-				if (AF_INET == dns_server_ptr->Address.lpSockaddr->sa_family) {
-					inet_ntop(PF_INET, &((sockaddr_in*)dns_server_ptr->Address.lpSockaddr)->sin_addr, ip, sizeof(ip));
-				} else if (AF_INET6 == dns_server_ptr->Address.lpSockaddr->sa_family) {
-					inet_ntop(PF_INET6, &((sockaddr_in*)dns_server_ptr->Address.lpSockaddr)->sin_addr, ip, sizeof(ip));
-				}
-				dns_server_ptr = dns_server_ptr->Next;
-			}
-			auto gateway_ptr = cur_addr_ptr->FirstGatewayAddress;
-			while (gateway_ptr) {
-				char ip[120] = { 0 };
-				if (AF_INET == gateway_ptr->Address.lpSockaddr->sa_family) {
-					inet_ntop(PF_INET, &((sockaddr_in*)gateway_ptr->Address.lpSockaddr)->sin_addr, ip, sizeof(ip));
-				} else if (AF_INET6 == gateway_ptr->Address.lpSockaddr->sa_family) {
-					inet_ntop(PF_INET6, &((sockaddr_in*)gateway_ptr->Address.lpSockaddr)->sin_addr, ip, sizeof(ip));
-				}
-				gateway_ptr = gateway_ptr->Next;
-			}
-			results.push_back(item);
-			cur_addr_ptr = cur_addr_ptr->Next;
-		}
-	} else {
-		DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_SYSTEM)("GetAdaptersAddresses failed with error: %d", ret_val);
-	}
-	free(address_ptr);
-#else
-///*TODO(80374374@3/7/2023):  */
-#endif //_MSC_VER
-	return results;
-}
-
-static BOOL CheckLANConnectStatus()
-{
-#if defined(_MSC_VER)
-	DWORD dwFlag(0);
-	BOOL bRet = InternetGetConnectedState(&dwFlag, 0);
-
-	if ((dwFlag & INTERNET_CONNECTION_CONFIGURED) == INTERNET_CONNECTION_CONFIGURED) {
-		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Local system has a valid connection to the Internet, but it might or might not be currently connected.");
-	}
-	if ((dwFlag & INTERNET_CONNECTION_LAN) == INTERNET_CONNECTION_LAN) {
-		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Local system uses a local area network to connect to the Internet.");
-	}
-	if ((dwFlag & INTERNET_CONNECTION_MODEM) == INTERNET_CONNECTION_MODEM) {
-		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Local system uses a modem to connect to the Internet.");
-	}
-	if ((dwFlag & INTERNET_CONNECTION_MODEM_BUSY) == INTERNET_CONNECTION_MODEM_BUSY) {
-		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("No longer used: INTERNET_CONNECTION_MODEM_BUSY");
-	}
-	if ((dwFlag & INTERNET_CONNECTION_OFFLINE) == INTERNET_CONNECTION_OFFLINE) {
-		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Local system is in offline mode.");
-	}
-	if ((dwFlag & INTERNET_CONNECTION_PROXY) == INTERNET_CONNECTION_PROXY) {
-		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Local system uses a proxy server to connect to the Internet.");
-	}
-	if ((dwFlag & INTERNET_RAS_INSTALLED) == INTERNET_RAS_INSTALLED) {
-		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Local system has RAS installed.");
-	}
-
-	if (bRet) {
-		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("InternetGetConnectedState Succeed: 0x%08X", dwFlag);
-	} else {
-		DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_SYSTEM)("InternetGetConnectedState failed: 0x%08X, GLE=%u", dwFlag, GetLastError());
-	}
-	return bRet;
-#else
-	return FALSE;
-#endif //_MSC_VER
-
-}
-
-static std::string GetWWWInfoThroughDig(const std::string& wwwUrl)
-{
-    std::string succStr, errStr;
-    std::string runStr("dig ");
-    runStr += wwwUrl;
-    if (SP::Module::Util::ShellExecute(runStr, succStr, errStr)) {
-        return succStr;
-    } else {
-        return std::string("ShellExecute(") + wwwUrl +  ") failed";
-    }
-}
-
 }//Net
 
-namespace FileSystem {
-
-	static DWORD FetchFileSize(const char* filePath)
-	{
-		int fileSize = 0;
-#if defined(RVC_OS_LINUX)
-		struct stat statbuf;
-		ZeroMemory(&statbuf, sizeof(statbuf));
-		stat(filePath, &statbuf);
-		fileSize = statbuf.st_size;
-#else
-		
-		HANDLE hFile;
-		hFile = CreateFile(filePath, 0, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
-		if (hFile != INVALID_HANDLE_VALUE) {
-			fileSize = GetFileSize(hFile, NULL);
-			CloseHandle(hFile);
-		}
-#endif //RVC_OS_LINUX
-		return fileSize;
-	}
-}
-
 } // mod
 } // sp
 

Module/include/DevEntityCommBase.hpp

@@ -7,7 +7,6 @@
 #include "SpHelper.h"
 #include "DeviceBaseClass.h"
 #include "SimpleString.h"
-#include "ModuleMix.h"
 #include "path.h"
 #include "toolkit.h"
 

Module/include/DevFSMCommBase.hpp

@@ -17,14 +17,10 @@
 
 #if defined(_MSC_VER)
 #pragma comment(lib, "Version.lib")
-typedef ErrorCodeEnum(*DevAdaptObjCreateFunc)(DeviceBaseClass*& baseObj);
-typedef ErrorCodeEnum(*DevAdaptObjReleaseFunc)(DeviceBaseClass*& pBaseObj);
-typedef void(*GetPrefixErrMsgFunc)(char* szErrMsg, DWORD* pMsgLen);
-#else //C/C++ Compiler 
+#endif //_MSC_VER
 using DevAdaptObjCreateFunc = ErrorCodeEnum(*)(DeviceBaseClass*& pOutDevAptObj);
 using DevAdaptObjReleaseFunc = ErrorCodeEnum(*)(DeviceBaseClass*& pInDevAptObj);
 using GetPrefixErrMsgFunc = void(*)(char* szErrMsg, DWORD* pMsgLen);
-#endif //_MSC_VER
 typedef ErrorCodeEnum(*GetDevAdapterVersionFunc)(DevSoftVersion& retVersion);
 
 #define HARDWARE_ENTITY_RESET_ENTITYID(ent, entityID)	\

Module/include/EventCode.h

@@ -167,7 +167,6 @@ static const char* Device_Type_Table[] = {
 #define ERROR_ACCESSAUTH_CONNECT_ACS_28				 0x50280032  //连接ACS服务报错误28
 #define ERROR_ACCESSAUTH_CONNECT_ACS_x				 0x50280033  //连接ACS服务报6和28之外的错误
 #define ERROR_ACCESSAUTH_CONNECT_ACS				 0x50280034  //连接ACS服务失败
-#define ERROR_ACCESSAUTH_ACS_DIGINFO				 0x50280035  //连接ACS服务失败 -- 获取域名解析信息
 
 #define ERR_ACCESSAUTH_GET_SYSTEM_STATIC_INFO        0x50210001  //获取系统静态信息错误
 #define ERR_ACCESSAUTH_SETTIMEZONE                   0x50210002  //设置时区错误

Module/include/ModuleMix.h

@@ -1,18 +0,0 @@
-#ifndef __MODULE_MIX_H
-#define __MODULE_MIX_H
-
-#pragma once
-
-/*MediaController有用到*/
-enum CapTypeEnum
-{
-	CAMTYPE_UNKNOWN = 0,
-	CAMTYPE_ENV,
-	CAMTYPE_OPT,
-	CAMTYPE_EWS,
-	CAMTYPE_HSPS,
-	CAMTYPE_CIRCLE,
-	CAMTYPE_MAX
-};
-
-#endif//__MODULE_MIX_H

Module/include/Other/CSystemStatus.cpp

@@ -1,752 +0,0 @@
-#include "stdafx.h"
-#include "CSystemStatus.h"
-#include "SpBase.h"
-
-#include <Shlwapi.h>
-#include <windows.h>
-#include <string>
-#include <Iphlpapi.h>
-#include <tchar.h>
-#include <atlstr.h>
-#include "WinIoCtl.h"
-#pragma comment(lib,"Iphlpapi.lib") 
-#pragma comment(lib, "Pdh.lib")
-#pragma comment(lib, "Shlwapi.lib")
- 
- 
-CSystemStatus::CSystemStatus()
-{
-	m_Query = NULL;
-	m_CpuTotal = NULL;
-	m_DiskRead = NULL;
-	m_DiskWrite= NULL;
-	m_NetDownload=NULL;
-	m_NetUpload=NULL;
-}
- 
-CSystemStatus::~CSystemStatus()
-{
-	if (m_CpuTotal){
-		PdhRemoveCounter(m_CpuTotal);
-		m_CpuTotal = NULL;
-	}
-	if (m_CpuTotal){
-		PdhRemoveCounter(m_CpuTotal);
-		m_CpuTotal = NULL;
-	}
-	if (m_DiskRead){
-		PdhRemoveCounter(m_DiskRead);
-		m_DiskRead = NULL;
-	}
-	if (m_DiskWrite){
-		PdhRemoveCounter(m_DiskWrite);
-		m_DiskWrite = NULL;
-	}
-	if (m_NetDownload)
-	{	
-		PdhRemoveCounter(m_NetDownload);
-		m_NetDownload = NULL;
-	}
-	if (m_NetUpload)
-	{
-		PdhRemoveCounter(m_NetUpload);
-		m_NetUpload = NULL;
-	}
-	if(m_Query){
-		PdhCloseQuery(m_Query);
-		m_Query = NULL;
-	}
-	//SystemUnInit();
-}
- 
-
-//初始化
-void CSystemStatus::SystemInit(DWORD object)
-{
-	PDH_STATUS state;
-	state = PdhOpenQuery(NULL, NULL, &m_Query);
-
-	if (object&SYSSTATE_CPU_USAGE)	//CPU使用率
-		state = PdhAddCounter(m_Query, _T("\\Processor(_Total)\\% Processor Time"), NULL, &m_CpuTotal);
-	if (object&SYSSTATE_DISK_READ)	//磁盘读速度
-		state = PdhAddCounter(m_Query, _T("\\PhysicalDisk(_Total)\\Disk Read Bytes/sec"), NULL, &m_DiskRead);
-	if (object&SYSSTATE_DISK_WRITE)	//磁盘写速度
-		state = PdhAddCounter(m_Query, _T("\\PhysicalDisk(_Total)\\Disk Write Bytes/sec"), NULL, &m_DiskWrite);
-	if (object&SYSSTATE_NET_DOWNLOAD)//网络下载速度
-		state = PdhAddCounter(m_Query, _T("\\Network Interface(killer E2200 Gigabit Ethernet Controller)\\Bytes Received/sec"), NULL, &m_NetDownload);
-	if (object&SYSSTATE_NET_UPLOAD)	//网络上传速度
-		state = PdhAddCounter(m_Query, _T("\\Network Interface(killer E2200 Gigabit Ethernet Controller)\\Bytes Sent/sec"), NULL, &m_NetUpload);
-
-	state = PdhCollectQueryData(m_Query);
-	Sleep(500);             //这里要有延时不然结果相当不准确  
-	state =	PdhCollectQueryData(m_Query); 
-}
-
-//获取网络下载速度（K/s）
-double CSystemStatus::GetSystemNetDownloadRate()
-{
-	PDH_FMT_COUNTERVALUE counterVal;
-	PDH_STATUS lStatus = PdhGetFormattedCounterValue(m_NetDownload, PDH_FMT_DOUBLE, NULL, &counterVal);
-	if(ERROR_SUCCESS != lStatus)  return -1;
-	double dbVal= counterVal.doubleValue; 
-	double NetDownload = (double)((dbVal/(1024*1.0f)));
-	return NetDownload;
-}
-
-//获取网络上传速度
-double CSystemStatus::GetSystemNetUploadRate()
-{
-	PDH_FMT_COUNTERVALUE counterVal;
-	PDH_STATUS lStatus = PdhGetFormattedCounterValue(m_NetUpload, PDH_FMT_DOUBLE, NULL, &counterVal);
-	if(ERROR_SUCCESS != lStatus)  return -1;
-	double dbVal= counterVal.doubleValue; 
-	double NetUpload = (double)((dbVal/(1024*1.0f)));
-	return NetUpload;
-}
-
-//获取系统当前磁盘读速率(K/s)
-double CSystemStatus::GetSystemDiskReadRate()
-{
-	PDH_FMT_COUNTERVALUE counterVal;
-	PDH_STATUS lStatus = PdhGetFormattedCounterValue(m_DiskRead, PDH_FMT_DOUBLE, NULL, &counterVal);
-	if(ERROR_SUCCESS != lStatus)  return -1;
-	double dbVal= counterVal.doubleValue; 
-	double dbDiskRead = (double)((dbVal/(1024*1.0f)));
-	return dbDiskRead;
-}
-
-//获取系统当前磁盘写速率
-double CSystemStatus::GetSystemDiskWriteRate()
-{
-	PDH_FMT_COUNTERVALUE counterVal;
-	PDH_STATUS lStatus = PdhGetFormattedCounterValue(m_DiskWrite, PDH_FMT_DOUBLE, NULL, &counterVal);
-	if(ERROR_SUCCESS != lStatus)  return -1;
-	double dbVal= counterVal.doubleValue; 
-	double dbDiskWrite = (double)((dbVal/(1024*1.0f)));
-	return dbDiskWrite;
-}
-
-//获取CPU使用值
-double CSystemStatus::GetSystemCpuCurrentUsage()
-{
-	PDH_FMT_COUNTERVALUE counterVal;
-	 // CPU时间，注意必须加上PDH_FMT_NOCAP100参数，否则多核CPU会有问题
-	PDH_STATUS lStatus = PdhGetFormattedCounterValue(m_CpuTotal, PDH_FMT_DOUBLE| PDH_FMT_NOCAP100, NULL, &counterVal);
-	if(ERROR_SUCCESS != lStatus)  return -1;
-	return counterVal.doubleValue;//PDH_INVALID_ARGUMENT PDH_INVALID_DATA 
-}
- 
-//反初始化
-void CSystemStatus::SystemUnInit()
-{
-	if (m_CpuTotal){
-		PdhRemoveCounter(m_CpuTotal);
-		m_CpuTotal = NULL;
-	}
-	if (m_DiskRead){
-		PdhRemoveCounter(m_DiskRead);
-		m_DiskRead = NULL;
-	}
-	if (m_DiskWrite){
-		PdhRemoveCounter(m_DiskWrite);
-		m_DiskWrite = NULL;
-	}
-	if (m_NetDownload)
-	{	
-		PdhRemoveCounter(m_NetDownload);
-		m_NetDownload = NULL;
-	}
-	if (m_NetUpload)
-	{
-		PdhRemoveCounter(m_NetUpload);
-		m_NetUpload = NULL;
-	}
-	if(m_Query){
-		PdhCloseQuery(m_Query);
-		m_Query = NULL;
-	}
-}
-
-// 获取系统所有硬盘使用情况		
-void CSystemStatus::GetSystemDiskStatus(ULONGLONG& AllDiskTotal, ULONGLONG& AllDiskFree)
-{
-	int DType = 0;
-	int si = 0;
-	BOOL bResult = FALSE;
-	int DiskCount = 0;
-	ULONGLONG nTempTotal = 0;
-	ULONGLONG nTempFree = 0;
-
-	ULONGLONG i64FreeBytesToCaller;  
-	ULONGLONG i64TotalBytes;  
-	ULONGLONG i64FreeBytes;
-
-	//枚举磁盘数量
-	DWORD DiskInfo = GetLogicalDrives();
-	while (DiskInfo){
-		if (DiskInfo & 1){
-			++DiskCount;
-		}
-		DiskInfo = DiskInfo >> 1;
-	}
-	int test = DiskCount;
-	int DSLength = GetLogicalDriveStrings(0, NULL);
-
-	TCHAR* DStr = NULL;
-	while (!DStr){
-		DStr = new TCHAR[DSLength];
-	}
-	if (NULL == DStr){
-		return;
-	}
-	int nRet = GetLogicalDriveStrings(DSLength, (LPTSTR)DStr);
-
-	//枚举磁盘名称
-	for (int i = 0;i < DSLength / 4; i++){
-		TCHAR strDisk[3] = {0};
-		_stprintf(strDisk, _T("%c:"), DStr[si]);
-		DType = GetDriveType(DStr + i * 4);
-		bResult = GetDiskFreeSpaceEx(
-			strDisk, 
-			(PULARGE_INTEGER)&i64FreeBytesToCaller,
-			(PULARGE_INTEGER)&i64TotalBytes,
-			(PULARGE_INTEGER)&i64FreeBytes);
-
-		if (bResult){
-			nTempTotal += (ULONGLONG)i64TotalBytes / 1024 / 1024 / 1024;
-			nTempFree += (ULONGLONG)i64FreeBytesToCaller / 1024 / 1024 / 1024;
-		}
-		else{
-			OutputDebugString(_T("设备未准备..."));
-		}
-		si += 4;
-	}
-	AllDiskTotal = nTempTotal;
-	AllDiskFree = nTempFree;
-
-	delete[] DStr;
-}
-
-// 获取系统各个硬盘使用情况		
-void CSystemStatus::GetSystemDiskStatus(std::vector<EACHDISKSTATUS> &vectorDisk)
-{
-	int DType = 0;
-	int si = 0;
-	BOOL bResult = FALSE;
-	int DiskCount = 0;
-	ULONGLONG nTempTotal = 0;
-	ULONGLONG nTempFree = 0;
-
-	ULONGLONG i64FreeBytesToCaller;  
-	ULONGLONG i64TotalBytes;  
-	ULONGLONG i64FreeBytes;
-
-	//枚举磁盘数量
-	DWORD DiskInfo = GetLogicalDrives();
-	while (DiskInfo){
-		if (DiskInfo & 1){
-			++DiskCount;
-		}
-		DiskInfo = DiskInfo >> 1;
-	}
-	int test = DiskCount;
-	int DSLength = GetLogicalDriveStrings(0, NULL);
-
-	TCHAR* DStr = NULL;
-	while (!DStr){
-		DStr = new TCHAR[DSLength];
-	}
-	if (NULL == DStr){
-		return;
-	}
-	int nRet = GetLogicalDriveStrings(DSLength, (LPTSTR)DStr);
-
-	EACHDISKSTATUS diskstatus;
-	//枚举磁盘名称
-	for (int i = 0;i < DSLength / 4; i++){
-		TCHAR strDisk[3] = {0};
-		_stprintf(strDisk, _T("%c:"), DStr[si]);
-		DType = GetDriveType(DStr + i * 4);
-		bResult = GetDiskFreeSpaceEx(
-			strDisk, 
-			(PULARGE_INTEGER)&i64FreeBytesToCaller,
-			(PULARGE_INTEGER)&i64TotalBytes,
-			(PULARGE_INTEGER)&i64FreeBytes);
-
-		if (bResult)
-		{
-			diskstatus._strdir=strDisk[0];
-			double total = ((i64TotalBytes  / 1024 / 1024)  * 100)/ 1024;
-			diskstatus._Total=total/100.0f;
-			double OfFree = ((i64FreeBytesToCaller  / 1024 / 1024)  * 100)/ 1024;
-			diskstatus._OfFree=OfFree/100.0f;
-			vectorDisk.push_back(diskstatus);
-		}
-		else
-		{
-			OutputDebugString(_T("设备未准备..."));
-		}
-		si += 4;
-	}
-
-	delete[] DStr;
-}
-
-//获取系统当前磁盘状态
-void CSystemStatus::GetSystemCurrentDiskStatus(ULONGLONG& TatolMB, ULONGLONG& FreeCaller)
-{
-	BOOL bResult = FALSE;
-	ULONGLONG nTempTotal = 0;
-	ULONGLONG nTempFree = 0;
-
-	ULONGLONG ui64FreeBytesToCaller;  
-	ULONGLONG ui64TotalBytes;  
-	ULONGLONG ui64FreeBytes;
-
-	TCHAR szModule[MAX_PATH*2] = {0};
-	GetModuleFileName(NULL, szModule, MAX_PATH*2);
-#ifdef _UNICODE
-	wstring strPath(szModule);
-	wstring strDirve = strPath.substr(0, 1);
-#else
-	std::string strPath(szModule);
-	std::string strDirve = strPath.substr(0, 1);
-#endif
-	TCHAR szDisk[3] = {0};
-	_stprintf(szDisk, _T("%c:"), strDirve[0]);
-	bResult = GetDiskFreeSpaceEx(
-		szDisk, 
-		(PULARGE_INTEGER)&ui64FreeBytesToCaller,	//用户可用的磁盘空间
-		(PULARGE_INTEGER)&ui64TotalBytes,			//磁盘总共的空间
-		(PULARGE_INTEGER)&ui64FreeBytes);			//磁盘空闲的空间.以上都是字节为单位。
-	if (bResult){
-		nTempTotal = ui64TotalBytes / 1024 / 1024 / 1024;
-		nTempFree = ui64FreeBytesToCaller / 1024 / 1024 / 1024;
-		TatolMB = nTempTotal;
-		FreeCaller = nTempFree;
-	}
-}
-
-//获取系统当前磁盘使用率
-double CSystemStatus::GetSystemCurrentDiskUsage()
-{
-	BOOL bResult = FALSE;
-	ULONGLONG ui64FreeBytesToCaller;  
-	ULONGLONG ui64TotalBytes;  
-	ULONGLONG ui64FreeBytes;
-
-	TCHAR szModule[MAX_PATH*2] = {0};
-	GetModuleFileName(NULL, szModule, MAX_PATH*2);
-	::PathRemoveFileSpec(szModule);
-#ifdef _UNICODE
-	wstring strPath(szModule);
-	wstring strDirve = strPath.substr(0, 1);
-#else
-	std::string strPath(szModule);
-	std::string strDirve = strPath.substr(0, 1);
-#endif
-
-	TCHAR szDisk[3] = {0};
-	_stprintf(szDisk, _T("%c:"), strDirve[0]);
-	bResult = GetDiskFreeSpaceEx(
-		szDisk, 
-		(PULARGE_INTEGER)&ui64FreeBytesToCaller,	//用户可用的磁盘空间
-		(PULARGE_INTEGER)&ui64TotalBytes,			//磁盘总共的空间
-		(PULARGE_INTEGER)&ui64FreeBytes);			//磁盘空闲的空间.以上都是字节为单位。
-	if (bResult){
-		double TempNum  = ((ui64TotalBytes / 1024 / 1024 / 1024)-(ui64FreeBytesToCaller/ 1024 / 1024 / 1024))* 100.0 / (ui64TotalBytes/ 1024 / 1024 / 1024);
-		return TempNum;
-	}
-	return 0;
-}
- 
-//物理内存和使用
-BOOL CSystemStatus::GetPhysicalMemoryState(ULONGLONG& totalPhysMem, ULONGLONG& physMemUsed)
-{
-	MEMORYSTATUSEX memInfo;
-	memInfo.dwLength = sizeof(MEMORYSTATUSEX);
-	GlobalMemoryStatusEx(&memInfo);
-	totalPhysMem = memInfo.ullTotalPhys;
-	physMemUsed = memInfo.ullTotalPhys - memInfo.ullAvailPhys;
-	return TRUE;
-}
- 
-//机器物理内存容量(总可用内存)
-double CSystemStatus::GetTotalPhysicalMemory()
-{
-	MEMORYSTATUSEX memInfo;
-	memInfo.dwLength = sizeof(MEMORYSTATUSEX);
-	GlobalMemoryStatusEx(&memInfo);
-	double totalPhysMem = ((memInfo.ullTotalPhys  / 1024 / 1024)  * 100)/ 1024;
-	double fTemptotal = totalPhysMem / 100.0;
-	return fTemptotal;
-}
-
-//机器物理内存容量(空闲内存)
-double CSystemStatus::GetTotalPhysicalMemoryFree()
-{
-	MEMORYSTATUSEX memInfo;
-	memInfo.dwLength = sizeof(MEMORYSTATUSEX);
-	GlobalMemoryStatusEx(&memInfo);
-	double physMemFree = (((memInfo.ullAvailPhys) / 1024 / 1024) * 100) / 1024;;
-	double fTemMemFree = physMemFree / 100.0;
-	return fTemMemFree;
-}
- 
-//机器物理内存使用(已使用内存)
-double CSystemStatus::GetTotalPhysicalMemoryUsed()
-{
-	MEMORYSTATUSEX memInfo;
-	memInfo.dwLength = sizeof(MEMORYSTATUSEX);
-	GlobalMemoryStatusEx(&memInfo);
-	double physMemUsed = (((memInfo.ullTotalPhys - memInfo.ullAvailPhys) / 1024 / 1024) * 100) / 1024;;
-	double fTemMemUsed = physMemUsed / 100.0;
-	return fTemMemUsed;
-}
- 
-//机器物理内存使用率 
-double CSystemStatus::GetPhysicalMemoryUsage()
-{
-	MEMORYSTATUSEX memInfo;
-	memInfo.dwLength = sizeof(MEMORYSTATUSEX);
-	GlobalMemoryStatusEx(&memInfo);
-	double MemUsage = memInfo.dwMemoryLoad;
-	return MemUsage;
-}
-
-//获取网卡信息（在获取网速时需要用到网卡描述）
-void CSystemStatus::GetNetCardInfo(std::vector<NETCARDINFO> &vectorNetCard)
-{
-
-	NETCARDINFO NetCardInfo;
-
-	PIP_ADAPTER_INFO pIpAdapterInfo = new IP_ADAPTER_INFO();
-	//得到结构体大小,用于GetAdaptersInfo参数
-	unsigned long stSize = sizeof(IP_ADAPTER_INFO);
-	//调用GetAdaptersInfo函数,填充pIpAdapterInfo指针变量;其中stSize参数既是一个输入量也是一个输出量
-	int nRel = GetAdaptersInfo(pIpAdapterInfo,&stSize);
-	//记录网卡数量
-	int netCardNum = 0;
-	//记录每张网卡上的IP地址数量
-	int IPnumPerNetCard = 0;
-	if (ERROR_BUFFER_OVERFLOW == nRel)
-	{
-		//如果函数返回的是ERROR_BUFFER_OVERFLOW
-		//则说明GetAdaptersInfo参数传递的内存空间不够,同时其传出stSize,表示需要的空间大小
-		//这也是说明为什么stSize既是一个输入量也是一个输出量
-		//释放原来的内存空间
-		delete pIpAdapterInfo;
-		//重新申请内存空间用来存储所有网卡信息
-		pIpAdapterInfo = (PIP_ADAPTER_INFO)new BYTE[stSize];
-		//再次调用GetAdaptersInfo函数,填充pIpAdapterInfo指针变量
-		nRel=GetAdaptersInfo(pIpAdapterInfo,&stSize);    
-	}
-	if (ERROR_SUCCESS == nRel)
-	{
-		//输出网卡信息
-		//可能有多网卡,因此通过循环去判断
-		while (pIpAdapterInfo)
-		{
-			++netCardNum;				//网卡数量
-
-			NetCardInfo.Name=pIpAdapterInfo->AdapterName;		//网卡名称
-			NetCardInfo.Description=pIpAdapterInfo->Description;//网卡描述
-			
-			switch(pIpAdapterInfo->Type)//网卡类型
-			{
-			case MIB_IF_TYPE_OTHER:break;
-			case MIB_IF_TYPE_ETHERNET:break;
-			case MIB_IF_TYPE_TOKENRING:break;
-			case MIB_IF_TYPE_FDDI:break;
-			case MIB_IF_TYPE_PPP:break;
-			case MIB_IF_TYPE_LOOPBACK:break;
-			case MIB_IF_TYPE_SLIP:break;
-			}
-			//网卡MAC地址
-			char tempchar[4];
-			for (DWORD i = 0; i < pIpAdapterInfo->AddressLength; i++)
-				if (i < pIpAdapterInfo->AddressLength-1)
-				{
-					printf("%02X-", pIpAdapterInfo->Address[i]);
-		
-					sprintf(tempchar,"%02X-",pIpAdapterInfo->Address[i]);
-					NetCardInfo.Local_Mac+=tempchar;
-					
-
-				}
-				else
-				{
-					printf("%02X", pIpAdapterInfo->Address[i]);
-		
-					sprintf(tempchar,"%02X",pIpAdapterInfo->Address[i]);
-					NetCardInfo.Local_Mac+=tempchar;
-					
-				}
-			
-			//网卡IP地址
-			//可能网卡有多IP,因此通过循环去判断
-			IP_ADDR_STRING *pIpAddrString =&(pIpAdapterInfo->IpAddressList);
-			do 
-			{
-				//cout<<"该网卡上的IP数量："<<++IPnumPerNetCard<<endl;
-				//cout<<"IP 地址："<<pIpAddrString->IpAddress.String<<endl;
-				//cout<<"子网地址："<<pIpAddrString->IpMask.String<<endl;
-				//cout<<"网关地址："<<pIpAdapterInfo->GatewayList.IpAddress.String<<endl;
-
-				NetCardInfo.Local_IP=pIpAddrString->IpAddress.String;
-
-				pIpAddrString=pIpAddrString->Next;
-			} while (pIpAddrString);
-
-			vectorNetCard.push_back(NetCardInfo);
-
-			pIpAdapterInfo = pIpAdapterInfo->Next;
-		}
-
-	}
-	if (pIpAdapterInfo)
-	{
-		delete pIpAdapterInfo;
-
-		pIpAdapterInfo=NULL;
-	}
-}
-
-//获取操作系统信息 
-void CSystemStatus::GetOsInfo(std::string& strOSName, std::string& strOSArch)
-{
-	// get os name according to version number
-
-	OSVERSIONINFOEX osvi;
-	SYSTEM_INFO si;
-
-	/** 因受系统限制，该接口获取的操作系统版本从8.1开始不对 Gifur@2023724]*/
-	ZeroMemory(&osvi, sizeof(OSVERSIONINFOEX));
-	osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
-	GetVersionEx((LPOSVERSIONINFO)&osvi);
-
-	ZeroMemory(&si, sizeof(SYSTEM_INFO));
-	GetSystemInfo(&si);
-
-	strOSName = "Unknown";
-	if (osvi.dwMajorVersion == 4 && osvi.dwMinorVersion == 0)
-	{
-		if(osvi.dwPlatformId==VER_PLATFORM_WIN32_NT) 
-			strOSName="Microsoft Windows NT 4.0 ";             
-		else if(osvi.dwPlatformId==VER_PLATFORM_WIN32_WINDOWS) 
-			strOSName="Microsoft Windows 95 "; 
-	}
-	else if (osvi.dwMajorVersion == 4 && osvi.dwMinorVersion == 10)
-		strOSName = "Microsoft Windows 98";
-	else if (osvi.dwMajorVersion == 4 && osvi.dwMinorVersion == 90)
-		strOSName = "Microsoft Windows Me";
-	else if (osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 0)
-	{
-		strOSName = "Microsoft Windows 2000";
-		if(osvi.wSuiteMask==VER_SUITE_ENTERPRISE) 
-			strOSName += " Advanced Server "; 
-	}
-	else if (osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 1)
-	{
-		strOSName = "Microsoft Windows XP";
-
-		if(osvi.wSuiteMask==VER_SUITE_EMBEDDEDNT) 
-			strOSName+=" Embedded "; 
-		else if(osvi.wSuiteMask==VER_SUITE_PERSONAL) 
-			strOSName+=" Home Edition "; 
-		else
-			strOSName+=" Professional ";
-	}
-	else if (osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 2)
-	{
-		if(osvi.wProductType==VER_NT_WORKSTATION &&si.wProcessorArchitecture==PROCESSOR_ARCHITECTURE_AMD64)
-			strOSName="Microsoft Windows XP Professional x64 Edition "; 
-		if(GetSystemMetrics(SM_SERVERR2)==0 && osvi.wSuiteMask==VER_SUITE_BLADE)
-			strOSName ="Microsoft Windows Server 2003 Web Edition "; 
-		else if(GetSystemMetrics(SM_SERVERR2)==0 && osvi.wSuiteMask==VER_SUITE_COMPUTE_SERVER) 
-			strOSName="Microsoft Windows Server 2003 Compute Cluster Edition "; 
-		else if(GetSystemMetrics(SM_SERVERR2)==0 &&  osvi.wSuiteMask==VER_SUITE_STORAGE_SERVER) 
-			strOSName="Microsoft Windows Server 2003 Storage Server "; 
-		else if(GetSystemMetrics(SM_SERVERR2)==0 &&   osvi.wSuiteMask==VER_SUITE_DATACENTER) 
-			strOSName="Microsoft Windows Server 2003 Datacenter Edition "; 
-		else if(GetSystemMetrics(SM_SERVERR2)==0 &&   osvi.wSuiteMask==VER_SUITE_ENTERPRISE) 
-			strOSName="Microsoft Windows Server 2003 Enterprise Edition "; 
-		else if(GetSystemMetrics(SM_SERVERR2)!=0 &&   osvi.wSuiteMask==VER_SUITE_STORAGE_SERVER)
-			strOSName="Microsoft Windows Server 2003 R2 Storage Server ";
-	}
-	else if (osvi.dwMajorVersion == 6 && osvi.dwMinorVersion == 0)
-	{
-		if(osvi.wProductType==VER_NT_WORKSTATION)
-		{
-			strOSName="Microsoft Windows Vista "; 
-			if (osvi.wSuiteMask==VER_SUITE_PERSONAL)
-				strOSName+=" Home";
-		}				
-		else if (osvi.wProductType != VER_NT_WORKSTATION) {
-			strOSName = "Microsoft Windows Server 2008 ";
-			if (osvi.wSuiteMask == VER_SUITE_DATACENTER)
-				strOSName += " Datacenter Server ";
-			else if (osvi.wSuiteMask == VER_SUITE_ENTERPRISE)
-				strOSName += " Enterprise ";
-		}
-	}
-	else if (osvi.dwMajorVersion == 6 && osvi.dwMinorVersion == 1)
-	{
-		strOSName = "Microsoft Windows 7.0";
-	}
-	else if (osvi.dwMajorVersion == 6 && osvi.dwMinorVersion == 2)
-	{
-		strOSName = "Microsoft Windows 8.0";
-	}
-	else if (osvi.dwMajorVersion == 6 && osvi.dwMinorVersion == 3)
-	{
-		strOSName = "Microsoft Windows 8.1";
-	}
-	else if (osvi.dwMajorVersion == 10 && osvi.dwMinorVersion == 0)
-	{
-		strOSName = "Microsoft Windows 10.0";
-	}
-	SYSTEM_INFO sie;
-	ZeroMemory(&sie, sizeof(SYSTEM_INFO));
-	GetNativeSystemInfo(&sie);
-	strOSArch = "Unknown";
-	if (sie.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64 ||
-		sie.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_IA64) {
-		strOSArch = "x64";
-	} else {
-		strOSArch = "x86";
-	}
-}
-
-//获取CPU硬件信息 
-void CSystemStatus::GetCpuInfo(std::string &CPUinfo)
-{
-	int cpuInfo[4] = {-1};
-	char cpu_manufacture[32] = { 0 };
-	char cpu_type[32] = { 0 };
-	char cpu_freq[32] = { 0 };
-
-	__cpuid(cpuInfo, 0x80000002);
-	memcpy(cpu_manufacture, cpuInfo, sizeof(cpuInfo));
-
-	__cpuid(cpuInfo, 0x80000003);
-	memcpy(cpu_type, cpuInfo, sizeof(cpuInfo));
-
-	__cpuid(cpuInfo, 0x80000004);
-	memcpy(cpu_freq, cpuInfo, sizeof(cpuInfo));
-
-	std::string manufacture=cpu_manufacture;//制造商
-	std::string type=cpu_type;				//型号
-	std::string freq=cpu_freq;				//频率
-	CPUinfo=manufacture+type+freq;
-}
-
-//获取CPUid
-void CSystemStatus::GetCPUid(std::string &CPUid)
-{
-	unsigned long s1,s2,s3,s4; 
-	__asm 
-	{ 
-		mov eax,00h 
-			xor edx,edx 
-			cpuid 
-			mov s1, edx 
-			mov s2, eax 
-	} 
-	__asm 
-	{ 
-		mov eax,01h 
-			xor ecx,ecx 
-			xor edx,edx 
-			cpuid 
-			mov s3, edx 
-			mov s4, ecx 
-	} 
-
-	CString st;
-	st.Format("%08X%08X%08X%08X",s1,s2,s3,s4);
-	CPUid=st.GetBuffer(0);
-	st.ReleaseBuffer();
-}
-
-
-
-BOOL CSystemStatus::GetHDSerial(std::string &HDSerial)
-{ 
-	BOOL		bRtn     = FALSE;
-	DWORD		bytesRtn = 0;
-	char		szhd[80] = {0}; 
-	PIDSECTOR	phdinfo; 
-	HANDLE		hDrive	 = NULL; 
-	GETVERSIONOUTPARAMS vers; 
-	SENDCMDINPARAMS		in; 
-	SENDCMDOUTPARAMS	out; 
-
-	ZeroMemory(&vers, sizeof(vers)); 
-	ZeroMemory(&in  , sizeof(in)); 
-	ZeroMemory(&out , sizeof(out)); 
-
-	//搜索四个物理硬盘，取第一个有数据的物理硬盘 
-	for (int j=0; j<4; j++)
-	{
-		sprintf(szhd,	"\\\\.\\PhysicalDrive%d",j); 
-		hDrive = CreateFileA(szhd, 
-			GENERIC_READ|GENERIC_WRITE, 
-			FILE_SHARE_READ|FILE_SHARE_WRITE,
-			0,
-			OPEN_EXISTING,
-			0,
-			0); 
-		if (NULL == hDrive)continue; 
-		
-		if (!DeviceIoControl(hDrive, DFP_GET_VERSION, 0, 0, &vers, sizeof(vers), &bytesRtn,0))goto FOREND;
-		//If IDE identify command not supported, fails 
-		if (!(vers.fCapabilities&1))goto FOREND;
-
-		//Identify the IDE drives 
-		if (j&1)in.irDriveRegs.bDriveHeadReg = 0xb0; 
-		else in.irDriveRegs.bDriveHeadReg = 0xa0; 
-		 
-		if (vers.fCapabilities&(16>>j))goto FOREND;	//We don't detect a ATAPI device. 
-		else in.irDriveRegs.bCommandReg = 0xec; 
-		 
-		in.bDriveNumber = j; 
-		in.irDriveRegs.bSectorCountReg  = 1; 
-		in.irDriveRegs.bSectorNumberReg = 1; 
-		in.cBufferSize = 512; 
-
-		if (!DeviceIoControl(hDrive, DFP_RECEIVE_DRIVE_DATA, &in, sizeof(in), &out, sizeof(out), &bytesRtn,0))
-		{ 
-			//"DeviceIoControl failed:DFP_RECEIVE_DRIVE_DATA"<<endl; 
-			goto FOREND; 			
-		} 
-		phdinfo=(PIDSECTOR)out.bBuffer; 
-
-		char	s[21] = {0};		
-		memcpy(s, phdinfo->sSerialNumber, 20); 		
-		s[20] = 0; 
-		ChangeByteOrder(s, 20); 
-
-		//删除空格字符
-		int ix = 0;
-		for (ix=0; ix<20; ix++)
-		{
-			if (s[ix] == ' ')continue;
-			break;
-		}
-		char lpszHD[128]={0};
-		memcpy(lpszHD, s+ix, 20);
-
-		HDSerial=lpszHD;
-
-		bRtn = TRUE;
-		if (bRtn)break;				
-FOREND:
-		CloseHandle(hDrive); 
-		hDrive = NULL; 
-	}
-
-	CloseHandle(hDrive); 
-	hDrive = NULL; 
-	return(bRtn);
-}

Module/include/Other/CSystemStatus.h

@@ -1,161 +0,0 @@
-#ifndef __CSystemStatus_h__
-#define __CSystemStatus_h__
-#include <vector>
-#include <string>
- 
-typedef struct
-{
-	std::string _strdir;			//磁盘名称
-	float	_Total;					//磁盘总容量MB
-	float	_OfFree;				//磁盘剩余容量MB
-}EACHDISKSTATUS,*LPEACHDISKSTATUS;
-
-typedef struct
-{
-	std::string Name;				//网卡名称
-	std::string Description;		//网卡描述
-	std::string Local_IP;			//IP地址
-	std::string Local_Mac;			//MAC地址
-}NETCARDINFO,*LPNETCARDINFO;
-
-
-#define SYSSTATE_NONE			0x00000000
-#define SYSSTATE_CPU_USAGE		0x00000001
-#define SYSSTATE_DISK_READ		0x00000002
-#define SYSSTATE_DISK_WRITE		0x00000004
-#define SYSSTATE_NET_DOWNLOAD	0x00000008
-#define SYSSTATE_NET_UPLOAD		0x00000010
-
-typedef struct
-{ 
-	BYTE bVersion; // Binary driver version. 
-	BYTE bRevision; // Binary driver revision. 
-	BYTE bReserved; // Not used. 
-	BYTE bIDEDeviceMap; // Bit map of IDE devices. 
-	DWORD fCapabilities; // Bit mask of driver capabilities. 
-	DWORD dwReserved[4]; // For future use. 
-} GETVERSIONOUTPARAMS, *PGETVERSIONOUTPARAMS, *LPGETVERSIONOUTPARAMS; 
-
-typedef struct
-{ 
-	USHORT wGenConfig; 
-	USHORT wNumCyls; 
-	USHORT wReserved; 
-	USHORT wNumHeads; 
-	USHORT wBytesPerTrack; 
-	USHORT wBytesPerSector; 
-	USHORT wSectorsPerTrack; 
-	USHORT wVendorUnique[3]; 
-	CHAR sSerialNumber[20]; 
-	USHORT wBufferType; 
-	USHORT wBufferSize; 
-	USHORT wECCSize; 
-	CHAR sFirmwareRev[8]; 
-	CHAR sModelNumber[40]; 
-	USHORT wMoreVendorUnique; 
-	USHORT wDoubleWordIO; 
-	USHORT wCapabilities; 
-	USHORT wReserved1; 
-	USHORT wPIOTiming; 
-	USHORT wDMATiming; 
-	USHORT wBS; 
-	USHORT wNumCurrentCyls; 
-	USHORT wNumCurrentHeads; 
-	USHORT wNumCurrentSectorsPerTrack; 
-	ULONG ulCurrentSectorCapacity; 
-	USHORT wMultSectorStuff; 
-	ULONG ulTotalAddressableSectors; 
-	USHORT wSingleWordDMA; 
-	USHORT wMultiWordDMA; 
-	BYTE bReserved[128]; 
-} IDSECTOR, *PIDSECTOR; 
-
-#define DFP_GET_VERSION			0x00074080 
-#define DFP_SEND_DRIVE_COMMAND	0x0007c084 
-#define DFP_RECEIVE_DRIVE_DATA	0x0007c088 
-
- 
-#include "pdh.h"
- 
-class CSystemStatus
-{
-public:
-	CSystemStatus();
-	~CSystemStatus();
-public:
-	void		SystemInit(DWORD object = SYSSTATE_CPU_USAGE);							//系统初始化(初始化多个项目时使用或运算连接)
-	void		SystemUnInit();															//释放资源
-	double		GetSystemNetDownloadRate();												//获取网络下载速度
-	double		GetSystemNetUploadRate();												//获取网络上传速度
-	double		GetSystemDiskReadRate();												//获取当前磁盘读速率
-	double		GetSystemDiskWriteRate();												//获取当前磁盘写速率
-	double		GetSystemCpuCurrentUsage();												//系统CPU使用率
-
-	void		GetSystemDiskStatus(std::vector<EACHDISKSTATUS> &vectorDisk);           //获取各个磁盘使用状态
-	void		GetSystemDiskStatus(ULONGLONG& AllDiskTotal, ULONGLONG& AllDiskFree);	//获取系统总得磁盘使用状态
-	void		GetSystemCurrentDiskStatus(ULONGLONG& TatolMB, ULONGLONG& FreeCaller);	//获取当前磁盘使用状态
-	double		GetSystemCurrentDiskUsage();											//获取当前磁盘使用率
-
-	BOOL		GetPhysicalMemoryState(ULONGLONG& totalPhysMem, ULONGLONG& physMemUsed);//获取物理内存状态
-	double		GetTotalPhysicalMemory();												//获取可用内存大小
-	double		GetTotalPhysicalMemoryFree();											//获取空闲内存
-	double		GetTotalPhysicalMemoryUsed();											//获取已使用内存大小
-	double		GetPhysicalMemoryUsage();												//获取内存使用率
-
-	void		GetNetCardInfo(std::vector<NETCARDINFO> &vectorNetCard);				//获取网卡信息
-	void		GetOsInfo(std::string& strOSName, std::string& strOSArch);                                         //获取操作系统信息 
-	void		GetCpuInfo(std::string &CPUinfo);										//获取CPU硬件信息 	
-	void		GetCPUid(std::string &CPUid);											//获取CPUid
-
-	BOOL		GetHDSerial(std::string &HDSerial);										//获取硬盘物理序列号（需要管理员权限）
-private:
-	PDH_HQUERY		m_Query; 
-	PDH_HCOUNTER	m_CpuTotal,m_DiskRead,m_DiskWrite,m_NetDownload,m_NetUpload;
-
-public:
-	/*
-	参数:const char *cmd
-	systeminfo:查看详细的系统信息
-	wmic logicaldisk:查看盘符
-	fsutil volume diskfree + 盘符名称:查看某个盘符的容量大小。
-	wmic path win32_physicalmedia get SerialNumber;查看硬盘系列号
-	wmic diskdrive get serialnumber;查看硬盘系列号(和上面效果一样)
-	wmic cpu:查看CPU运行信息
-	wmic cpu list brief:查看CPU硬件信息
-	wmic memorychip;查看系统内存信息
-	wmic bios:查看系统的bios信息
-	wmic memorychip list brief:查看内存条数
-	wmic memcache list brief:查看缓存内存
-	wmic diskdrive:查看磁盘详细信息
-	wmic diskdrive get Name, Model:查看硬盘名称，型号（使用get）
-	...
-	*/
-	std::string execCmd(const char *cmd)
-	{
-		char buffer[128] = { 0 };
-		std::string result;
-		FILE *pipe = _popen(cmd, "r");
-		if (!pipe) throw std::runtime_error("_popen() failed!");
-		while (!feof(pipe))
-		{
-			if (fgets(buffer, 128, pipe) != NULL)
-				result += buffer;
-		}
-		_pclose(pipe);
-		return result;
-	}
-
-	_inline void ChangeByteOrder(PCHAR szString, USHORT uscStrSize) 
-	{ 
-		USHORT  i	= 0; 
-		CHAR	temp= '\0'; 
-
-		for (i = 0; i < uscStrSize; i+=2) 
-		{ 
-			temp			= szString[i]; 
-			szString[i]		= szString[i+1]; 
-			szString[i+1]	= temp; 
-		} 
-	}
-};
-#endif

Module/mod_CardIssuerStand/CardIssuerStandFSM.cpp

@@ -5,14 +5,10 @@
 #include "EventCode.h"
 #include "RVCEventCode.h"
 #include "RVCComm.h"
-//oilyang@20200522 go on using
-// deprecated!! [4/17/2020 16:15 @Gifur]
-#include "CardIssuerStand_UserErrorCode.h"	//后续替代EventCode.h，暂时混合使用，时间太紧
+#include "CardIssuerStand_UserErrorCode.h"
 #include "CardIssuerStand_msg_g.h"
-#include "ModuleMix.h"
 
 #include "publicFunExport.h"
-#pragma comment(lib, "libpublicFun.lib")
 #include <algorithm>
 #include <map>
 #ifdef RVC_OS_WIN
@@ -25,7 +21,7 @@
 #include "stdafx.h"
 #include <regex>
 
-//oiltest@20200915 temp for GetTickCount
+//TODO: CrossPlaform  [Gifur@2025730]
 #ifdef RVC_OS_WIN
 #define _ATL_NO_AUTOMATIC_NAMESPACE
 #else
@@ -1319,8 +1315,6 @@ ErrorCodeEnum CCardIssuerFSM::OnInit()
 	GetEntityBase()->GetFunction()->GetSystemStaticInfo(sysInfo);
 	m_csMachineType = sysInfo.strMachineType;
 	m_terminalNo = sysInfo.strTerminalID;
-	m_majorVerion = sysInfo.MachineVersion.GetMajor();
-	m_minorVerion = sysInfo.MachineVersion.GetMinor();
 
 	m_devStatus.eMedia = CI_MEDIA_NOTPRESENT;
 	m_bHasHopper[0] = false;
@@ -1475,6 +1469,7 @@ bool CCardIssuerFSM::LoadCMBPrint(CSimpleStringA csBinPath)
 {
 	if (cmdDecodeEx == NULL) {
 		CSimpleStringA csCMBPrint("");
+		//TODO: CrossPlaform  [Gifur@2025730]
 #ifdef RVC_OS_LINUX
 		csCMBPrint = "libCMBPrint.so";
 		csCMBPrint = csBinPath + "/" + csCMBPrint;
@@ -4547,6 +4542,8 @@ bool CCardIssuerFSM::SyncMaterialCount(IHttpFunc* client,SyncMaterialCountInfo s
 	qTempReq.m_url = m_csSyncMaterialUrl.GetData();
 	qTempReq.m_headers.emplace(std::make_pair("Content-Type", "application/json"));
 	SyncMaterialCountReq1& req1 = qTempReq.reqInfo;
+
+	//TODO: CrossPlaform  [Gifur@2025730]
 #ifdef RVC_OS_WIN
 	strncpy_s(req1.TerminalNo, sizeof(req1.TerminalNo), info.strTerminalID, _TRUNCATE);
 	strncpy_s(req1.DeviceNo, sizeof(req1.DeviceNo), syncInfo.strDeviceNo, _TRUNCATE);
@@ -4564,6 +4561,8 @@ bool CCardIssuerFSM::SyncMaterialCount(IHttpFunc* client,SyncMaterialCountInfo s
 		pReq2.bMaintain = syncInfo.arrMaintainFlag[i];
 		if (syncInfo.arrMaintainFlag[i])
 		{
+
+		//TODO: CrossPlaform  [Gifur@2025730]
 #ifdef RVC_OS_WIN		
 			strncpy_s(pReq2.Maintainer, sizeof(pReq2.Maintainer), syncInfo.arrMaintainer[i], _TRUNCATE);
 #else
@@ -4571,6 +4570,8 @@ bool CCardIssuerFSM::SyncMaterialCount(IHttpFunc* client,SyncMaterialCountInfo s
 #endif //RVC_OS_WIN
 			pReq2.MaintainTime = syncInfo.arrMaintainTime[i];
 		}
+
+//TODO: CrossPlaform  [Gifur@2025730]
 #ifdef RVC_OS_WIN
 		strncpy_s(pReq2.CardBoxNo, sizeof(pReq2.CardBoxNo), syncInfo.arrCardBoxNo[i], _TRUNCATE);
 		strncpy_s(pReq2.PsbCode, sizeof(pReq2.PsbCode), syncInfo.arrPsbCode[i], _TRUNCATE);

Module/mod_CardIssuerStand/CardIssuerStandFSM.h

@@ -915,7 +915,6 @@ private:
 	int m_issueStatusFromFile, m_issueStatus/*the status maybe changed by Business call*/;
 	//1:default, 2:SCI, 3:no cfg
 	int m_machineType;
-	WORD m_majorVerion, m_minorVerion;
 	int m_currentHopper,m_devOpenFailedCount;
 	int m_maxSlot,m_findCard,m_cardPos,m_currentFSMState,m_maxRetainCount, m_eacQueryFlag/*accout query*/
 		,m_ICRetryTimes;

Module/mod_CardReadAdapter/CardReadAdapterFSM.cpp

@@ -3,15 +3,14 @@
 #include "SpHelper.h"
 #include "CardReadAdapterFSM.h"
 #include "EventCode.h"
-#include "ModuleMix.h"
 #include <algorithm>
 #include <map>
 using namespace std;
-//CSimpleStringA<T> ambigulous
 #define _ATL_NO_AUTOMATIC_NAMESPACE
-//#include <atltime.h>
 #define ReadCard_TIMEOUT	62000	//web的超时时间是65s
 #define ReadCard_Min_Time	12000	//Read+PreOnline 
+
+//TODO: CrossPlaform  [Gifur@2025730]
 unsigned long long GetTickCountRVC() {
 #ifdef RVC_OS_WIN
 	return GetTickCount64();
@@ -33,17 +32,16 @@ void CCardReadAdapterFSM::s0_on_entry()
 	GetEntityBase()->GetFunction()->GetSystemStaticInfo(sysInfo);
 	m_csMachineType = sysInfo.strMachineType;
 	m_terminalNo = sysInfo.strTerminalID;
-	m_majorVerion = sysInfo.MachineVersion.GetMajor();
-	m_minorVerion = sysInfo.MachineVersion.GetMinor();
-	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("machineType:%s,terminalNo:%s,machineVersion:%d.%d", (const char*)m_csMachineType, (const char*)m_terminalNo
-	, m_majorVerion, m_minorVerion);
+	m_eMachineType = SpStr2MachineType(sysInfo.strMachineType);
+	/** test  [Gifur@202587]*/
+	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("machinType:%d", m_eMachineType);
+	m_csMachineType = "";
+	GetEntityBase()->GetFunction()->GetMachineType(&m_csMachineType);
+	/** test done  [Gifur@202587]*/
 
-	///**TODO(Gifur@8/17/2023): 覆盖其他需要字段 */
-	const auto terminInfo = SP::Module::Comm::GetTerminalMachineInfo(GetEntityBase());
-	m_eMachineType = terminInfo.type;
+	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("machineType:%s,terminalNo:%s", (const char*)m_csMachineType, (const char*)m_terminalNo);
 
 	FSMEvent *pEvt;
-
 	pEvt = new FSMEvent(USER_EVT_INIT);
 	PostEventFIFO(pEvt);
 }
@@ -131,7 +129,7 @@ unsigned int CCardReadAdapterFSM::s2_on_event(FSMEvent* pEvt)
 			CardReadEvent* cre = dynamic_cast<CardReadEvent*>(pEvt);
 			bool bCardIssuer, bContactlessCard;
 			bCardIssuer = bContactlessCard = false;
-			if (m_eMachineType == SP::Module::Comm::RVC_Stand2S || m_eMachineType == SP::Module::Comm::RVC_Stand1SPlus)
+			if (m_eMachineType == RVC_Stand2S || m_eMachineType == RVC_Stand1SPlus)
 			{
 				ContactlessCardReadTask* cTask = new ContactlessCardReadTask(this);
 				cTask->ctx = cre->ctx;
@@ -759,7 +757,7 @@ int CCardReadAdapterFSM::CardIssuerRead(SpReqAnsContext<CardReadAdapterService_R
 						ctx->Ans.ICCardNo = ansR.ICData;
 						ctx->Ans.status = ansR.status;
 						///**TODO(Gifur@8/22/2023):  增加单屏机型判断，需要诗友确认*/
-						if (m_eMachineType == SP::Module::Comm::RVC_Stand2S || m_eMachineType == SP::Module::Comm::RVC_Stand1SPlus)
+						if (m_eMachineType == RVC_Stand2S || m_eMachineType == RVC_Stand1SPlus)
 							ctx->Ans.cardPos = CardPos_CardIssuer_Stand2S;
 						else
 							ctx->Ans.cardPos = CardPos_CardIssuer_Split;
@@ -912,7 +910,7 @@ int CCardReadAdapterFSM::CardIssuerRead(SpReqAnsContext<CardReadAdapterService_R
 						ctx->Ans.ICCardNo = ansR.ICData;
 						ctx->Ans.status = ansR.status;
 						///**TODO(Gifur@8/22/2023):  增加单屏机型判断，需要诗友确认*/
-						if (m_eMachineType == SP::Module::Comm::RVC_Stand2S || m_eMachineType == SP::Module::Comm::RVC_Stand1SPlus)
+						if (m_eMachineType == RVC_Stand2S || m_eMachineType == RVC_Stand1SPlus)
 							ctx->Ans.cardPos = CardPos_CardIssuer_Stand2S;
 						else
 							ctx->Ans.cardPos = CardPos_CardIssuer_Split;
@@ -1719,7 +1717,7 @@ void CCardReadAdapterFSM::CheckAndReconnectSession()
 			}
 		}
 		//ContactlessCard
-		if ((m_eMachineType != SP::Module::Comm::RVC_CardStore && m_eMachineType != SP::Module::Comm::RVC_CardPrinter)
+		if ((m_eMachineType != RVC_CardStore && m_eMachineType != RVC_CardPrinter)
 			&& (m_pContactless == NULL || (m_pContactless != NULL && m_pContactless->QuerySessionClosed())))
 		{
 			if (m_pContactless != NULL)
@@ -1784,10 +1782,10 @@ bool CCardReadAdapterFSM::IsTheEntity(int module,ModuleType eModule)
 		
 		if (eModule == Module_CardIssuer)
 		{
-			if (m_eMachineType == SP::Module::Comm::RVC_Stand2S
-				|| m_eMachineType == SP::Module::Comm::RVC_CardStore
-				|| m_eMachineType == SP::Module::Comm::RVC_CardPrinter
-				|| m_eMachineType == SP::Module::Comm::RVC_Stand1SPlus)
+			if (m_eMachineType == RVC_Stand2S
+				|| m_eMachineType == RVC_CardStore
+				|| m_eMachineType == RVC_CardPrinter
+				|| m_eMachineType == RVC_Stand1SPlus)
 				return true;
 			else
 				return false;

Module/mod_CardReadAdapter/CardReadAdapterFSM.h

@@ -820,7 +820,7 @@ public:
 		event = m_lastS2Event;
 		param1 = m_lastS2EvtParam1;
 	}
-	SP::Module::Comm::What GetMachineType() {return m_eMachineType;}
+	MachineTypeEnum GetMachineType() {return m_eMachineType;}
 	int QueryCIStatus(SpReqAnsContext<CardReadAdapterService_QueryCIStatus_Req, CardReadAdapterService_QueryCIStatus_Ans>::Pointer ctx);
 	void WaitCardActive();
 protected:
@@ -840,8 +840,7 @@ private:
 	//m_lastModule:0~7
 	//0:all; 1:CardIssuerStand or CardIssuerStore; 2:ContactlessCard
 	int m_lastModule,m_lastS2Event, m_lastS2EvtParam1;
-	SP::Module::Comm::What m_eMachineType;
-	WORD m_majorVerion,m_minorVerion;
+	MachineTypeEnum m_eMachineType;
 	///
 	int m_resetTimes;
 	bool m_devInit, m_bCancelAccept, m_bWaitingAccept, m_bWaitAccepteMore
@@ -893,7 +892,7 @@ private:
 	}
 
 	bool IsCardIssuerStore() {
-		if (m_eMachineType == SP::Module::Comm::RVC_CardStore || m_eMachineType == SP::Module::Comm::RVC_CardPrinter) {
+		if (m_eMachineType == RVC_CardStore || m_eMachineType == RVC_CardPrinter) {
 			return true;
 		}
 		else {

Module/mod_ContactlessCard/ContactlessFSM.cpp

@@ -2,7 +2,6 @@
 #include "ContactlessFSM.h"
 #include "EventCode.h"
 #include "ContactlessCard_msg_g.h"
-#include "ModuleMix.h"
 #include "ContactlessCard_UserErrorCode.h"
 #include "CommDevEntityErrorCode.h"
 #include <map>
@@ -653,12 +652,6 @@ ErrorCodeEnum CContactlessCardFSM::OnInit()
 		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode("RTA2J19")("create card process failed.");
 		return Error_Resource;
 	}
-
-	CSystemStaticInfo sysInfo;
-	m_csMachineType = "";
-	GetEntityBase()->GetFunction()->GetSystemStaticInfo(sysInfo);
-	m_csMachineType = sysInfo.strMachineType;
-
 	m_bOpening = true;
 	ErrorCodeEnum errCode = Load();
 	
@@ -786,8 +779,6 @@ ErrorCodeEnum CContactlessCardFSM::Load()
 	}
 	else
 	{
-		m_devInit = true;
-		//LogWarn(Severity_Low, Error_Unexpect, ContactlessCard_UserErrorCode_DevOpen_Success, "非接读卡器打开成功");
 		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("非接读卡器打开成功");
 		return Error_Succeed;
 	}
@@ -1249,6 +1240,7 @@ int CContactlessCardFSM::PreOnline(SpReqAnsContext<ContactlessCardService_PreOnl
 
 	char arqcLen[8];
 	ZeroMemory(arqcLen,sizeof(arqcLen));
+	//TODO: CrossPlaform  [Gifur@2025729]
 #ifdef RVC_OS_WIN
     itoa(lenRet, arqcLen, 10);
 #else
@@ -1510,6 +1502,8 @@ bool CContactlessCardFSM::LoadCMBPrint(CSimpleStringA csBinPath)
 {
 	if (cmdDecodeEx == NULL) {
 		CSimpleStringA csCMBPrint("");
+
+		//TODO: CrossPlaform  [Gifur@2025730]
 #ifdef RVC_OS_WIN
 		csCMBPrint = "CMBPrint.dll";
 		csCMBPrint = csBinPath + SPLIT_SLASH_STR + csCMBPrint;
@@ -1960,6 +1954,7 @@ int CContactlessCardFSM::PreOnlineJS(SpReqAnsContext<ContactlessCardService_Read
 	}
 	char arqcLen[8];
 	ZeroMemory(arqcLen, sizeof(arqcLen));
+	//TODO: CrossPlaform  [Gifur@2025729]
 #ifdef RVC_OS_WIN
 	itoa(lenRet, arqcLen, 10);
 #else

Module/mod_ContactlessCard/ContactlessFSM.h

@@ -49,13 +49,8 @@ enum EvtType
 };
 
 using namespace ContactlessCard;
-#ifdef RVC_OS_WIN
-typedef int(*lpCMBdecodeMag2)(char* Mag2Data, char * data);
-typedef int(*lpCMBdecodeEx)( char* MagData, char * type, char * data);
-#else
 using lpCMBdecodeMag2 = int(*)(char* mag2Data, char* data);
 using lpCMBdecodeEx = int(*)(char* magData, char* type, char* data);
-#endif
 
 class CContactlessCardEntity;
 class CContactlessCardFSM;
@@ -284,7 +279,7 @@ public:
 
 		CContactlessCardFSM() : m_bCancelAccept(false), m_bWaitingAccept(false),
 		m_bWaitAccepteMore(false), m_bExit(false), m_resetTimes(0), m_testResult(Error_Succeed)
-		, m_bCDA(false), m_pDataToARQC(NULL), m_csMachineType(true), m_csDevNo(""), m_devInit(false), m_repeatErrTimes(0),
+		, m_bCDA(false), m_pDataToARQC(NULL), m_repeatErrTimes(0),
 		m_bCancelRead(false),m_bPageExit(false), m_bNeedReset(true)
 		{
 			HARDWARE_ENTITY_RESET_ENTITYID(m_entCode, 0x213); 
@@ -394,9 +389,8 @@ private:
 	int m_resetTimes;
 	lpCMBdecodeMag2 cmdDecodeMag2;
 	lpCMBdecodeEx cmdDecodeEx;	
-	bool m_devInit, m_bCancelAccept, m_bWaitingAccept, m_bWaitAccepteMore, m_bExit;
+	bool m_bCancelAccept, m_bWaitingAccept, m_bWaitAccepteMore, m_bExit;
 	ErrorCodeEnum m_testResult;
-	CSimpleStringA m_csMachineType;
 	DevCategoryInfo m_devCatInfo;
 
 	
@@ -408,8 +402,6 @@ private:
 
 	char m_AuthCode[2];
 	bool m_bCDA;
-	CSimpleStringA m_csDevNo;
-
 	int SplitTrack2(CSimpleStringA pTrack2,Track2Data &decodeData);
 
 	int m_repeatErrTimes;

Module/mod_CustMngrAuth/CustMngrAuthFSM.cpp

@@ -18,7 +18,6 @@
 
 using namespace std;
 #else
-#include "fileutil.h"
 #include <memory>
 #include <thread>
 #include <chrono>
@@ -435,16 +434,6 @@ ErrorCodeEnum CCustMngrAuthFSM::OnInit()
 {
 	LOG_FUNCTION();
 	m_authCtx.eAuthByWhich = AuthByNone;
-
-	CSystemStaticInfo staticInfo;
-	m_pEntity->GetFunction()->GetSystemStaticInfo(staticInfo);
-	m_TerminalID = staticInfo.strTerminalID;
-	m_csMachineType = staticInfo.strMachineType;
-	m_FingerSection = "FingerInfo";
-	CSimpleStringA machineVersion = CSimpleStringA::Format("%d.%d", staticInfo.MachineVersion.GetMajor(), staticInfo.MachineVersion.GetMinor());
-	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("CustMngrAuth m_csMachineType:%s, machineVersion:%s, TerminalNo:%s",
-			m_csMachineType.GetData(), machineVersion.GetData(), m_TerminalID.GetData());
-
 	return Error_Succeed;
 }
 
@@ -457,25 +446,9 @@ ErrorCodeEnum CCustMngrAuthFSM::OnExit()
 
 int CCustMngrAuthFSM::Initial()
 {
-	ErrorCodeEnum errCode = OpenRunInfoFile();
-	if (errCode != Error_Succeed) {
-		return 1;
-	}
 	return 0;
 }
 
-ErrorCodeEnum CCustMngrAuthFSM::OpenRunInfoFile()
-{
-	ErrorCodeEnum errCode;
-	errCode = GetEntityBase()->GetFunction()->GetPath("RunInfo", m_RunInfoPath);
-	if (errCode != Error_Succeed)
-	{
-		LogWarn(Severity_High, Error_DevLoadFileFailed, LOG_ERR_CUSTMNGRAUTH_GET_RUNINFO_PATH_FAILED_Init, "get runinfo path failed while init");
-		errCode =  Error_Unexpect;
-	}	
-	return errCode;
-}
-
 #pragma endregion
 
 #pragma region Registe process
@@ -819,6 +792,7 @@ void CCustMngrAuthFSM::DeleteBmp(int type)
 	}
 }
 
+//TODO: CrossPlaform  [Gifur@2025728]
 ErrorCodeEnum CCustMngrAuthFSM::DeleteFileIfExisted(const char* fileName)
 {
 #ifdef RVC_OS_WIN
@@ -832,7 +806,7 @@ ErrorCodeEnum CCustMngrAuthFSM::DeleteFileIfExisted(const char* fileName)
 	strObjPath = strPath + "\\" + fileName;
 
 	UpdateAndWarnFileFindInDepBak(strObjPath, fileName, LOG_ERR_CUSTMNGRAUTH_FindFile_in_DepBak);
-
+	//TODO: CrossPlaform  [Gifur@2025728]
 	WIN32_FIND_DATA findData;
 	if (FindFirstFileA((LPCTSTR)strObjPath, &findData) != INVALID_HANDLE_VALUE)
 	{
@@ -920,32 +894,6 @@ void CCustMngrAuthFSM::BroadcastGetFinger(int status)
 
 #pragma region invoked function
 
-//ErrorCodeEnum CCustMngrAuthFSM::WaitForUkey(ErrorCodeEnum eErr)
-//{
-//	//与朱毅约定，4表示本地无指纹数据，3表示指纹仪实体异常(包括旧接口的其他错误码和新接口的Error_HardWare)
-//	//4: no data in local, 3:enitty exception
-////	DbgInfo(CSimpleStringA::Format("WaitForUkey, eErr:%d(0x%x)", eErr, eErr));
-//	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("WaitForUkey, eErr:%d(0x%x)", eErr, eErr);
-//	int status = (eErr == Error_NoTarget) ? 4 : 3;
-//	BroadcastGetFinger(status);
-//	while (1) {
-//#ifdef RVC_OS_WIN
-//		Sleep(300);
-//#else
-//		SLEEP(300);
-//#endif
-//		if (m_bCancelAuthorize) {
-//			m_bCancelAuthorize = false;
-//			if (m_bAuthorizeTimeout){
-//				m_bAuthorizeTimeout = false;
-//				return Error_TimeOut;
-//			}
-//			else
-//				return Error_Cancel;
-//		}
-//	}
-//}
-
 void CCustMngrAuthFSM::CancelAuthorize()
 {
 	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Invoke m_pFingerPrint->CancelMatch()");

Module/mod_CustMngrAuth/CustMngrAuthFSM.h

@@ -495,9 +495,6 @@ public:
 	SpReqAnsContext<CustMngrAuthService_StartAuthorize_Req, CustMngrAuthService_StartAuthorize_Ans>::Pointer m_ctx;
 	SpReqAnsContext<CustMngrAuthService_QueryAuthorInfo_Req, CustMngrAuthService_QueryAuthorInfo_Ans>::Pointer qaInfoCtx;
 	AuthContext m_authCtx;
-	CSimpleStringA m_TerminalID;
-	CSimpleStringA m_csMachineType;
-
 	
 	ErrorCodeEnum MatchFingerPrintEx(SpReqAnsContext<CustMngrAuthService_QueryAuthorInfo_Req, CustMngrAuthService_QueryAuthorInfo_Ans>::Pointer ctx, bool& bStopAuthorize, DWORD& dwUserErrCode);
 	
@@ -515,14 +512,10 @@ public:
 	void DeleteBmp(int type);
 	ErrorCodeEnum DeleteFileIfExisted(const char* fileName);
 
-	ErrorCodeEnum OpenRunInfoFile();//Initial使用
-	
 	//在旧dep路径下找到文件时告警，未继承CCommDevFSM,单独实现
 	void UpdateAndWarnFileFindInDepBak(CSimpleStringA& newDepPath, const char* filename, DWORD userCode);
 
 #pragma region 废弃的方法
-
-
 	ErrorCodeEnum MatchFingerPrint(SpReqAnsContext<CustMngrAuthService_StartAuthorize_Req, CustMngrAuthService_StartAuthorize_Ans>::Pointer ctx, bool& bStopAuthorize);//废弃的方法
 	ErrorCodeEnum CollectFingerPrint(SpReqAnsContext<CustMngrAuthService_CollectFingerPrint_Req, CustMngrAuthService_CollectFingerPrint_Ans>::Pointer ctx, DWORD& dwUserErrCode);//废弃的方法
 	ErrorCodeEnum CollectFingerPrintEx(SpReqAnsContext<CustMngrAuthService_CollectFingerPrintEx_Req, CustMngrAuthService_CollectFingerPrintEx_Ans>::Pointer ctx, DWORD& dwUserErrCode);//废弃的方法
@@ -533,12 +526,6 @@ public:
 private:
 	
 	FingerPrintService_ClientBase *m_pFingerPrint;
-
-
-	CSimpleStringA m_FingerSection;//人脸特征路径
-	CSimpleStringA m_RunInfoPath;
-
-
 	bool m_bCancelCollectFP, m_bCancelAuthorize, m_bAuthorizeTimeout;
 	int m_TimeLimit;
 

Module/mod_CustMngrAuth/CustMngrAuth_UserErrorCode.h

@@ -8,7 +8,6 @@
 #define LOG_ERR_CUSTMNGRAUTH_FEATUPDATE_CONNECT_FAILED				0x10200204	//连接分行服务失败（连续60次连接不上（30min），报错一次） - LogWarn
 #define LOG_ERR_CUSTMNGRAUTH_AUTHORIZATION_READFEAT_FAILED			0x10200205	//读文件数据到内存失败 - LogWarn
 #define LOG_ERR_CUSTMNGRAUTH_READ_INTO_MEMORY_TIME					0x10200206	//读文件到内存耗时 - LogWarn
-#define LOG_ERR_CUSTMNGRAUTH_GET_RUNINFO_PATH_FAILED_Init			0x10200207	//初始化时获取运行时路径失败 - LogWarn
 
 #define LOG_ERR_CUSTMNGRAUTH_INVOKE_MATCH							0x10200208	//web调用旧的比对接口 - LogWarn
 #define LOG_ERR_CUSTMNGRAUTH_INVOKE_MATCHEx							0x10200209	//web调用后端比对接口 - LogWarn

Module/mod_FingerPrint/FingerPrintFSM.cpp

@@ -15,6 +15,7 @@
 #include <sys/stat.h>
 #include <unistd.h>
 #endif
+#include <winpr/synch.h>
 
 #define FINGERPRINT_SCAN_TIMEOUT 15000
 #define FINGERPRINT_GETFINGER_TIMEOUT 25000
@@ -23,9 +24,6 @@
 #define MAX_FEATURE_LEN 1024
 #define STANDARD_FEATURE_LEN 684
 
-
-
-
 void CFingerPrintFSM::s0_on_entry()
 {
 	LOG_FUNCTION();
@@ -352,16 +350,6 @@ unsigned CFingerPrintFSM::s3_on_event(FSMEvent* e)
 
 ErrorCodeEnum CFingerPrintFSM::OnInit()
 {
-	CSystemStaticInfo sysInfo;
-	GetEntityBase()->GetFunction()->GetSystemStaticInfo(sysInfo);
-	m_csMachineType = sysInfo.strMachineType;
-	WORD majorVersion = sysInfo.MachineVersion.GetMajor();
-	WORD minorVersion = sysInfo.MachineVersion.GetMinor();
-	m_machineVersion = CSimpleStringA::Format("%d.%d", majorVersion, minorVersion);
-	m_terminalNo = sysInfo.strTerminalID;
-	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)(CSimpleStringA::Format("MachineType:%s, machineVersion:%s, terminalNo: %s",
-		m_csMachineType.GetData(), m_machineVersion.GetData(), m_terminalNo.GetData()));
-
 	auto pEntity = GET_DEV_ENTITY_BASE_POINTER();
 	pEntity->LoadVendorLibName();
 	return Error_Succeed;
@@ -855,11 +843,7 @@ int CFingerPrintFSM::GetFingerPrint(SpReqAnsContext<FingerPrintService_GetFinger
 			bExit = true;
 			break;
 		}
-#ifdef RVC_OS_WIN
 		Sleep(FINGERPRINT_SCAN_INTERNAL);
-#else
-		SLEEP(FINGERPRINT_SCAN_INTERNAL);
-#endif
 		lpbLength = MAX_FEATURE_LEN;
 		l_beginTime = SP::Module::Comm::RVCGetTickCount();
 		eErr = m_hDevHelper->Image2Feature(fileName, lpbFeature, lpbLength);
@@ -871,8 +855,11 @@ int CFingerPrintFSM::GetFingerPrint(SpReqAnsContext<FingerPrintService_GetFinger
 			UpdateAndWarnFileFindInDepBak(strPath, fileName, FingerPrint_UserErrorCode_FindFile_in_DepBak);
 
 			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::Image2Feature").setCostTime(l_endTime - l_beginTime)("GetFingerPrint::Image2Feature succ ,fileName:%s, lpbLength:%d", fileName.GetData(), lpbLength);
-#ifdef RVC_OS_WIN
 			Sleep(200);//save image may be delayed some time, not must happen
+			//TODO: CrossPlaform  [Gifur@2025730]
+#ifdef RVC_OS_WIN
+
+			//TODO: CrossPlaform  [Gifur@2025728]
 			WIN32_FIND_DATA findData;
 			if (FindFirstFileA((LPCTSTR)strPath, &findData) != INVALID_HANDLE_VALUE 
 				&& lpbFeature != NULL && lpbLength == STANDARD_FEATURE_LEN)
@@ -899,7 +886,6 @@ int CFingerPrintFSM::GetFingerPrint(SpReqAnsContext<FingerPrintService_GetFinger
 				break;
 			}
 #else
-			SLEEP(200);
 			if (ExistsFile(strPath)
 				&& lpbFeature != NULL && lpbLength == STANDARD_FEATURE_LEN)
 			{
@@ -1026,6 +1012,8 @@ int CFingerPrintFSM::GenerateTemplate(SpReqAnsContext<FingerPrintService_Generat
 
 		imagePaths.push_back(tempStr);
 		//DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("imageName:%s", imagePaths[i].GetData());
+
+		//TODO: CrossPlaform  [Gifur@2025728]
 #ifdef RVC_OS_WIN		
 		WIN32_FIND_DATA findData;
 		if (FindFirstFileA((LPCTSTR)imagePaths[i], &findData) == INVALID_HANDLE_VALUE)
@@ -1096,6 +1084,7 @@ int CFingerPrintFSM::GenerateTemplate(SpReqAnsContext<FingerPrintService_Generat
 
 ErrorCodeEnum CFingerPrintFSM::GetDevCatInfo(DevCategoryInfo& devInfo)
 {
+	//TODO: CrossPlaform  [Gifur@2025730]
 	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER)("DevCatgoryInfo len:%d, %d, %d", strlen(m_devCatInfo.szModel), strlen(m_devCatInfo.szType), strlen(m_devCatInfo.szVendor));
 #ifdef RVC_OS_WIN
 	strncpy_s(devInfo.szModel, m_devCatInfo.szModel, (MAX_DEV_MODEL_LEN > strlen(m_devCatInfo.szModel)) ? strlen(m_devCatInfo.szModel) : MAX_DEV_MODEL_LEN-1);
@@ -1245,6 +1234,8 @@ ErrorCodeEnum CFingerPrintFSM::DeleteFileIfExisted(const char* fileName)
 	strObjPath = CSimpleStringA::Format("%s" SPLIT_SLASH_STR "%s", strPath.GetData(), fileName);
 
 	UpdateAndWarnFileFindInDepBak(strObjPath, fileName, FingerPrint_UserErrorCode_FindFile_in_DepBak);
+
+	//TODO: CrossPlaform  [Gifur@2025728]
 #ifdef RVC_OS_WIN
 	WIN32_FIND_DATA findData;
 	if (FindFirstFileA((LPCTSTR)strObjPath, &findData) != INVALID_HANDLE_VALUE)

Module/mod_FingerPrint/FingerPrintFSM.h

@@ -293,7 +293,7 @@ public:
 	END_FSM_RULE()
 
 	CFingerPrintFSM():m_bCancelRegister(false), m_bCancelMatch(false), m_bExit(false),
-					  m_testResult(Error_Succeed),m_csMachineType(""), m_terminalNo(""), m_machineVersion(""),
+					  m_testResult(Error_Succeed),
 					  m_bCancelScan(false), m_bExitMainPage(false)
 					{	
 						HARDWARE_ENTITY_RESET_ENTITYID(m_entCode, 0x204); 
@@ -346,7 +346,6 @@ private:
 	bool m_bCancelRegister;
 	bool m_bCancelMatch;
 	bool m_bExit;
-	CSimpleStringA m_csMachineType, m_terminalNo, m_machineVersion;
 	
 public:
 	int GetFingerPrintJS(SpReqAnsContext<FingerPrintService_GetFingerPrintJS_Req, FingerPrintService_GetFingerPrintJS_Ans>::Pointer ctx);

Module/mod_FingerPrint/test/testFingerPrintEntity.cpp

@@ -73,7 +73,6 @@ TEST_CASE_FSM_CLASS(CFingerPrintFSM, "GetDevCatInfo")
 TEST_CASE_METHOD("TestForRVCGetTickCount")
 {
 	ULLINT startTag = RVCGetTickCount();
-	SLEEP(100);
 	long long endTag = RVCGetTickCount();
 
 	Dbg("time internal = %dms", endTag - startTag);

Module/mod_IDCertificate/IDCertFSM.cpp

@@ -1,7 +1,6 @@
 #include "stdafx.h"
 #include "IDCertFSM.h"
 #include "EventCode.h"
-#include "ModuleMix.h"
 #include "IDCertificate_UserErrorCode.h"
 #include <highgui.h>
 #include <cv.h>  
@@ -22,7 +21,6 @@ using namespace SP::Module::Comm;
 #include "json/json.h" 
 #include <Windows.h>
 #include <unordered_map>
-#pragma comment(lib,"user32.lib")
 #endif // RVC_OS_LINUX
 
 #define IDCER_INIT_COUNT 3
@@ -1130,11 +1128,6 @@ void CIDCertFSM::DeleteZP(int type, int deleteTiming)
 int CIDCertFSM::Initial()
 {
 	LOG_FUNCTION();
-	CSystemStaticInfo sysInfo;
-	GetEntityBase()->GetFunction()->GetSystemStaticInfo(sysInfo);
-	m_csMachineType = sysInfo.strMachineType;
-	m_terminalNo = sysInfo.strTerminalID;
-	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("machineType:%s,terminalNo:%s", (const char*)m_csMachineType, (const char*)m_terminalNo);
 	SetDevState(DEVICE_STATUS_NOT_READY);
 	auto pEntity = GET_DEV_ENTITY_BASE_POINTER();
 

Module/mod_IDCertificate/IDCertFSM.h

@@ -229,7 +229,7 @@ public:
 	END_FSM_RULE()
 
 		CIDCertFSM() :m_bCancelRead(false), m_bReading(false),
-		m_bExit(false), m_testResult(Error_Succeed), m_getDevCategory(Error_Unexpect), m_csMachineType(""), m_terminalNo(""), transImgMsg("")
+		m_bExit(false), m_testResult(Error_Succeed), m_getDevCategory(Error_Unexpect),transImgMsg("")
 	{
 		ZeroMemory(&m_adapterInfo, sizeof(m_adapterInfo));
 		HARDWARE_ENTITY_RESET_ENTITYID(m_entCode, 0x201);
@@ -309,7 +309,6 @@ private:
 	ErrorCodeEnum m_testResult;
 	ErrorCodeEnum m_getDevCategory;
 	DevCategoryInfo m_devCatInfo;
-	CSimpleStringA m_csMachineType, m_terminalNo;
 	CSimpleStringA transImgMsg;
 #ifdef RVC_OS_WIN
 	unordered_map<int, wstring> nationalCode; 

Module/mod_ResourceWatcher/CMakeLists.txt

@@ -4,7 +4,6 @@ if(MSVC)
 
 set(${MODULE_PREFIX}_SRCS 
     FileInfo.h
-    FileSimpleComp.h
     mod_ResourceWatcher.h
     ResourceWatcherFSM.h
     ResourceWatcher_def_g.h
@@ -25,7 +24,6 @@ else()
 
 set(${MODULE_PREFIX}_SRCS 
     FileInfo.h
-    FileSimpleComp.h
     mod_ResourceWatcher.h
     ResourceWatcherFSM.h
     ResourceWatcher_def_g.h
@@ -46,7 +44,7 @@ add_module_libraries(${MODULE_PREFIX} ${MODULE_NAME} ${MOD_VERSION_STRING})
 
 if(MSVC)
     set(${MODULE_PREFIX}_LIBS RestfulFunc)
-    set(${MODULE_PREFIX}_LIBS ${${MODULE_PREFIX}_LIBS} ws2_32 mbnapi_uuid pdh winmm shell32 Wintrust crypt32 wlanapi mbnapi_uuid Gdi32 User32)
+    set(${MODULE_PREFIX}_LIBS ${${MODULE_PREFIX}_LIBS} ws2_32 mbnapi_uuid pdh winmm shell32 Wintrust crypt32 wlanapi mbnapi_uuid Gdi32 User32 WtsApi32)
 else()
     target_link_directories(${MODULE_NAME} PRIVATE ${CONAN_LIB_DIRS_SOGOULIB})
     set(${MODULE_PREFIX}_LIBS ${MODULE_BASE_LIBS} libpublicFun RestfulFunc ${CONAN_LIBS_SOGOULIB})