在现代软件开发中，执行系统命令是一项常见的需求，无论是自动化脚本、系统管理工具，还是需要调用外部程序的复杂应用程序，都离不开对系统命令的调用。然而，直接使用系统调用（如 execve）虽然简单，但存在诸多问题，例如安全性不足、灵活性差以及可维护性低等。为了克服这些问题，我们可以通过封装命令执行逻辑，设计一个自定义的命令执行器。本文将深入探讨如何在 C++ 中实现一个安全、灵活且易于管理的命令执行器。

一、背景与动机

在许多应用程序中，执行系统命令是一项常见需求。例如，自动化脚本、系统管理工具或需要调用外部程序的复杂应用程序。然而，直接使用系统调用（如 execve）存在以下问题：

安全性问题：直接拼接命令字符串可能导致命令注入攻击。
灵活性不足：系统调用通常需要手动管理参数和环境变量，容易出错。
可维护性差：直接调用系统调用的代码通常难以阅读和维护。
为了解决这些问题，我们设计了一个自定义的命令执行器包装器，通过封装命令执行逻辑，提供更安全、灵活且易于管理的接口。

二、设计与实现

1. 命令执行器类的设计

命令执行器的核心是一个 command 类，它封装了命令名称、参数列表和环境变量。以下是 command 类的主要设计：
类定义

class command
{
public:
    command(const std::string cmd, const std::vector<std::string>& arguments, const environ_map& envs = environ_map());
    command(const command&) = default;
    command(command&&) = default;

    command& operator=(const command&) = default;
    command& operator=(command&&) = default;

    ~command() = default;

    void exec();

private:
    std::string m_cmd;
    std::vector<std::string> m_arguments;
    environ_map m_envs;
};

构造函数
构造函数接受命令名称、参数列表和环境变量。其中，环境变量通过 environ_map 类型传递，这是一个自定义的环境变量映射类，支持从当前进程环境变量初始化。
执行逻辑
exec() 方法是命令执行的核心。它使用 execve 系统调用执行命令，同时处理参数和环境变量的转换。为了安全地管理动态分配的内存，我们使用 std::shared_ptr 来管理参数数组。

2. 参数和环境变量的处理

为了将参数列表和环境变量转换为 execve 所需的格式，我们设计了以下辅助函数：
参数转换

std::shared_ptr<char*> to_argv(const std::string& cmd, const std::vector<std::string>& vec)
{
    char **argv = new char*[vec.size() + 2];
    argv[0] = ::strdup(cmd.c_str());
    for(size_t i = 0 ; i < vec.size(); ++i)
        argv[i+1] = ::strdup(vec[i].c_str());

    argv[vec.size()+1] = nullptr;

    return std::shared_ptr<char*>(argv, argv_deleter);
}

环境变量转换
environ_map 类提供了一个 raw() 方法，将环境变量映射转换为 execve 所需的格式。它使用 动态分配内存，并通过自定义的 raw_environ_holder 类管理内存生命周期。

3. 环境变量管理

environ_map 类是一个封装了环境变量的映射类，支持从当前进程环境变量初始化，并提供安全的内存管理机制。以下是其主要实现：
环境变量映射

class environ_map : public std::map<std::string, std::string>
{
public:
    environ_map() = default;
    environ_map(const std::map<std::string, std::string>& map) : std::map<std::string, std::string>(map) {};
    environ_map(const environ_map&) = default;
    raw_environ_holder raw() const;

    static environ_map get_for_current_process();
};

从当前进程环境变量初始化

environ_map environ_map::get_for_current_process()
{
    environ_map result;

    int i = 0;
    while(environ[i])
    {
        std::string str(environ[i++]);
        size_t indx = str.find('=');
        if(indx == std::string::npos)
            throw std::runtime_error("Failed to parse env");

        result[str.substr(0, indx)] = str.substr(indx +1);
    }

    return result;
}

三、自定义命令执行器的包装器：实现与应用（C/C++实现）

展示如何使用自定义的命令执行器：
cpp复制

#include "command.h"
#include "environ_map.h"

class command
{
public:
    command(const std::string cmd, const std::vector<std::string>& arguments, const environ_map& envs = environ_map());
    command(const command&) = default;
    command(command&&) = default;

    command& operator=(const command&) = default;
    command& operator=(command&&) = default;

    ~command() = default;

    void exec();

private:
    std::string m_cmd;
    std::vector<std::string> m_arguments;
    environ_map m_envs;
};

...
class raw_environ_holder
{
public:
    raw_environ_holder() = delete;
    raw_environ_holder(const raw_environ_holder&) = delete;
    raw_environ_holder(raw_environ_holder&&);

    raw_environ_holder& operator=(const raw_environ_holder&) = delete;
    raw_environ_holder& operator=(raw_environ_holder&&);

    ~raw_environ_holder();

    operator char**() { return ppenv;};

private:
    friend class environ_map;

    explicit raw_environ_holder(char** ppenv) : ppenv(ppenv){};

    void destroy();

    char** ppenv;
};


class environ_map : public std::map<std::string, std::string>
{
public:
    environ_map() = default;
    environ_map(const std::map<std::string, std::string>& map) : std::map<std::string, std::string>(map) {};
    environ_map(const environ_map&) = default;
    raw_environ_holder raw() const;

    static environ_map get_for_current_process();
};

...
int main()
{
    // 获取当前进程的环境变量
    environ_map m = environ_map::get_for_current_process();
    for(const auto& p: m)
    {
        std::cout << p.first << "=" << p.second << std::endl;
    }

    // 创建并执行命令
    command cmd("/bin/ls", std::vector<std::string>());
    cmd.exec();
}

我们首先获取当前进程的环境变量，然后创建一个 command 对象来执行 /bin/ls 命令。通过封装命令执行逻辑，代码更加清晰且易于维护。

If you need the complete source code, please add the WeChat number (c17865354792)

四、优势与总结

通过实现自定义命令执行器，我们可以更加灵活和安全地执行系统命令。上述实现不仅支持环境变量的设置和传递多个参数，还能够处理执行过程中的错误，并提供输出捕获的功能。这种封装方式使得命令执行变得更加简洁和易于维护，同时也提高了代码的安全性和可读性。未来，我们可以进一步扩展该执行器，添加更多的功能，如异步执行、超时控制等，以满足更多复杂的需求。

Welcome to follow WeChat official account【程序猿编码】