diff --git a/include/appspawn_server.h b/include/appspawn_server.h
index b210bc599d5ca5a107ca13118702e7ce7c996e7b..c73cf79fa9fa00cf026a1a9e3f403ae67b695ce2 100644
--- a/include/appspawn_server.h
+++ b/include/appspawn_server.h
@@ -143,13 +143,6 @@ private:
      */
     bool CheckAppProperty(const ClientSocket::AppProperty *appProperty);
 
-#ifdef ACEABILITY_LIBRARY_LOADER
-    /**
-     * Load libace.z.so library when boot the devices
-     */
-    void LoadAceLib();
-#endif
-
 private:
     const std::string deviceNull_ = "/dev/null";
     std::string socketName_ {};
diff --git a/include/appspawn_socket.h b/include/appspawn_socket.h
index f4436cdabf87a80bb91fabc92d08b41c9994046a..6edf8b7280850698d2e187ab2d8fee549b70e15a 100644
--- a/include/appspawn_socket.h
+++ b/include/appspawn_socket.h
@@ -99,7 +99,7 @@ protected:
 
 protected:
     int socketFd_ = -1;
-    std::string socketName_{};
+    std::string socketName_ {};
     struct sockaddr_un socketAddr_ {};
     socklen_t socketAddrLen_ = 0;
 #ifdef __MUSL__
diff --git a/src/appspawn_server.cpp b/src/appspawn_server.cpp
index e5d0ee5e7486e864a53e56a861ee5853539197bf..12b901a2930b58b068eb5fc886498729710a99d9 100644
--- a/src/appspawn_server.cpp
+++ b/src/appspawn_server.cpp
@@ -17,7 +17,7 @@
 
 #include <fcntl.h>
 #include <memory>
-#include <signal.h>
+#include <csignal>
 #include <sys/wait.h>
 #include <sys/prctl.h>
 #include <sys/capability.h>
@@ -28,12 +28,14 @@
 #include "main_thread.h"
 #include "securec.h"
 
+#define ACEABILITY_LIBRARY_LOADER
 #if defined(ABILITY_LIBRARY_LOADER) || defined(APPLICATION_LIBRARY_LOADER)
 #include <dirent.h>
 #include <dlfcn.h>
 #endif
 
 #define GRAPHIC_PERMISSION_CHECK
+constexpr static size_t ERR_STRING_SZ = 64;
 
 namespace OHOS {
 namespace AppSpawn {
@@ -76,11 +78,13 @@ static void SignalHandler([[maybe_unused]] int sig)
 
 static void InstallSigHandler()
 {
+    char err_string[ERR_STRING_SZ];
     struct sigaction sa = {};
     sa.sa_handler = SignalHandler;
     int err = sigaction(SIGCHLD, &sa, nullptr);
     if (err < 0) {
-        HiLog::Error(LABEL, "Error installing SIGCHLD handler: %{public}s", strerror(errno));
+        HiLog::Error(LABEL, "Error installing SIGCHLD handler: %{public}d",
+            strerror_r(errno, err_string, ERR_STRING_SZ));
         return;
     }
 
@@ -88,24 +92,26 @@ static void InstallSigHandler()
     sah.sa_handler = SIG_IGN;
     err = sigaction(SIGHUP, &sah, nullptr);
     if (err < 0) {
-        HiLog::Error(LABEL, "Error installing SIGHUP handler: %{public}s", strerror(errno));
+        HiLog::Error(LABEL, "Error installing SIGHUP handler: %{public}d",
+            strerror_r(errno, err_string, ERR_STRING_SZ));
     }
 }
 
 static void UninstallSigHandler()
 {
+    char err_string[ERR_STRING_SZ];
     struct sigaction sa = {};
     sa.sa_handler = SIG_DFL;
     int err = sigaction(SIGCHLD, &sa, nullptr);
     if (err < 0) {
-        HiLog::Error(LABEL, "Error uninstalling SIGCHLD handler: %s", strerror(errno));
+        HiLog::Error(LABEL, "Error uninstalling SIGCHLD handler: %d", strerror_r(errno, err_string, ERR_STRING_SZ));
     }
 
     struct sigaction sah = {};
     sah.sa_handler = SIG_DFL;
     err = sigaction(SIGHUP, &sah, nullptr);
     if (err < 0) {
-        HiLog::Error(LABEL, "Error uninstalling SIGHUP handler: %s", strerror(errno));
+        HiLog::Error(LABEL, "Error uninstalling SIGHUP handler: %d", strerror_r(errno, err_string, ERR_STRING_SZ));
     }
 }
 #ifdef __cplusplus
@@ -121,9 +127,11 @@ AppSpawnServer::AppSpawnServer(const std::string &socketName)
 
 void AppSpawnServer::MsgPeer(int connectFd)
 {
+    char err_string[ERR_STRING_SZ];
     std::unique_ptr<AppSpawnMsgPeer> msgPeer = std::make_unique<AppSpawnMsgPeer>(socket_, connectFd);
     if (msgPeer == nullptr || msgPeer->MsgPeer() != 0) {
-        HiLog::Error(LABEL, "Failed to listen connection %d, %s", connectFd, strerror(errno));
+        HiLog::Error(LABEL, "Failed to listen connection %d, %d",
+            connectFd, strerror_r(errno, err_string, ERR_STRING_SZ));
         return;
     }
 
@@ -152,9 +160,15 @@ void AppSpawnServer::ConnectionPeer()
     }
 }
 
-#ifdef ACEABILITY_LIBRARY_LOADER
-void AppSpawnServer::LoadAceLib()
+bool AppSpawnServer::ServerMain(char *longProcName, int64_t longProcNameLen)
 {
+    if (socket_->RegisterServerSocket() != 0) {
+        HiLog::Error(LABEL, "AppSpawnServer::Failed to register server socket");
+        return false;
+    }
+    std::thread(&AppSpawnServer::ConnectionPeer, this).detach();
+
+    #ifdef ACEABILITY_LIBRARY_LOADER
     std::string acelibdir("/system/lib/libace.z.so");
     void *AceAbilityLib = nullptr;
     HiLog::Info(LABEL, "MainThread::LoadAbilityLibrary. Start calling dlopen acelibdir.");
@@ -165,19 +179,8 @@ void AppSpawnServer::LoadAceLib()
         HiLog::Info(LABEL, "Success to dlopen %{public}s", acelibdir.c_str());
     }
     HiLog::Info(LABEL, "MainThread::LoadAbilityLibrary. End calling dlopen.");
-}
-#endif
+    #endif
 
