!897 fix bug for cmd service

Merge pull request !897 from Mupceet/controlfd

interfaces/innerkits/control_fd/control_fd.h

@@ -18,6 +18,9 @@
 
 #include <stdint.h>
 #include <fcntl.h>
+#include <limits.h>
+
+#include "list.h"
 #include "loop_event.h"
 
 #ifdef __cplusplus
@@ -29,19 +32,28 @@ extern "C" {
 #define INIT_CONTROL_FD_SOCKET_PATH "/dev/unix/socket/init_control_fd"
 
 #define CONTROL_FD_FIFO_MODE (S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH)
-#define FIFO_BUF_SIZE 4096
-#define FIFO_PATH_SIZE 128
+#define PTY_BUF_SIZE 4096
+#define PTY_PATH_SIZE 128
 
 typedef struct CmdService_ {
     TaskHandle serverTask;
+    struct ListNode head;
 } CmdService;
 
 typedef struct CmdAgent_ {
     TaskHandle task;
     WatcherHandle input; // watch stdin
-    WatcherHandle reader; // watch read pipe
+    WatcherHandle reader; // watch read pty
+    int ptyFd;
 } CmdAgent;
 
+typedef struct CmdTask_ {
+    TaskHandle task;
+    struct ListNode item;
+    int ptyFd;
+    pid_t pid;
+} CmdTask;
+
 typedef void (* CallbackControlFdProcess)(uint16_t type, const char *serviceCmd, const void *context);
 
 typedef enum {
@@ -55,14 +67,13 @@ typedef enum {
 typedef struct {
     uint16_t msgSize;
     uint16_t type;
-    pid_t pid;
-    char fifoName[FIFO_PATH_SIZE];
+    char ptyName[PTY_PATH_SIZE];
     char cmd[0];
 } CmdMessage;
 
 void CmdServiceInit(const char *socketPath, CallbackControlFdProcess func);
-void CmdClientInit(const char *socketPath, uint16_t type, const char *cmd, const char *fifoName);
-void DestroyCmdFifo(int rfd, int wfd, const char *readPath, const char *writePath);
+void CmdClientInit(const char *socketPath, uint16_t type, const char *cmd);
+void CmdServiceProcessDelClient(pid_t pid);
 
 #ifdef __cplusplus
 #if __cplusplus

interfaces/innerkits/control_fd/control_fd_client.c

@@ -17,9 +17,11 @@
 #include <stdbool.h>
 #include <stdlib.h>
 #include <stdio.h>
+#include <sys/ioctl.h>
 #include <sys/select.h>
 #include <sys/stat.h>
 #include <sys/types.h>
+#include <termios.h>
 #include <time.h>
 #include <unistd.h>
 #include <limits.h>
@@ -29,76 +31,46 @@
 #include "init_utils.h"
 #include "securec.h"
 
-static char g_FifoReadPath[FIFO_PATH_SIZE] = {0};
-static int g_FifoReadFd = -1;
-
-static char g_FifoWritePath[FIFO_PATH_SIZE] = {0};
-static int g_FifoWriteFd = -1;
-
-static void ProcessFifoWrite(const WatcherHandle taskHandle, int fd, uint32_t *events, const void *context)
+static void ProcessPtyWrite(const WatcherHandle taskHandle, int fd, uint32_t *events, const void *context)
 {
     if ((fd < 0) || (events == NULL) || (context == NULL)) {
         BEGET_LOGE("[control_fd] Invalid fifo write parameter");
         return;
     }
-    int fifow = *((int *)context);
-    if (fifow < 0) {
-        BEGET_LOGE("[control_fd] invalid fifo write fd");
-        return;
-    }
-    char rbuf[FIFO_BUF_SIZE] = {0};
-    int rlen = read(fd, rbuf, FIFO_BUF_SIZE - 1);
+    CmdAgent *agent = (CmdAgent *)context;
+    char rbuf[PTY_BUF_SIZE] = {0};
+    int rlen = read(fd, rbuf, PTY_BUF_SIZE - 1);
     int ret = fflush(stdin);
     BEGET_ERROR_CHECK(ret == 0, return, "[control_fd] Failed fflush err=%d", errno);
     if (rlen > 0) {
-        int wlen = write(fifow, rbuf, rlen);
+        int wlen = write(agent->ptyFd, rbuf, rlen);
         BEGET_ERROR_CHECK(wlen == rlen, return, "[control_fd] Failed write fifo err=%d", errno);
     }
-    printf("#");
     ret = fflush(stdout);
     BEGET_ERROR_CHECK(ret == 0, return, "[control_fd] Failed fflush err=%d", errno);
     *events = Event_Read;
 }
 
-static void ProcessFifoRead(const WatcherHandle taskHandle, int fd, uint32_t *events, const void *context)
+static void ProcessPtyRead(const WatcherHandle taskHandle, int fd, uint32_t *events, const void *context)
 {
-    if ((fd < 0) || (events == NULL)) {
+    if ((fd < 0) || (events == NULL) || (context == NULL)) {
         BEGET_LOGE("[control_fd] Invalid fifo read parameter");
         return;
     }
-    char buf[FIFO_BUF_SIZE] = {0};
-    int readlen = read(fd, buf, FIFO_BUF_SIZE - 1);
+    CmdAgent *agent = (CmdAgent *)context;
+    char buf[PTY_BUF_SIZE] = {0};
+    int readlen = read(fd, buf, PTY_BUF_SIZE - 1);
     if (readlen > 0) {
         fprintf(stdout, "%s", buf);
     } else {
-        DestroyCmdFifo(g_FifoReadFd, g_FifoWriteFd, g_FifoReadPath, g_FifoWritePath);
+        (void)close(agent->ptyFd);
         return;
     }
     int ret = fflush(stdout);
     BEGET_ERROR_CHECK(ret == 0, return, "[control_fd] Failed fflush err=%d", errno);
-    printf("#");
-    ret = fflush(stdout);
-    BEGET_ERROR_CHECK(ret == 0, return, "[control_fd] Failed fflush err=%d", errno);
     *events = Event_Read;
 }
 
-void DestroyCmdFifo(int rfd, int wfd, const char *readPath, const char *writePath)
-{
-    if (rfd >= 0) {
-        (void)close(rfd);
-    }
-    if (wfd >= 0) {
-        (void)close(wfd);
-    }
-
-    if (readPath != NULL) {
-        BEGET_CHECK_ONLY_ELOG(unlink(readPath) == 0, "Failed unlink fifo %s", readPath);
-    }
-    if (writePath != NULL) {
-        BEGET_CHECK_ONLY_ELOG(unlink(writePath) == 0, "Failed unlink fifo %s", writePath);
-    }
-}
-
 static void CmdOnRecvMessage(const TaskHandle task, const uint8_t *buffer, uint32_t buffLen)
 {
     BEGET_LOGI("[control_fd] CmdOnRecvMessage %s len %d.", (char *)buffer, buffLen);
@@ -112,7 +84,11 @@ static void CmdOnConntectComplete(const TaskHandle client)
 static void CmdOnClose(const TaskHandle task)
 {
     BEGET_LOGI("[control_fd] CmdOnClose");
-    DestroyCmdFifo(g_FifoReadFd, g_FifoWriteFd, g_FifoReadPath, g_FifoWritePath);
+    CmdAgent *agent = (CmdAgent *)LE_GetUserData(task);
+    BEGET_ERROR_CHECK(agent != NULL, return, "[control_fd] Invalid agent");
+    (void)close(agent->ptyFd);
+    agent->ptyFd = -1;
+    LE_StopLoop(LE_GetDefaultLoop());
 }
 
 static void CmdDisConnectComplete(const TaskHandle client)
@@ -120,54 +96,9 @@ static void CmdDisConnectComplete(const TaskHandle client)
     BEGET_LOGI("[control_fd] CmdDisConnectComplete");
 }
 
-static void CmdAgentInit(WatcherHandle handle, const char *path, bool read, ProcessWatchEvent func)
-{
-    if (path == NULL) {
-        BEGET_LOGE("[control_fd] Invalid parameter");
-        return;
-    }
-    BEGET_LOGI("[control_fd] client open %s", (read ? "read" : "write"));
-    char *realPath = GetRealPath(path);
-    if (realPath == NULL) {
-        BEGET_LOGE("[control_fd] Failed get real path %s", path);
-        return;
-    }
-    if (read == true) {
-        g_FifoReadFd = open(realPath, O_RDONLY | O_TRUNC | O_NONBLOCK);
-        BEGET_ERROR_CHECK(g_FifoReadFd >= 0, free(realPath); return, "[control_fd] Failed to open fifo read");
-        BEGET_LOGI("[control_fd] g_FifoReadFd is %d", g_FifoReadFd);
-    } else {
-        g_FifoWriteFd = open(realPath, O_WRONLY | O_TRUNC);
-        BEGET_ERROR_CHECK(g_FifoWriteFd >= 0, free(realPath); return, "[control_fd] Failed to open fifo write");
-        BEGET_LOGI("[control_fd] g_FifoWriteFd is %d", g_FifoWriteFd);
-    }
-    free(realPath);
-    // start watcher for stdin
-    LE_WatchInfo info = {};
-    info.flags = 0;
-    info.events = Event_Read;
-    info.processEvent = func;
-    if (read == true) {
-        info.fd = g_FifoReadFd; // read fifo0
-        BEGET_ERROR_CHECK(LE_StartWatcher(LE_GetDefaultLoop(), &handle, &info, NULL) == LE_SUCCESS,
-            return, "[control_fd] Failed le_loop start watcher fifo read");
-    } else {
-        info.fd = STDIN_FILENO; // read stdin and write fifo1
-        BEGET_ERROR_CHECK(LE_StartWatcher(LE_GetDefaultLoop(), &handle, &info, &g_FifoWriteFd) == LE_SUCCESS,
-            return, "[control_fd] Failed le_loop start watcher stdin");
-    }
-    return;
-}
-
 static void CmdOnSendMessageComplete(const TaskHandle task, const BufferHandle handle)
 {
     BEGET_LOGI("[control_fd] CmdOnSendMessageComplete");
-    CmdAgent *agent = (CmdAgent *)LE_GetUserData(task);
-    BEGET_ERROR_CHECK(agent != NULL, return, "[control_fd] Invalid agent");
-    CmdAgentInit(agent->input, g_FifoWritePath, false, ProcessFifoWrite);
-    printf("#");
-    int ret = fflush(stdout);
-    BEGET_ERROR_CHECK(ret == 0, return, "[control_fd] Failed fflush err=%d", errno);
 }
 
 static CmdAgent *CmdAgentCreate(const char *server)
@@ -194,85 +125,86 @@ static CmdAgent *CmdAgentCreate(const char *server)
     return agent;
 }
 
-static int CreateFifo(const char *pipeName)
-{
-    if (pipeName == NULL) {
-        BEGET_LOGE("[control_fd] Invalid parameter");
-        return -1;
-    }
-    // create fifo for cmd
-    CheckAndCreateDir(pipeName);
-    int ret = mkfifo(pipeName, CONTROL_FD_FIFO_MODE);
-    if (ret != 0) {
-        if (errno != EEXIST) {
-            return -1;
-        }
-    }
-    return 0;
-}
-
-static int SendCmdMessage(const CmdAgent *agent, uint16_t type, const char *cmd, const char *fifoName)
+static int SendCmdMessage(const CmdAgent *agent, uint16_t type, const char *cmd, const char *ptyName)
 {
-    if ((agent == NULL) || (cmd == NULL) || (fifoName == NULL)) {
+    if ((agent == NULL) || (cmd == NULL) || (ptyName == NULL)) {
         BEGET_LOGE("[control_fd] Invalid parameter");
         return -1;
     }
     int ret = 0;
     BufferHandle handle = NULL;
-    uint32_t bufferSize = sizeof(CmdMessage) + strlen(cmd) + FIFO_PATH_SIZE + 1;
+    uint32_t bufferSize = sizeof(CmdMessage) + strlen(cmd) + PTY_PATH_SIZE + 1;
     handle = LE_CreateBuffer(LE_GetDefaultLoop(), bufferSize);
     char *buff = (char *)LE_GetBufferInfo(handle, NULL, NULL);
     BEGET_ERROR_CHECK(buff != NULL, return -1, "[control_fd] Failed get buffer info");
     CmdMessage *message = (CmdMessage *)buff;
     message->msgSize = bufferSize;
     message->type = type;
-    message->pid = getpid();
-    ret = strcpy_s(message->fifoName, FIFO_PATH_SIZE - 1, fifoName);
+    ret = strcpy_s(message->ptyName, PTY_PATH_SIZE - 1, ptyName);
     BEGET_ERROR_CHECK(ret == 0, LE_FreeBuffer(LE_GetDefaultLoop(), agent->task, handle);
-        return -1, "[control_fd] Failed to copy fifo name %s", fifoName);
-    ret = strcpy_s(message->cmd, bufferSize - sizeof(CmdMessage) - FIFO_PATH_SIZE, cmd);
+        return -1, "[control_fd] Failed to copy pty name %s", ptyName);
+    ret = strcpy_s(message->cmd, bufferSize - sizeof(CmdMessage) - PTY_PATH_SIZE, cmd);
     BEGET_ERROR_CHECK(ret == 0, LE_FreeBuffer(LE_GetDefaultLoop(), agent->task, handle);
         return -1, "[control_fd] Failed to copy cmd %s", cmd);
     ret = LE_Send(LE_GetDefaultLoop(), agent->task, handle, bufferSize);
-    BEGET_ERROR_CHECK(ret == 0, return -1, "[control_fd] Failed LE_Send msg type %d, pid %d, cmd %s",
-        message->type, message->pid, message->cmd);
+    BEGET_ERROR_CHECK(ret == 0, return -1, "[control_fd] Failed LE_Send msg type %d, cmd %s",
+        message->type, message->cmd);
     return 0;
 }
 
-static int CmdMakeFifoInit(const char *fifoPath)
+static int InitPtyInterface(CmdAgent *agent, uint16_t type, const char *cmd)
 {
-    if (fifoPath == NULL) {
-        BEGET_LOGE("[control_fd] Invalid parameter");
+    if ((cmd == NULL) || (agent == NULL)) {
         return -1;
     }
-    int ret = sprintf_s(g_FifoReadPath, sizeof(g_FifoReadPath) - 1, "/dev/fifo/%s0.%d", fifoPath, getpid());
-    BEGET_ERROR_CHECK(ret > 0, return -1, "[control_fd] Failed sprintf_s err=%d", errno);
-    ret = CreateFifo(g_FifoReadPath);
-    BEGET_ERROR_CHECK(ret == 0, return -1, "[control_fd] Failed create fifo err=%d", errno);
-    
-    ret = sprintf_s(g_FifoWritePath, sizeof(g_FifoWritePath) - 1, "/dev/fifo/%s1.%d", fifoPath, getpid());
-    BEGET_ERROR_CHECK(ret > 0, return -1, "[control_fd] Failed sprintf_s err=%d", errno);
-    ret = CreateFifo(g_FifoWritePath);
-    BEGET_ERROR_CHECK(ret == 0, return -1, "[control_fd] Failed create fifo err=%d", errno);
+    // initialize terminal
+    struct termios term;
+    int ret = tcgetattr(STDIN_FILENO, &term);
+    BEGET_ERROR_CHECK(ret == 0, return -1, "Failed tcgetattr stdin, err=%d", errno);
+    cfmakeraw(&term);
+    term.c_cc[VTIME] = 0;
+    term.c_cc[VMIN] = 1;
+    ret = tcsetattr(STDIN_FILENO, TCSANOW, &term);
+    BEGET_ERROR_CHECK(ret == 0, return -1, "Failed tcsetattr term, err=%d", errno);
+    // open master pty and get slave pty
+    int pfd = open("/dev/ptmx", O_RDWR | O_CLOEXEC);
+    BEGET_ERROR_CHECK(pfd >= 0, return -1, "Failed open pty err=%d", errno);
+    BEGET_ERROR_CHECK(grantpt(pfd) >= 0, close(pfd); return -1, "Failed to call grantpt");
+    BEGET_ERROR_CHECK(unlockpt(pfd) >= 0, close(pfd); return -1, "Failed to call unlockpt");
+    char ptsbuffer[PTY_PATH_SIZE] = {0};
+    ret = ptsname_r(pfd, ptsbuffer, sizeof(ptsbuffer));
+    BEGET_ERROR_CHECK(ret >= 0, close(pfd); return -1, "Failed to get pts name err=%d", errno);
+    BEGET_LOGI("ptsbuffer is %s", ptsbuffer);
+    agent->ptyFd = pfd;
+
+    LE_WatchInfo info = {};
+    info.flags = 0;
+    info.events = Event_Read;
+    info.processEvent = ProcessPtyRead;
+    info.fd = pfd; // read ptmx
+    BEGET_ERROR_CHECK(LE_StartWatcher(LE_GetDefaultLoop(), &agent->reader, &info, agent) == LE_SUCCESS,
+        close(pfd); return -1, "[control_fd] Failed le_loop start watcher ptmx read");
+    info.processEvent = ProcessPtyWrite;
+    info.fd = STDIN_FILENO; // read stdin and write ptmx
+    BEGET_ERROR_CHECK(LE_StartWatcher(LE_GetDefaultLoop(), &agent->input, &info, agent) == LE_SUCCESS,
+        close(pfd); return -1, "[control_fd] Failed le_loop start watcher stdin read and write ptmx");
+    ret = SendCmdMessage(agent, type, cmd, ptsbuffer);
+    BEGET_ERROR_CHECK(ret == 0, close(pfd); return -1, "[control_fd] Failed send message");
     return 0;
 }
 
-void CmdClientInit(const char *socketPath, uint16_t type, const char *cmd, const char *fifoName)
+void CmdClientInit(const char *socketPath, uint16_t type, const char *cmd)
 {
     if ((socketPath == NULL) || (cmd == NULL)) {
         BEGET_LOGE("[control_fd] Invalid parameter");
     }
     BEGET_LOGI("[control_fd] CmdAgentInit");
-    int ret = CmdMakeFifoInit(fifoName);
-    BEGET_ERROR_CHECK(ret == 0, return, "[control_fd] Failed init fifo");
     CmdAgent *agent = CmdAgentCreate(socketPath);
     BEGET_ERROR_CHECK(agent != NULL, return, "[control_fd] Failed to create agent");
-    CmdAgentInit(agent->reader, g_FifoReadPath, true, ProcessFifoRead);
-    ret = SendCmdMessage(agent, type, cmd, fifoName);
-    BEGET_ERROR_CHECK(ret == 0, return, "[control_fd] Failed send message");
+    int ret = InitPtyInterface(agent, type, cmd);
+    if (ret != 0) {
+        return;
+    }
     LE_RunLoop(LE_GetDefaultLoop());
     BEGET_LOGI("Cmd Client exit ");
-    LE_CloseStreamTask(LE_GetDefaultLoop(), agent->task);
-    free(agent);
-    DestroyCmdFifo(g_FifoReadFd, g_FifoWriteFd, g_FifoReadPath, g_FifoWritePath);
 }

interfaces/innerkits/control_fd/control_fd_service.c

@@ -15,7 +15,9 @@
 #include <fcntl.h>
 #include <limits.h>
 #include <stdbool.h>
+#include <sys/ioctl.h>
 #include <sys/wait.h>
+#include <termios.h>
 #include <unistd.h>
 
 #include "beget_ext.h"
@@ -27,20 +29,12 @@ static CmdService g_cmdService;
 
 CallbackControlFdProcess g_controlFdFunc = NULL;
 
-static int ReadFifoPath(const char *name, bool read, pid_t pid, char *resolvedPath)
+static void OnClose(const TaskHandle task)
 {
-    if ((name == NULL) || (pid < 0) || resolvedPath == NULL) {
-        return -1;
-    }
-    int flag = read ? 1 : 0;
-    char path[PATH_MAX] = {0};
-    int ret = sprintf_s(path, sizeof(path) - 1, "/dev/fifo/%s%d.%d", name, flag, pid);
-    BEGET_ERROR_CHECK(ret > 0, return -1, "[control_fd] Failed sprintf_s err=%d", errno);
-    char *realPath = realpath(path, resolvedPath);
-    BEGET_ERROR_CHECK(realPath != NULL, return -1, "[control_fd] Failed get real path %s, err=%d", path, errno);
-    int flags = read ? (O_RDONLY | O_TRUNC | O_NONBLOCK) : (O_WRONLY | O_TRUNC);
-    int fd = open(resolvedPath, flags);
-    return fd;
+    CmdTask *agent = (CmdTask *)LE_GetUserData(task);
+    BEGET_ERROR_CHECK(agent != NULL, return, "[control_fd] Can not get agent");
+    OH_ListRemove(&agent->item);
+    OH_ListInit(&agent->item);
 }
 
 static void CmdOnRecvMessage(const TaskHandle task, const uint8_t *buffer, uint32_t buffLen)
@@ -48,33 +42,35 @@ static void CmdOnRecvMessage(const TaskHandle task, const uint8_t *buffer, uint3
     if (buffer == NULL) {
         return;
     }
+    CmdTask *agent = (CmdTask *)LE_GetUserData(task);
+    BEGET_ERROR_CHECK(agent != NULL, return, "[control_fd] Can not get agent");
+
     // parse msg to exec
     CmdMessage *msg = (CmdMessage *)buffer;
-    if ((msg->type < 0) || (msg->type >= ACTION_MAX) || (msg->cmd[0] == '\0') || (msg->fifoName[0] == '\0')) {
-        BEGET_LOGE("[control_fd] Failed msg ");
+    if ((msg->type < 0) || (msg->type >= ACTION_MAX) || (msg->cmd[0] == '\0') || (msg->ptyName[0] == '\0')) {
+        BEGET_LOGE("[control_fd] Received msg is invaild");
         return;
     }
-    char readPath[PATH_MAX] = {0};
-    int reader = ReadFifoPath(msg->fifoName, true, msg->pid, readPath); // read
-    BEGET_ERROR_CHECK(reader > 0, return, "[control_fd] Failed to open fifo read, err=%d", errno);
 
-    char writePath[PATH_MAX] = {0};
-    int writer = ReadFifoPath(msg->fifoName, false, msg->pid, writePath); // write
-    BEGET_ERROR_CHECK(writer > 0, return, "[control_fd] Failed to open fifo write, err=%d", errno);
-
-    pid_t pid = fork();
-    if (pid == 0) {
-        (void)dup2(reader, STDIN_FILENO);
-        (void)dup2(writer, STDOUT_FILENO);
-        (void)dup2(writer, STDERR_FILENO); // Redirect fd to 0, 1, 2
-        (void)close(reader);
-        (void)close(writer);
+    agent->pid = fork();
+    if (agent->pid == 0) {
+        OpenConsole();
+        char *realPath = GetRealPath(msg->ptyName);
+        BEGET_ERROR_CHECK(realPath != NULL, return, "Failed get realpath, err=%d", errno);
+        char *strl = strstr(realPath, "/dev/pts");
+        BEGET_ERROR_CHECK(strl != NULL, return, "pty slave path %s is invaild", realPath);
+        int fd = open(realPath, O_RDWR);
+        free(realPath);
+        BEGET_ERROR_CHECK(fd >= 0, return, "Failed open %s, err=%d", realPath, errno);
+        (void)dup2(fd, STDIN_FILENO);
+        (void)dup2(fd, STDOUT_FILENO);
+        (void)dup2(fd, STDERR_FILENO); // Redirect fd to 0, 1, 2
+        (void)close(fd);
         g_controlFdFunc(msg->type, msg->cmd, NULL);
         exit(0);
-    } else if (pid < 0) {
+    } else if (agent->pid < 0) {
         BEGET_LOGE("[control_fd] Failed fork service");
     }
-    DestroyCmdFifo(reader, writer, readPath, writePath);
     return;
 }
 
@@ -102,18 +98,20 @@ static int CmdOnIncommingConntect(const LoopHandle loop, const TaskHandle server
     TaskHandle client = NULL;
     LE_StreamInfo info = {};
     info.baseInfo.flags = TASK_STREAM | TASK_PIPE | TASK_CONNECT;
-    info.baseInfo.close = NULL;
-    info.baseInfo.userDataSize = sizeof(CmdAgent);
+    info.baseInfo.close = OnClose;
+    info.baseInfo.userDataSize = sizeof(CmdTask);
     info.disConntectComplete = NULL;
     info.sendMessageComplete = NULL;
     info.recvMessage = CmdOnRecvMessage;
     int ret = LE_AcceptStreamClient(LE_GetDefaultLoop(), server, &client, &info);
     BEGET_ERROR_CHECK(ret == 0, return -1, "[control_fd] Failed accept stream")
-    CmdAgent *agent = (CmdAgent *)LE_GetUserData(client);
+    CmdTask *agent = (CmdTask *)LE_GetUserData(client);
     BEGET_ERROR_CHECK(agent != NULL, return -1, "[control_fd] Invalid agent");
     agent->task = client;
+    OH_ListInit(&agent->item);
     ret = SendMessage(LE_GetDefaultLoop(), agent->task, "connect success.");
     BEGET_ERROR_CHECK(ret == 0, return -1, "[control_fd] Failed send msg");
+    OH_ListAddTail(&g_cmdService.head, &agent->item);
     return 0;
 }
 
@@ -123,6 +121,7 @@ void CmdServiceInit(const char *socketPath, CallbackControlFdProcess func)
         BEGET_LOGE("[control_fd] Invalid parameter");
         return;
     }
+    OH_ListInit(&g_cmdService.head);
     LE_StreamServerInfo info = {};
     info.baseInfo.flags = TASK_STREAM | TASK_SERVER | TASK_PIPE;
     info.server = (char *)socketPath;
@@ -135,3 +134,21 @@ void CmdServiceInit(const char *socketPath, CallbackControlFdProcess func)
     g_controlFdFunc = func;
     (void)LE_CreateStreamServer(LE_GetDefaultLoop(), &g_cmdService.serverTask, &info);
 }
+
+static int ClientTraversalProc(ListNode *node, void *data)
+{
+    CmdTask *info = ListEntry(node, CmdTask, item);
+    int pid = *(int *)data;
+    return pid - info->pid;
+}
+
+void CmdServiceProcessDelClient(pid_t pid)
+{
+    ListNode *node = OH_ListFind(&g_cmdService.head, (void *)&pid, ClientTraversalProc);
+    if (node != NULL) {
+        CmdTask *agent = ListEntry(node, CmdTask, item);
+        OH_ListRemove(&agent->item);
+        OH_ListInit(&agent->item);
+        LE_CloseTask(LE_GetDefaultLoop(), agent->task);
+    }
+}

services/begetctl/dump_service.c

@@ -29,7 +29,7 @@ static int main_cmd(BShellHandle shell, int argc, char **argv)
     }
     if (strcmp(argv[0], "dump_service") == 0) {
         printf("dump service info \n");
-        CmdClientInit(INIT_CONTROL_FD_SOCKET_PATH, ACTION_DUMP, argv[1], "FIFO");
+        CmdClientInit(INIT_CONTROL_FD_SOCKET_PATH, ACTION_DUMP, argv[1]);
     } else {
         BShellCmdHelp(shell, argc, argv);
     }

services/begetctl/modulectl.c

@@ -45,7 +45,7 @@ static int ModuleDisplayCmd(BShellHandle shell, int argc, char **argv)
         BShellCmdHelp(shell, argc, argv);
         return 0;
     }
-    CmdClientInit(INIT_CONTROL_FD_SOCKET_PATH, ACTION_MODULEMGR, argv[0], "FIFO");
+    CmdClientInit(INIT_CONTROL_FD_SOCKET_PATH, ACTION_MODULEMGR, argv[0]);
     return 0;
 }
 

services/begetctl/sandbox.cpp

@@ -128,7 +128,7 @@ static void RunCmd(const std::string &serviceName, const std::string &namespaceN
         EnterExec(processName);
     } else if (namespaceName.empty() && processName.empty() && !serviceName.empty()) {
         std::cout << "enter sandbox service name " << serviceName << std::endl;
-        CmdClientInit(INIT_CONTROL_FD_SOCKET_PATH, ACTION_SANDBOX, serviceName.c_str(), "FIFO");
+        CmdClientInit(INIT_CONTROL_FD_SOCKET_PATH, ACTION_SANDBOX, serviceName.c_str());
     } else {
         Usage();
     }

services/include/init_utils.h

@@ -75,6 +75,7 @@ int StringReplaceChr(char *strl, char oldChr, char newChr);
 int GetMapValue(const char *name, const InitArgInfo *infos, int argNum, int defValue);
 const InitArgInfo *GetServieStatusMap(int *size);
 uint32_t GetRandom(void);
+void OpenConsole(void);
 #ifdef __cplusplus
 #if __cplusplus
 }

