【实战指南】从零构建嵌入式远程Shell，提升跨地域协作效率（2）

[TOC]

引言

  之前曾发布过一篇关于构建嵌入式远程Shell的文章，详细介绍了基础版本的实现方法，详见【实战指南】从零构建嵌入式远程Shell。然而，该版本在功能性和稳定性方面还有待提升。本文将在此基础上进行改进和优化，进一步完善远程Shell的功能。

概述

  本次改进主要集中在模块化设计与功能增强上。模块化方面，我们将系统拆分为LogManager和ShellEnv两个独立的类，以提高代码的可维护性和复用性。在功能上，新增了对阻塞命令的支持以及提供用户主动结束Shell进程的能力等。

优化策略

  在第一版代码中，由于功能较为简单，未采用模块化设计；同时，其实现也相对单一，仅支持非阻塞命令的执行。基于此，第二版实现中增加了以下功能：

• 将代码按功能拆分为LogManager和ShellEnv两个模块。前者专注于远程交互，后者负责shell命令的执行。
• 支持非阻塞及阻塞命令的执行，并能准确回传命令回执打印。
• 增加交互日志，以便更好地追踪和记录操作过程。

详细设计

  将远程Shell拆解为LogManager和ShellEnv两大模块。其中，LogManager负责与远端的连接、shell进程管理等；而ShellEnv则专注于Shell命令的执行及其回执输出。

1. LogManager
   LogManager 主要负责与远程端口的连接以及 shell 进程的管理功能。具体职责包括：

   ① 建立TCP连接。目前仅支持作为TCP服务端运行，允许远程客户端以客户端模式接入并输入指令。
   ② 解析远程指令。接收来自远程客户端的指令字节流，解析并判断其是否属于内建指令。
   ③ 增加内建指令集。增加一系列与RShellX使用相关的内建指令，提升工具的易用性和功能性。
   ④ 触发指令执行。对于内建指令直接进行处理；而对于其他外部命令，则交由ShellEnv模块执行。
   ⑤ 回收Shell进程。通过注册SIGCHLD信号处理函数，自动回收已完成任务的Shell子进程，确保系统资源的有效管理。

class LoginManager
{
public:
    LoginManager();
    ~LoginManager();
    static LoginManager* GetInstance();

    int Init();
    int BuildConnectAsTcpServer(short port);
    int ConnectLoop();

private:
    int Usage();
    int ExitShell();
    int ExitAll();
    int WriteStdin(const std::string& buf);
    int RegisterSignal();
    int ListenPipeEvent(int pipeFd);
    int ExecuteCmd(std::string& cmdBytes);
    // int Login(const char* username, const char* password);
    // int Logout();

private:
    bool mIsLogin;
    pid_t mCurPid;
    static pid_t mShellPid;
    int mStdin;
    int mStdout;
    int mStderr;
    int mInPipe[2];
    int mOutPipe[2];
    std::shared_ptr<PPipe> mPipePtr;
    std::shared_ptr<PSocket> mTcpSrvPtr;
    std::list<std::shared_ptr<PSocket>> mTcpClients;
};

从 LogManager 的接口设计，亦可以非常直观地理解其承担的主要职责。其中，一些细节的实现如下记录：

• BuildConnectAsTcpServer
  当接收到客户端成功接入时，需如下处理：
  ① 将服务端socket文件描述符fd，通过dup2重定向至标准输入（stdin），确保从客户端接收的数据可以直接作为输入被处理。
  ② 将客户端socket文件描述符fd，通过dup2重定向至标准输出（stdout），确保终端回执能够直接传输至客户端。
  ③ 向客户端发送接入欢迎应答。

int LoginManager::BuildConnectAsTcpServer(short port)
{
    auto pEpoll = EpollEventHandler::GetInstance();
    mTcpSrvPtr = make_shared<PSocket>(AF_INET, SOCK_STREAM, 0, [&](int cli, void *arg) {
        PSocket* pSrvObj = (PSocket*)arg;
        if (pSrvObj == nullptr) {
            SPR_LOGE("PSocket is nullptr\n");
            return;
        }

        auto tcpClient = make_shared<PSocket>(cli, [&](int sock, void *arg) {
            PSocket* pCliObj = (PSocket*)arg;
            if (pCliObj == nullptr) {
                SPR_LOGE("PSocket is nullptr\n");
                return;
            }

            std::string rBuf;
            int rc = pCliObj->Read(sock, rBuf);
            if (rc <= 0) {
                mTcpClients.remove_if([sock, pEpoll, pCliObj](shared_ptr<PSocket>& v) {
                    pEpoll->DelPoll(pCliObj);
                    return (v->GetEpollFd() == sock);
                });
                return;
            }

            // SPR_LOGD("# RECV [%d]> %s shellpid = %d\n", sock, rBuf.c_str(), mShellPid);
            ExecuteCmd(rBuf);
        });

        tcpClient->AsTcpClient();
        pEpoll->AddPoll(tcpClient.get());
        mTcpClients.push_back(tcpClient);
        dup2(mTcpSrvPtr->GetEpollFd(), STDIN_FILENO);
        dup2(tcpClient->GetEpollFd(), STDOUT_FILENO);
        dup2(tcpClient->GetEpollFd(), STDERR_FILENO);

        const string welcomes = "Welcome to RShellX! >_<\n";
        if (write(STDOUT_FILENO, welcomes.c_str(), welcomes.size()) < 0) {
            SPR_LOGE("# Write welcome failed! %s", strerror(errno));
        }
    });

    mTcpSrvPtr->AsTcpServer(port, 5);
    pEpoll->AddPoll(mTcpSrvPtr.get());
    return 0;
}