-bool AppSpawnServer::ServerMain(char *longProcName, int64_t longProcNameLen)
-{
-    if (socket_->RegisterServerSocket() != 0) {
-        HiLog::Error(LABEL, "AppSpawnServer::Failed to register server socket");
-        return false;
-    }
-    std::thread(&AppSpawnServer::ConnectionPeer, this).detach();
-#ifdef ACEABILITY_LIBRARY_LOADER
-    LoadAceLib();
-#endif
     while (isRunning_) {
         std::unique_lock<std::mutex> lock(mut_);
         dataCond_.wait(lock, [this] { return !this->appQueue_.empty(); });
@@ -226,6 +229,7 @@ bool AppSpawnServer::ServerMain(char *longProcName, int64_t longProcNameLen)
 int32_t AppSpawnServer::SetProcessName(
     char *longProcName, int64_t longProcNameLen, const char *processName, int32_t len)
 {
+    char err_string[ERR_STRING_SZ];
     if (longProcName == nullptr || processName == nullptr || len <= 0) {
         HiLog::Error(LABEL, "process name is nullptr or length error");
         return -EINVAL;
@@ -240,31 +244,31 @@ int32_t AppSpawnServer::SetProcessName(
     // process short name max length 16 bytes.
     if (len > MAX_LEN_SHORT_NAME) {
         if (strncpy_s(shortName, MAX_LEN_SHORT_NAME, processName, MAX_LEN_SHORT_NAME - 1) != EOK) {
-            HiLog::Error(LABEL, "strncpy_s short name error: %{public}s", strerror(errno));
+            HiLog::Error(LABEL, "strncpy_s short name error: %{public}d", strerror_r(errno, err_string, ERR_STRING_SZ));
             return -EINVAL;
         }
     } else {
         if (strncpy_s(shortName, MAX_LEN_SHORT_NAME, processName, len) != EOK) {
-            HiLog::Error(LABEL, "strncpy_s short name error: %{public}s", strerror(errno));
+            HiLog::Error(LABEL, "strncpy_s short name error: %{public}d", strerror_r(errno, err_string, ERR_STRING_SZ));
             return -EINVAL;
         }
     }
 
     // set short name
     if (prctl(PR_SET_NAME, shortName) == -1) {
-        HiLog::Error(LABEL, "prctl(PR_SET_NAME) error: %{public}s", strerror(errno));
+        HiLog::Error(LABEL, "prctl(PR_SET_NAME) error: %{public}d", strerror_r(errno, err_string, ERR_STRING_SZ));
         return (-errno);
     }
 
     // reset longProcName
-    if (memset_s(longProcName, longProcNameLen, 0, longProcNameLen) != EOK) {
+    if (memset_s(longProcName, static_cast<size_t>(longProcNameLen), 0, static_cast<size_t>(longProcNameLen)) != EOK) {
         HiLog::Error(LABEL, "Failed to memset long process name");
         return -EINVAL;
     }
 
     // set long process name
     if (strncpy_s(longProcName, len, processName, len) != EOK) {
-        HiLog::Error(LABEL, "strncpy_s long name error: %{public}s", strerror(errno));
+        HiLog::Error(LABEL, "strncpy_s long name error: %{public}d", strerror_r(errno, err_string, ERR_STRING_SZ));
         return -EINVAL;
     }
 
@@ -274,21 +278,27 @@ int32_t AppSpawnServer::SetProcessName(
 int32_t AppSpawnServer::SetUidGid(
     const uint32_t uid, const uint32_t gid, const uint32_t *gitTable, const uint32_t gidCount)
 {
+    char err_string[ERR_STRING_SZ];
+    if (gitTable == nullptr) {
+        HiLog::Error(LABEL, "gitTable is nullptr");
+        return (-errno);
+    }
     // set gids
     if (setgroups(gidCount, reinterpret_cast<const gid_t *>(&gitTable[0])) == -1) {
-        HiLog::Error(LABEL, "setgroups failed: %{public}s, gids.size=%{public}u", strerror(errno), gidCount);
+        HiLog::Error(LABEL, "setgroups failed: %{public}d, gids.size=%{public}u",
+            strerror_r(errno, err_string, ERR_STRING_SZ), gidCount);
         return (-errno);
     }
 
     // set gid
     if (setresgid(gid, gid, gid) == -1) {
-        HiLog::Error(LABEL, "setgid(%{public}u) failed: %{public}s", gid, strerror(errno));
+        HiLog::Error(LABEL, "setgid(%{public}u) failed: %{public}d", gid, strerror_r(errno, err_string, ERR_STRING_SZ));
         return (-errno);
     }
 
     // If the effective user ID is changed from 0 to nonzero, then all capabilities are cleared from the effective set
     if (setresuid(uid, uid, uid) == -1) {
-        HiLog::Error(LABEL, "setuid(%{public}u) failed: %{public}s", uid, strerror(errno));
+        HiLog::Error(LABEL, "setuid(%{public}u) failed: %{public}d", uid, strerror_r(errno, err_string, ERR_STRING_SZ));
         return (-errno);
     }
     return ERR_OK;
@@ -296,6 +306,7 @@ int32_t AppSpawnServer::SetUidGid(
 
 int32_t AppSpawnServer::SetFileDescriptors()
 {
+    char err_string[ERR_STRING_SZ];
     // close stdin stdout stderr
     close(STDIN_FILENO);
     close(STDOUT_FILENO);
@@ -304,25 +315,25 @@ int32_t AppSpawnServer::SetFileDescriptors()
     // redirect to /dev/null
     int dev_null_fd = open(deviceNull_.c_str(), O_RDWR);
     if (dev_null_fd == -1) {
-        HiLog::Error(LABEL, "open dev_null error: %{public}s", strerror(errno));
+        HiLog::Error(LABEL, "open dev_null error: %{public}d", strerror_r(errno, err_string, ERR_STRING_SZ));
         return (-errno);
     }
 
     // stdin
     if (dup2(dev_null_fd, STDIN_FILENO) == -1) {
-        HiLog::Error(LABEL, "dup2 STDIN error: %{public}s", strerror(errno));
+        HiLog::Error(LABEL, "dup2 STDIN error: %{public}d", strerror_r(errno, err_string, ERR_STRING_SZ));
         return (-errno);
     };
 
     // stdout
     if (dup2(dev_null_fd, STDOUT_FILENO) == -1) {
-        HiLog::Error(LABEL, "dup2 STDOUT error: %{public}s", strerror(errno));
+        HiLog::Error(LABEL, "dup2 STDOUT error: %{public}d", strerror_r(errno, err_string, ERR_STRING_SZ));
         return (-errno);
     };
 
     // stderr
     if (dup2(dev_null_fd, STDERR_FILENO) == -1) {
-        HiLog::Error(LABEL, "dup2 STDERR error: %{public}s", strerror(errno));
+        HiLog::Error(LABEL, "dup2 STDERR error: %{public}d", strerror_r(errno, err_string, ERR_STRING_SZ));
         return (-errno);
     };
 
@@ -348,25 +359,26 @@ int32_t AppSpawnServer::SetCapabilities()
 
     // init inheritable permitted effective zero
 #ifdef GRAPHIC_PERMISSION_CHECK
-    uint64_t inheriTable = 0;
-    uint64_t permitted = 0;
-    uint64_t effective = 0;
+    const uint64_t inheriTable = 0;
+    const uint64_t permitted = 0;
+    const uint64_t effective = 0;
 #else
-    uint64_t inheriTable = 0x3fffffffff;
-    uint64_t permitted = 0x3fffffffff;
-    uint64_t effective = 0x3fffffffff;
+    const uint64_t inheriTable = 0x3fffffffff;
+    const uint64_t permitted = 0x3fffffffff;
+    const uint64_t effective = 0x3fffffffff;
 #endif
 
-    cap_data[0].inheritable = inheriTable;
-    cap_data[1].inheritable = inheriTable >> BITLEN32;
-    cap_data[0].permitted = permitted;
-    cap_data[1].permitted = permitted >> BITLEN32;
-    cap_data[0].effective = effective;
-    cap_data[1].effective = effective >> BITLEN32;
+    cap_data[0].inheritable = static_cast<__u32>(inheriTable);
+    cap_data[1].inheritable = static_cast<__u32>(inheriTable >> BITLEN32);
+    cap_data[0].permitted = static_cast<__u32>(permitted);
+    cap_data[1].permitted = static_cast<__u32>(permitted >> BITLEN32);
+    cap_data[0].effective = static_cast<__u32>(effective);
+    cap_data[1].effective = static_cast<__u32>(effective >> BITLEN32);
 
+    char err_string[ERR_STRING_SZ];
     // set capabilities
     if (capset(&cap_header, &cap_data[0]) == -1) {
-        HiLog::Error(LABEL, "capset failed: %{public}s", strerror(errno));
+        HiLog::Error(LABEL, "capset failed: %{public}d", strerror_r(errno, err_string, ERR_STRING_SZ));
         return errno;
     }
 
@@ -386,6 +398,10 @@ void AppSpawnServer::SetServerSocket(const std::shared_ptr<ServerSocket> &server
 bool AppSpawnServer::SetAppProcProperty(int connectFd, const ClientSocket::AppProperty *appProperty, char *longProcName,
     int64_t longProcNameLen, const int32_t fd[FDLEN2])
 {
+    if (appProperty == nullptr) {
+        HiLog::Error(LABEL, "appProperty is nullptr");
+        return false;
+    }
     pid_t newPid = getpid();
     HiLog::Debug(LABEL, "AppSpawnServer::Success to fork new process, pid = %{public}d", newPid);
     // close socket connection and peer socket in child process
@@ -442,6 +458,10 @@ void AppSpawnServer::NotifyResToParentProc(const int32_t fd, const int32_t value
 
 void AppSpawnServer::SpecialHandle(ClientSocket::AppProperty *appProperty)
 {
+    if (appProperty == nullptr) {
+        HiLog::Error(LABEL, "appProperty is nullptr");
+        return;
+    }
     // special handle bundle name "com.ohos.photos" and "com.ohos.camera"
     if ((strcmp(appProperty->processName, BUNDLE_NAME_CAMERA.data()) == 0) ||
         (strcmp(appProperty->processName, BUNDLE_NAME_PHOTOS.data()) == 0)) {
@@ -456,10 +476,11 @@ void AppSpawnServer::SpecialHandle(ClientSocket::AppProperty *appProperty)
 
 int32_t AppSpawnServer::SetKeepCapabilities(uint32_t uid)
 {
+    char err_string[ERR_STRING_SZ];
     // set keep capabilities when user not root.
     if (uid != 0) {
         if (prctl(PR_SET_KEEPCAPS, 1, 0, 0, 0) == -1) {
-            HiLog::Error(LABEL, "set keepcaps failed: %{public}s", strerror(errno));
+            HiLog::Error(LABEL, "set keepcaps failed: %{public}d", strerror_r(errno, err_string, ERR_STRING_SZ));
             return (-errno);
         }
     }
diff --git a/src/main.cpp b/src/main.cpp
index 905bfec6243470c831daa686f4df0b6595b8a16f..b6bb8a587e4f5e70c1dabc31ba1ad7246059bb4d 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -18,7 +18,7 @@
 #include "appspawn_server.h"
 #include "hilog/log.h"
 
-int main(int argc, char* const argv[])
+int main(int argc, char *const argv[])
 {
     if (argc > 0) {
         // calculate child process long name size
diff --git a/src/socket/appspawn_socket.cpp b/src/socket/appspawn_socket.cpp
index 1eb2362b413d74d9ba8b958f6640268758f1cf23..76b984fe99e529bcf534366716a764eb2c1dd741 100755
--- a/src/socket/appspawn_socket.cpp
+++ b/src/socket/appspawn_socket.cpp
@@ -27,6 +27,7 @@ namespace OHOS {
 namespace AppSpawn {
 using namespace OHOS::HiviewDFX;
 static constexpr HiLogLabel LABEL = {LOG_CORE, 0, "AppSpawnSocket"};
+constexpr static size_t ERR_STRING_SZ = 64;
 
 AppSpawnSocket::AppSpawnSocket(const std::string &name)
 {
@@ -80,9 +81,10 @@ int AppSpawnSocket::PackSocketAddr()
 
 int AppSpawnSocket::CreateSocket()
 {
+    char err_string[ERR_STRING_SZ];
     int socketFd = socket(AF_LOCAL, SOCK_SEQPACKET, 0);
     if (socketFd < 0) {
-        HiLog::Error(LABEL, "Failed to create socket: %s", strerror(errno));
+        HiLog::Error(LABEL, "Failed to create socket: %d", strerror_r(errno, err_string, ERR_STRING_SZ));
         return -1;
     }
 
@@ -101,6 +103,7 @@ void AppSpawnSocket::CloseSocket(int &socketFd)
 
 int AppSpawnSocket::ReadSocketMessage(int socketFd, void *buf, int len)
 {
+    char err_string[ERR_STRING_SZ];
     if (socketFd < 0 || len <= 0 || buf == nullptr) {
         HiLog::Error(LABEL, "Invalid args: socket %d, len %d, buf might be nullptr", socketFd, len);
         return -1;
@@ -113,7 +116,8 @@ int AppSpawnSocket::ReadSocketMessage(int socketFd, void *buf, int len)
 
     ssize_t rLen = TEMP_FAILURE_RETRY(read(socketFd, buf, len));
     if (rLen < 0) {
-        HiLog::Error(LABEL, "Read message from fd %d error %zd: %s", socketFd, rLen, strerror(errno));
+        HiLog::Error(LABEL, "Read message from fd %d error %zd: %d",
+            socketFd, rLen, strerror_r(errno, err_string, ERR_STRING_SZ));
         return -1;
     }
 
@@ -122,6 +126,7 @@ int AppSpawnSocket::ReadSocketMessage(int socketFd, void *buf, int len)
 
 int AppSpawnSocket::WriteSocketMessage(int socketFd, const void *buf, int len)
 {
+    char err_string[ERR_STRING_SZ];
     if (socketFd < 0 || len <= 0 || buf == nullptr) {
         HiLog::Error(LABEL, "Invalid args: socket %d, len %d, buf might be nullptr", socketFd, len);
         return -1;
@@ -134,7 +139,8 @@ int AppSpawnSocket::WriteSocketMessage(int socketFd, const void *buf, int len)
         wLen = write(socketFd, offset, remain);
         HiLog::Debug(LABEL, "socket fd %d, wLen %zd", socketFd, wLen);
         if ((wLen <= 0) && (errno != EINTR)) {
-            HiLog::Error(LABEL, "Failed to write message to fd %d, error %zd: %s", socketFd, wLen, strerror(errno));
+            HiLog::Error(LABEL, "Failed to write message to fd %d, error %zd: %d",
+                socketFd, wLen, strerror_r(errno, err_string, ERR_STRING_SZ));
             return -1;
         }
     }
diff --git a/src/socket/client_socket.cpp b/src/socket/client_socket.cpp
index fbed40f4f4f42aa8043d61ee08e9ab1b4997042b..c39a0c95d3bbba2e21526a58fdc155ded6989000 100644
--- a/src/socket/client_socket.cpp
+++ b/src/socket/client_socket.cpp
@@ -26,6 +26,7 @@ namespace OHOS {
 namespace AppSpawn {
 using namespace OHOS::HiviewDFX;
 static constexpr HiLogLabel LABEL = {LOG_CORE, 0, "ClientSocket"};
+constexpr static size_t ERR_STRING_SZ = 64;
 
 ClientSocket::ClientSocket(const std::string &client) : AppSpawnSocket(client)
 {}
@@ -57,6 +58,7 @@ void ClientSocket::CloseClient()
 
 int ClientSocket::ConnectSocket(int connectFd)
 {
+    char err_string[ERR_STRING_SZ];
     if (connectFd < 0) {
         HiLog::Error(LABEL, "Client: Invalid socket fd: %d", connectFd);
         return -1;
@@ -68,11 +70,13 @@ int ClientSocket::ConnectSocket(int connectFd)
 
     if ((setsockopt(connectFd, SOL_SOCKET, SO_RCVTIMEO, &SOCKET_TIMEOUT, sizeof(SOCKET_TIMEOUT)) != 0) ||
         (setsockopt(connectFd, SOL_SOCKET, SO_SNDTIMEO, &SOCKET_TIMEOUT, sizeof(SOCKET_TIMEOUT)) != 0)) {
-        HiLog::Warn(LABEL, "Client: Failed to set opt of socket %d, err %s", connectFd, strerror(errno));
+        HiLog::Warn(LABEL, "Client: Failed to set opt of socket %d, err %d",
+            connectFd, strerror_r(errno, err_string, ERR_STRING_SZ));
     }
 
     if (connect(connectFd, reinterpret_cast<struct sockaddr *>(&socketAddr_), socketAddrLen_) < 0) {
-        HiLog::Warn(LABEL, "Client: Connect on socket fd %d, failed: %s", connectFd, strerror(errno));
+        HiLog::Warn(LABEL, "Client: Connect on socket fd %d, failed: %d",
+            connectFd, strerror_r(errno, err_string, ERR_STRING_SZ));
         CloseSocket(connectFd);
         return -1;
     }
diff --git a/src/socket/server_socket.cpp b/src/socket/server_socket.cpp
index a4daf97bbd51058670beada2228555ab02d3ca43..941cd4049d632379036e1bfa63008753827b620c 100644
--- a/src/socket/server_socket.cpp
+++ b/src/socket/server_socket.cpp
@@ -26,6 +26,7 @@ namespace OHOS {
 namespace AppSpawn {
 using namespace OHOS::HiviewDFX;
 static constexpr HiLogLabel LABEL = {LOG_CORE, 0, "ServerSocket"};
+constexpr static size_t ERR_STRING_SZ = 64;
 
 ServerSocket::ServerSocket(const std::string &server) : AppSpawnSocket(server)
 {}
@@ -100,6 +101,7 @@ void ServerSocket::CloseServerMonitor()
 
 int ServerSocket::BindSocket(int connectFd)
 {
+    char err_string[ERR_STRING_SZ];
     if (connectFd < 0) {
         HiLog::Error(LABEL, "Server: Invalid socket fd: %d", connectFd);
         return -1;
@@ -110,7 +112,7 @@ int ServerSocket::BindSocket(int connectFd)
     }
 
     if ((unlink(socketAddr_.sun_path) != 0) && (errno != ENOENT)) {
-        HiLog::Error(LABEL, "Server: Failed to unlink, err %s", strerror(errno));
+        HiLog::Error(LABEL, "Server: Failed to unlink, err %d", strerror_r(errno, err_string, ERR_STRING_SZ));
         return -1;
     }
 
@@ -118,22 +120,26 @@ int ServerSocket::BindSocket(int connectFd)
     if ((setsockopt(connectFd, SOL_SOCKET, SO_REUSEADDR, &reuseAddr, sizeof(reuseAddr)) != 0) ||
         (setsockopt(connectFd, SOL_SOCKET, SO_RCVTIMEO, &SOCKET_TIMEOUT, sizeof(SOCKET_TIMEOUT)) != 0) ||
         (setsockopt(connectFd, SOL_SOCKET, SO_SNDTIMEO, &SOCKET_TIMEOUT, sizeof(SOCKET_TIMEOUT)) != 0)) {
-        HiLog::Warn(LABEL, "Server: Failed to set opt of socket %d, err %s", connectFd, strerror(errno));
+        HiLog::Warn(LABEL, "Server: Failed to set opt of socket %d, err %d",
+            connectFd, strerror_r(errno, err_string, ERR_STRING_SZ));
     }
 
     if (bind(connectFd, reinterpret_cast<struct sockaddr *>(&socketAddr_), socketAddrLen_) < 0) {
-        HiLog::Error(LABEL, "Server: Bind socket fd %d, failed: %s", connectFd, strerror(errno));
+        HiLog::Error(LABEL, "Server: Bind socket fd %d, failed: %d",
+            connectFd, strerror_r(errno, err_string, ERR_STRING_SZ));
         return -1;
     }
 
     if (chown(socketAddr_.sun_path, APPSPAWN_ID_ROOT, APPSPAWN_ID_SYSTEM)) {
-        HiLog::Error(LABEL, "Server: failed to chown socket fd %d, failed: %s", connectFd, strerror(errno));
+        HiLog::Error(LABEL, "Server: failed to chown socket fd %d, failed: %d",
+            connectFd, strerror_r(errno, err_string, ERR_STRING_SZ));
         return -1;
     }
     if (chmod(socketAddr_.sun_path, SOCKET_PERM)) {
-        HiLog::Error(LABEL, "Server: failed to chmod socket fd %d, failed: %s", connectFd, strerror(errno));
+        HiLog::Error(LABEL, "Server: failed to chmod socket fd %d, failed: %d",
+            connectFd, strerror_r(errno, err_string, ERR_STRING_SZ));
         if ((unlink(socketAddr_.sun_path) != 0) && (errno != ENOENT)) {
-            HiLog::Error(LABEL, "Server: Failed to unlink, err %s", strerror(errno));
+            HiLog::Error(LABEL, "Server: Failed to unlink, err %d", strerror_r(errno, err_string, ERR_STRING_SZ));
         }
         return -1;
     }
@@ -143,6 +149,7 @@ int ServerSocket::BindSocket(int connectFd)
 
 int ServerSocket::RegisterServerSocket(int &connectFd)
 {
+    char err_string[ERR_STRING_SZ];
     if (socketName_.empty()) {
         HiLog::Error(LABEL, "Server: Invalid socket name: empty");
         return -1;
@@ -155,10 +162,10 @@ int ServerSocket::RegisterServerSocket(int &connectFd)
 
     if ((BindSocket(connectFd) != 0) || (listen(connectFd, listenBacklog_) < 0)) {
         HiLog::Error(LABEL,
-            "Server: Register socket fd %d with backlog %d error: %s",
+            "Server: Register socket fd %d with backlog %d error: %d",
             connectFd,
             listenBacklog_,
-            strerror(errno));
+            strerror_r(errno, err_string, ERR_STRING_SZ));
         close(connectFd);
         connectFd = -1;
         return -1;
@@ -180,6 +187,7 @@ int ServerSocket::RegisterServerSocket()
 
 int ServerSocket::WaitForConnection(int connectFd)
 {
+    char err_string[ERR_STRING_SZ];
     if (connectFd < 0) {
         HiLog::Error(LABEL, "Server: Invalid args: connectFd %d", connectFd);
         return -1;
@@ -198,7 +206,8 @@ int ServerSocket::WaitForConnection(int connectFd)
 
     if ((setsockopt(connFd, SOL_SOCKET, SO_RCVTIMEO, &SOCKET_TIMEOUT, sizeof(SOCKET_TIMEOUT)) < 0) ||
         (setsockopt(connFd, SOL_SOCKET, SO_SNDTIMEO, &SOCKET_TIMEOUT, sizeof(SOCKET_TIMEOUT)) < 0)) {
-        HiLog::Warn(LABEL, "Server: Failed to set opt of Connection %d, err %s", connFd, strerror(errno));
+        HiLog::Warn(LABEL, "Server: Failed to set opt of Connection %d, err %d",
+            connFd, strerror_r(errno, err_string, ERR_STRING_SZ));
     }
 
     HiLog::Debug(LABEL, "Server: Connection accepted, connect fd %d", connFd);
diff --git a/test/mock/include/mock_server_socket.h b/test/mock/include/mock_server_socket.h
index 3cdbf36fac9cf36db77dbe32f3d5aa5707100842..b1eb98ddd7b0edad0b108f519afb857f1a997d3e 100644
--- a/test/mock/include/mock_server_socket.h
+++ b/test/mock/include/mock_server_socket.h
@@ -55,17 +55,20 @@ public:
         auto ret = memset_s(params->gidTable, sizeof(params->gidTable), 0, sizeof(params->gidTable));
         if (ret != EOK) {
             HiLog::Info(LABEL, "memset_s failed");
+            return 0;
         }
         params->gidCount = ClientSocket::MAX_GIDS + 1;
         std::string processName = "processName";
         ret = memcpy_s(params->processName, sizeof(params->processName), processName.c_str(), processName.length());
         if (ret != EOK) {
             HiLog::Info(LABEL, "memcpy_s failed");
+            return 0;
         }
         std::string soPath = "soPath";
         ret = memcpy_s(params->soPath, sizeof(params->soPath), soPath.c_str(), soPath.length());
         if (ret != EOK) {
             HiLog::Info(LABEL, "memcpy_s failed");
+            return 0;
         }
 
         return sizeof(ClientSocket::AppProperty);
@@ -85,17 +88,20 @@ public:
         auto ret = memset_s(params->gidTable, sizeof(params->gidTable), 0, sizeof(params->gidTable));
         if (ret != EOK) {
             HiLog::Info(LABEL, "memset_s failed");
+            return 0;
         }
         params->gidCount = ClientSocket::MAX_GIDS;
         std::string processName = "";
         ret = memcpy_s(params->processName, sizeof(params->processName), processName.c_str(), processName.length());
         if (ret != EOK) {
             HiLog::Info(LABEL, "memcpy_s failed");
+            return 0;
         }
         std::string soPath = "soPath";
         ret = memcpy_s(params->soPath, sizeof(params->soPath), soPath.c_str(), soPath.length());
         if (ret != EOK) {
             HiLog::Info(LABEL, "memcpy_s failed");
+            return 0;
         }
 
         return sizeof(ClientSocket::AppProperty);
@@ -115,17 +121,20 @@ public:
         auto ret = memset_s(params->gidTable, sizeof(params->gidTable), 0, sizeof(params->gidTable));
         if (ret != EOK) {
             HiLog::Info(LABEL, "memset_s failed");
+            return 0;
         }
         params->gidCount = ClientSocket::MAX_GIDS;
         std::string processName = "processName";
         ret = memcpy_s(params->processName, sizeof(params->processName), processName.c_str(), processName.length());
         if (ret != EOK) {
             HiLog::Info(LABEL, "memcpy_s failed");
+            return 0;
         }
         std::string soPath = "soPath";
         ret = memcpy_s(params->soPath, sizeof(params->soPath), soPath.c_str(), soPath.length());
         if (ret != EOK) {
             HiLog::Info(LABEL, "memcpy_s failed");
+            return 0;
         }
 
         return sizeof(ClientSocket::AppProperty);
@@ -145,17 +154,20 @@ public:
         auto ret = memset_s(params->gidTable, sizeof(params->gidTable), 0, sizeof(params->gidTable));
         if (ret != EOK) {
             HiLog::Info(LABEL, "memset_s failed");
+            return 0;
         }
         params->gidCount = ClientSocket::MAX_GIDS;
         std::string processName = "ProcessName1234567890";
         ret = memcpy_s(params->processName, sizeof(params->processName), processName.c_str(), processName.length());
         if (ret != EOK) {
             HiLog::Info(LABEL, "memcpy_s failed");
+            return 0;
         }
         std::string soPath = "soPath";
         ret = memcpy_s(params->soPath, sizeof(params->soPath), soPath.c_str(), soPath.length());
         if (ret != EOK) {
             HiLog::Info(LABEL, "memcpy_s failed");
+            return 0;
         }
 
         return sizeof(ClientSocket::AppProperty);
diff --git a/test/mock/src/appspawn_msg_peer.cpp b/test/mock/src/appspawn_msg_peer.cpp
index 55dd8c1328e053c9d57f79354dfeb75281e8efe6..8e2c799b73146fc22631de9d81355c6c04c722dd 100644
--- a/test/mock/src/appspawn_msg_peer.cpp
+++ b/test/mock/src/appspawn_msg_peer.cpp
@@ -49,6 +49,7 @@ ClientSocket::AppProperty *AppSpawnMsgPeer::GetMsg() const
         auto ret = memset_s(appProperty->gidTable, sizeof(appProperty->gidTable), 0, sizeof(appProperty->gidTable));
         if (ret != EOK) {
             HiLog::Error(LABEL, "memset_s failed!");
+            return nullptr;
         }
         appProperty->gidCount = ClientSocket::MAX_GIDS;
         std::string processName = "processName";
@@ -56,11 +57,13 @@ ClientSocket::AppProperty *AppSpawnMsgPeer::GetMsg() const
             appProperty->processName, sizeof(appProperty->processName), processName.c_str(), processName.length());
         if (ret != EOK) {
             HiLog::Error(LABEL, "memcpy_s failed!");
+            return nullptr;
         }
         std::string soPath = "soPath";
         ret = memcpy_s(appProperty->soPath, sizeof(appProperty->soPath), soPath.c_str(), soPath.length());
         if (ret != EOK) {
             HiLog::Error(LABEL, "memcpy_s failed!");
+            return nullptr;
         }
     }
 
diff --git a/test/moduletest/appspawn_module_test.cpp b/test/moduletest/appspawn_module_test.cpp
index ff487b825094f403190d307c1eb10dbd9a7d2aa6..330d34bbd023791d35c3927a9fc3d0789a8f250c 100644
--- a/test/moduletest/appspawn_module_test.cpp
+++ b/test/moduletest/appspawn_module_test.cpp
@@ -48,7 +48,7 @@ const int32_t GROUPS_POSITION_MOVE = 8;
 const char *DELIMITER_SPACE = " ";
 const char *DELIMITER_NEWLINE = "\n";
 
-char buffer[BUFFER_SIZE];
+char buffer[BUFFER_SIZE] = {"\0"};
 int32_t newPid = 0;
 int32_t retryCount = 0;
 }  // namespace
@@ -132,6 +132,10 @@ bool checkGid(const int32_t &pid, const AppSpawnStartMsg &params)
         if (strlen(gidPtr) > GID_POSITION_MOVE) {
             gidPtr = gidPtr + GID_POSITION_MOVE;
         }
+        if (gidPtr == nullptr) {
+            HiLog::Error(LABEL, "get Gid info failed.");
+            return CHECK_ERROR;
+        }
         int32_t gid = (int32_t)strtol(gidPtr, NULL, BASE_TYPE);
         HiLog::Info(LABEL, "new proc(%{public}d) gid = %{public}d, setGid=%{public}d.", pid, gid, params.gid);
         if (gid == params.gid) {
@@ -154,6 +158,10 @@ std::size_t getGids(const int32_t &pid, std::vector<int32_t> &gids)
         }
         // Get the row content of Groups
         char *saveptr = nullptr;
+        if (groupsPtr == nullptr || strlen(groupsPtr) > BUFFER_SIZE) {
+            HiLog::Error(LABEL, "get Groups info failed.");
+            return CHECK_ERROR;
+        }
         char *line = strtok_r(groupsPtr, DELIMITER_NEWLINE, &saveptr);
         if (line == nullptr || strlen(line) > BUFFER_SIZE) {
             HiLog::Error(LABEL, "get Groups line info failed.");
@@ -202,6 +210,10 @@ bool checkProcName(const int32_t &pid, const AppSpawnStartMsg &params)
         HiLog::Error(LABEL, "cmd sprintf_s fail .");
         return CHECK_ERROR;
     }
+    if(strlen(cmd) > CMD_SIZE){
+        HiLog::Error(LABEL, " cmd length is too long  .");
+        return CHECK_ERROR;
+    }
     fp = popen(cmd, "r");
     if (fp == nullptr) {
         HiLog::Error(LABEL, " popen function call failed .");
diff --git a/test/unittest/app_spawn_server_test/app_spawn_server_mock_test.cpp b/test/unittest/app_spawn_server_test/app_spawn_server_mock_test.cpp
index ebe9962049719481ac1279aae9d49a2351c81206..ff2f71570bcfc33f4d3ea6ad4df82c3b94215d61 100644
--- a/test/unittest/app_spawn_server_test/app_spawn_server_mock_test.cpp
+++ b/test/unittest/app_spawn_server_test/app_spawn_server_mock_test.cpp
@@ -30,15 +30,14 @@ using namespace testing;
 using namespace testing::ext;
 using namespace OHOS::AppSpawn;
 
+static constexpr int TEST_WAIT_TIME = 50 * 1000;  // 50 ms
+
 class AppSpawnServerMockTest : public testing::Test {
 public:
     static void SetUpTestCase();
     static void TearDownTestCase();
     void SetUp();
     void TearDown();
-
-public:
-    static constexpr int TEST_WAIT_TIME = 50 * 1000;  // 50 ms
 protected:
     std::unique_ptr<AppSpawnServer> appSpawnServer_ = nullptr;
     std::shared_ptr<MockServerSocket> mockServerSocket_ = nullptr;
@@ -110,7 +109,7 @@ HWTEST_F(AppSpawnServerMockTest, App_Spawn_Server_002, TestSize.Level0)
 
     auto func = [&]() {
         // wait ServerMain unit test case
-        usleep(AppSpawnServerMockTest::TEST_WAIT_TIME);
+        usleep(TEST_WAIT_TIME);
         appSpawnServer_->SetRunning(false);
     };
 
@@ -118,7 +117,7 @@ HWTEST_F(AppSpawnServerMockTest, App_Spawn_Server_002, TestSize.Level0)
     EXPECT_EQ(false, appSpawnServer_->ServerMain(argv, sizeof(argv)));
 
     // wait release
-    usleep(AppSpawnServerMockTest::TEST_WAIT_TIME);
+    usleep(TEST_WAIT_TIME);
 
     GTEST_LOG_(INFO) << "App_Spawn_Server_002 end";
 }
@@ -149,7 +148,7 @@ HWTEST_F(AppSpawnServerMockTest, App_Spawn_Server_003, TestSize.Level0)
 
     auto func = [=]() {
         // wait ServerMain unit test case
-        usleep(AppSpawnServerMockTest::TEST_WAIT_TIME);
+        usleep(TEST_WAIT_TIME);
         appSpawnServer_->SetRunning(false);
     };
 
@@ -157,7 +156,7 @@ HWTEST_F(AppSpawnServerMockTest, App_Spawn_Server_003, TestSize.Level0)
     EXPECT_EQ(false, appSpawnServer_->ServerMain(argv, sizeof(argv)));
 
     // wait release
-    usleep(AppSpawnServerMockTest::TEST_WAIT_TIME);
+    usleep(TEST_WAIT_TIME);
 
     GTEST_LOG_(INFO) << "App_Spawn_Server_003 end";
 }
diff --git a/test/unittest/app_spawn_server_test/app_spawn_server_override_test.cpp b/test/unittest/app_spawn_server_test/app_spawn_server_override_test.cpp
index 7deb9969d1615c4c6a92a010642c2345522acf23..33422757e190970eb1ff7b0372b4b88d5b32ea75 100644
--- a/test/unittest/app_spawn_server_test/app_spawn_server_override_test.cpp
+++ b/test/unittest/app_spawn_server_test/app_spawn_server_override_test.cpp
@@ -28,15 +28,14 @@ using namespace testing;
 using namespace testing::ext;
 using namespace OHOS::AppSpawn;
 
+static constexpr int TEST_WAIT_TIME = 50 * 1000;  // 50 ms
+
 class AppSpawnServerOverrideTest : public testing::Test {
 public:
     static void SetUpTestCase();
     static void TearDownTestCase();
     void SetUp();
     void TearDown();
-
-public:
-    static constexpr int TEST_WAIT_TIME = 50 * 1000;  // 50 ms
 protected:
     std::unique_ptr<AppSpawnServer> appSpawnServer_ = nullptr;
 };
@@ -72,14 +71,14 @@ HWTEST_F(AppSpawnServerOverrideTest, App_Spawn_Server_Override_001, TestSize.Lev
     char argv[20] = "LongNameTest";
     auto func = [&]() {
         // wait ServerMain unit test case
-        usleep(AppSpawnServerOverrideTest::TEST_WAIT_TIME);
+        usleep(TEST_WAIT_TIME);
         appSpawnServer_->SetRunning(false);
     };
     std::thread(func).detach();
     EXPECT_EQ(false, appSpawnServer_->ServerMain(argv, sizeof(argv)));
 
     // wait release
-    usleep(AppSpawnServerOverrideTest::TEST_WAIT_TIME);
+    usleep(TEST_WAIT_TIME);
 
     GTEST_LOG_(INFO) << "App_Spawn_Server_Override_001 end";
 }
diff --git a/test/unittest/app_spawn_socket_test/app_spawn_socket_test.cpp b/test/unittest/app_spawn_socket_test/app_spawn_socket_test.cpp
index 4e1759727a6bcf858a3583807367f3ca1dc2d774..ca5a5bb49c6e51bb955a3a5de08c75d2a9cf86fe 100644
--- a/test/unittest/app_spawn_socket_test/app_spawn_socket_test.cpp
+++ b/test/unittest/app_spawn_socket_test/app_spawn_socket_test.cpp
@@ -14,7 +14,7 @@
  */
 
 #include <gtest/gtest.h>
-#include <string.h>
+#include <cstring>
 
 // redefine private and protected since testcase need to invoke and test private function
 #define private public
@@ -35,9 +35,6 @@ public:
     static void TearDownTestCase();
     void SetUp();
     void TearDown();
-
-public:
-    static constexpr int TEST_WAIT_TIME = 100000;
 };
 
 void AppSpawnSocketTest::SetUpTestCase()
@@ -277,6 +274,7 @@ HWTEST(AppSpawnSocketTest, App_Spawn_Socket_010, TestSize.Level0)
     EXPECT_TRUE(appSpawnSocket);
     std::string content = "hiworld";
     int32_t len = content.length();
+    EXPECT_TRUE(len);
     std::unique_ptr<int8_t[]> buff = std::make_unique<int8_t[]>(len);
     EXPECT_TRUE(buff);
     int32_t fd[2] = {0, 0};
@@ -407,6 +405,7 @@ HWTEST(AppSpawnSocketTest, App_Spawn_Socket_015, TestSize.Level0)
     EXPECT_TRUE(appSpawnSocket);
     std::string content = "hiworld";
     int32_t len = content.length();
+    EXPECT_TRUE(len);
     std::unique_ptr<int8_t[]> buff = std::make_unique<int8_t[]>(len);
     EXPECT_TRUE(buff);
     int32_t fd[2] = {0, 0};
diff --git a/test/unittest/client_socket_test/client_socket_test.cpp b/test/unittest/client_socket_test/client_socket_test.cpp
index 197ffd00431b0b9323beedeb199a19a7c0a22265..aabbfc5a57096b2bb4ed1e53e9aef5264f130336 100644
--- a/test/unittest/client_socket_test/client_socket_test.cpp
+++ b/test/unittest/client_socket_test/client_socket_test.cpp
@@ -35,9 +35,6 @@ public:
     static void TearDownTestCase();
     void SetUp();
     void TearDown();
-
-public:
-    static constexpr int TEST_WAIT_TIME = 100000;
 };
 
 void ClientSocketTest::SetUpTestCase()
diff --git a/test/unittest/server_socket_test/server_socket_test.cpp b/test/unittest/server_socket_test/server_socket_test.cpp
index 890a67bcd3374604e6d715749c2ad0dd0ab7006b..0cfdbfe93a0b4533787c6af9b22ba0c01088ce0e 100644
--- a/test/unittest/server_socket_test/server_socket_test.cpp
+++ b/test/unittest/server_socket_test/server_socket_test.cpp
@@ -35,9 +35,6 @@ public:
     static void TearDownTestCase();
     void SetUp();
     void TearDown();
-
-public:
-    static constexpr int TEST_WAIT_TIME = 100000;
 };
 
 void ServerSocketTest::SetUpTestCase()