services/init/init_common_service.c

@@ -117,24 +117,6 @@ static int SetPerms(const Service *service)
     return SERVICE_SUCCESS;
 }
 
-static void OpenConsole(void)
-{
-    const int stdError = 2;
-    setsid();
-    WaitForFile("/dev/console", WAIT_MAX_SECOND);
-    int fd = open("/dev/console", O_RDWR);
-    if (fd >= 0) {
-        ioctl(fd, TIOCSCTTY, 0);
-        dup2(fd, 0);
-        dup2(fd, 1);
-        dup2(fd, stdError); // Redirect fd to 0, 1, 2
-        close(fd);
-    } else {
-        INIT_LOGE("Open /dev/console failed. err = %d", errno);
-    }
-    return;
-}
-
 static int WritePid(const Service *service)
 {
     const int maxPidStrLen = 50;

services/init/standard/init_signal_handler.c

@@ -15,6 +15,7 @@
 #include <signal.h>
 #include <sys/wait.h>
 
+#include "control_fd.h"
 #include "init_adapter.h"
 #include "init_log.h"
 #include "init_param.h"
@@ -41,6 +42,7 @@ static void ProcessSignal(const struct signalfd_siginfo *siginfo)
                 if (WIFEXITED(procStat)) {
                     INIT_LOGE("Child process %d exit with code : %d", sigPID, WEXITSTATUS(procStat));
                 }
+                CmdServiceProcessDelClient(sigPID);
                 Service* service = GetServiceByPid(sigPID);
                 INIT_LOGI("SigHandler, SIGCHLD received, Service:%s pid:%d uid:%d status:%d.",
                     service == NULL ? "Unknown" : service->name,

services/utils/init_utils.c

@@ -23,6 +23,7 @@
 #include <pwd.h>
 #include <stdlib.h>
 #include <string.h>
+#include <sys/ioctl.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <time.h>
@@ -561,3 +562,23 @@ uint32_t GetRandom()
     close(fd);
     return ulSeed;
 }
+
+void OpenConsole(void)
+{
+#ifndef __LITEOS_M__
+    const int stdError = 2;
+    setsid();
+    WaitForFile("/dev/console", WAIT_MAX_SECOND);
+    int fd = open("/dev/console", O_RDWR);
+    if (fd >= 0) {
+        ioctl(fd, TIOCSCTTY, 0);
+        dup2(fd, 0);
+        dup2(fd, 1);
+        dup2(fd, stdError); // Redirect fd to 0, 1, 2
+        close(fd);
+    } else {
+        INIT_LOGE("Open /dev/console failed. err = %d", errno);
+    }
+    return;
+#endif
+}

test/unittest/BUILD.gn

@@ -163,6 +163,7 @@ ohos_unittest("init_unittest") {
     "//base/startup/init_lite/interfaces/innerkits/include/syspara",
     "//base/startup/init_lite/interfaces/innerkits/fd_holder",
     "//base/startup/init_lite/interfaces/innerkits/syspara",
+    "//base/startup/init_lite/interfaces/innerkits/control_fd",
     "//base/startup/init_lite/services/begetctl",
     "//base/startup/init_lite/services/begetctl/shell",
     "//base/startup/init_lite/services/include",