• ExecuteCmd
  当接收到客户端发送来的字符串时，需如下处理：
  ① 去除多余"\r\n"。确保指令格式正常。
  ② 判断是否为内建指令。是内建指令直接处理并返回处理回执。
  ③ 不为内建指令。交由ShellEnv处理。

int LoginManager::ExecuteCmd(string& cmdBytes)
{
    cmdBytes.erase(std::find_if(cmdBytes.rbegin(), cmdBytes.rend(), [](unsigned char ch) {
        return ch != '\r' && ch != '\n';
    }).base(), cmdBytes.end());

    if (cmdBytes == "Quit" || cmdBytes == "Ctrl C" || cmdBytes == "Ctrl Q") {
        return ExitShell();
    } else if (cmdBytes == "Quit all") {
        return ExitAll();
    } else if (cmdBytes == "Help" || cmdBytes == "help" || cmdBytes == "?") {
        return Usage();
    }

    // 上一个命令未执行完，输入作为参数传入上一个命令
    if (mShellPid > 0) {
        SPR_LOGD("Last shell %d is running, send [%s] as parameter\n", mShellPid, cmdBytes.c_str());
        // int rc = write(mInPipe[1], cmdBytes.c_str(), cmdBytes.size());
        // if (rc > 0) {
        //     SPR_LOGD("# SEND [%d]> %s\n", mInPipe[1], cmdBytes.c_str());
        // }
        return 0;
    }

    ShellEnv shellEnv(mInPipe[0], mOutPipe[1], mOutPipe[1]);
    mShellPid = shellEnv.Execute(cmdBytes);
    return 0;
}

• RegisterSignal
  通过监听SIGCHLD, 及时回收已经结束的子进程资源。

int LoginManager::RegisterSignal()
{
    signal(SIGCHLD, [](int) {
        pid_t pid;
        int status;
        while ((pid = waitpid(-1, &status, WNOHANG)) > 0) {
            mShellPid = -1;
            SPR_LOGD("Shell [%d] exit!\n", pid);
        }
    });
    return 0;
}

2. ShellEnv
   ShellEnv的功能比较简单，即创建子进程，并执行shell指令。

class ShellEnv
{
public:
    explicit ShellEnv(int inFd, int outFd, int errFd);
    ~ShellEnv();

    int Execute(const std::string& cmd);
};

ShellEnv 中的 Execute 方法用于执行 shell 命令，其实现如下：

• Execute
  ① 解析命令字符串：首先查找命令字符串中的空格位置，分离出命令名称和参数。然后将整个命令字符串按空格分割成多个参数，存储在一个 std::vector<std::string> 中。
  ② 创建子进程：通过 fork() 创建一个子进程。在子进程中，使用 execvp 函数执行指定的 shell 命令。execvp 会接管子进程，用新的程序替换当前进程的镜像。
  ③ 错误处理：如果 execvp 执行失败，会记录错误信息并通过 _exit 退出子进程，返回一个失败状态码。
  ④ 父进程记录：父进程记录子进程的 PID 和执行的命令，便于后续管理和日志记录。

int ShellEnv::Execute(const std::string& cmd)
{
    size_t pos = cmd.find(' ');
    std::string cmdName = cmd.substr(0, pos);
    std::vector<std::string> tmpArgs = GeneralUtils::Split(cmd, ' ');
    char* args[tmpArgs.size() + 1];
    args[tmpArgs.size()] = nullptr;
    for (size_t i = 0; i < tmpArgs.size(); i++) {
        args[i] = const_cast<char*>(tmpArgs[i].c_str());
    }

    pid_t pid = fork();
    if (pid == 0) {
        int rc = execvp(cmdName.c_str(), args);
        if (rc < 0) {
            SPR_LOGE("execlp failed: %s\n", strerror(errno));
        }
        _exit(EXIT_FAILURE);
    } else {
        SPR_LOGD("ppid = %d, cpid = %d cmd: %s\n", getpid(), pid, cmd.c_str());
    }

    return pid;
}

验证

准备三个终端输入窗口，方便调试验证。

• 终端1
  启动RShellX程序

$ ./rshellx 8080

• 终端2
  Windows平台使用网络助手创建tcp客户端连接RShellX，并输入Shell命令验证反馈。
  ① 建立tcp客户端，连接RShellX。
  ② 输入touch test.log，创建文件test.log。
  ③ 输入tail -f test.log，并执行终端③行为（向test.log写入数据），观察当前终端输出。
  ④ 输入Quit，结束tail子进程。输入lsb_release -a，观察输出。

tcp客户端

• 终端3
  实时向test.log尾部实时增加内容，观察终端2打印情况。

$ echo "Hello" >> test.log
$ echo "I'm kangkang" >> test.log
$ echo "What's your name?" >> test.log

• 结论
  通过上述验证，确认：
  ① TCP 客户端能够正常使用阻塞命令tail。
  ② 输入Quit结束tail阻塞子进程后。输入lsb_release -a ，能够正常执行。

总结

• 本次改进的主要特点是将之前的“单进程 + popen” 实现方式，优化为“多进程 + execvp”的方式。多进程模式便于管理 shell 执行的子进程，而 execvp 则简化了命令输出的重定向。
• 实现后，即使在非Linux平台一样能够使用Shell指令调试目标设备，还是比较方便的。
• 当前实现仍存在许多优化空间：
  例如不能与命令交互，像gdb这种运行过程需要终端输入的，目前还不能支持；
  shell回显的方式可以优化为与shell一致，增加当前权限和路径；
  另外，向cd这类非可执行文件的命令，目前也无法支持。诸如此类问题，后续版本慢慢改进。