9

我有一个包含要使用 execv 执行的命令的 std::string，将其转换为 execv() 的第二个参数所需的“char *argv[]”的最佳“C++”方法是什么？

澄清：

std::string cmd = "mycommand arg1 arg2";
char *cmd_argv[];

StrToArgv(cmd, cmd_argv); // how do I write this function?

execv(cmd_argv[0], cmd_argv);
4

10 回答 10

11

这里非常不统一的答案。有什么问题：

std::string cmd = "echo hello world";
execl("/bin/sh", "/bin/sh", "-c", cmd.c_str(), NULL);

当系统上已经有一个非常好的解析器时，为什么还要编写一个命令行解析器呢？

（注意：一个很好的理由是因为你不相信你将要执行的字符串。人们希望这已经是真的了，但是 shell 会比一个天真的空格分割器做更多的事情，因此如果您不小心，会打开更多安全漏洞。）

于 2009-10-02T21:23:39.267 回答
5 
std::vector<char *> args;
std::istringstream iss(cmd);

std::string token;
while(iss >> token) {
  char *arg = new char[token.size() + 1];
  copy(token.begin(), token.end(), arg);
  arg[token.size()] = '\0';
  args.push_back(arg);
}
args.push_back(0);

// now exec with &args[0], and then:

for(size_t i = 0; i < args.size(); i++)
  delete[] args[i];

当然，这不适用于使用引用 like 的命令rm "a file.mp3"。您可以考虑wordexp关心这一点的 POSIX 函数等等。

于 2009-10-02T21:27:30.527 回答
2

c_str() 字符串方法和 strtok() 的组合用空格将其拆分应该可以得到需要传递给 exec() 及其相关函数的字符串数组。

于 2009-10-02T21:15:28.567 回答
2

也许split_winmain来自 Boost.ProgramOptions。在大多数情况下，Boost 是一个不错的选择。 http://www.boost.org/doc/libs/1_40_0/doc/html/program_options/howto.html#id1396212

如果您只对 Windows 感兴趣（其他内核通常不了解 Windows 意义上的命令行），您可以使用CommandLineToArgvW与 MS C 运行时使用相同约定的 API 函数。

一般来说，它取决于平台和/或外壳的引用风格。Microsoft C 运行时使用与 bash 等完全不同的风格！

于 2009-10-02T21:16:37.280 回答
1

这是 litb 答案的变体，但没有所有手动内存分配。它仍然无法处理引用。

#include <vector>
#include <string>
#include <sstream>

std::string cmd = "mycommand arg1 arg2";
std::istringstream ss(cmd);
std::string arg;
std::list<std::string> ls;
std::vector<char*> v;
while (ss >> arg)
{
   ls.push_back(arg); 
   v.push_back(const_cast<char*>(ls.back().c_str()));
}
v.push_back(0);  // need terminating null pointer

execv(v[0], &v[0]);

我觉得 const_cast<> 有点脏，但程序真的不应该修改 argv 字符串的内容。

于 2009-10-03T01:24:31.773 回答
1

好的，我自己已经为此绊倒了很多次。这是直接的“C”，因此可以插入 C 或 C++。它以不同的方式处理单引号和双引号字符串。调用者负责释放 argv[0]（如果不是 NULL）和 argv。

#include 
#include 
#include 
#include 

typedef enum {
    STR2AV_OK       = 0,
    STR2AV_UNBALANCED_QUOTE
} str_to_argv_err_t;

#ifndef NUL
#define NUL '\0'
#endif

static char const nomem[] = "no memory for %d byte allocation\n";

static str_to_argv_err_t
copy_raw_string(char ** dest_p, char ** src_p);

static str_to_argv_err_t
copy_cooked_string(char ** dest_p, char ** src_p);

static inline void *
Xmalloc(size_t sz)
{
    void * res = malloc(sz);
    if (res == NULL) {
        fprintf(stderr, nomem, sz);
        exit(EXIT_FAILURE);
    }
    return res;
}

static inline void *
Xrealloc(void * ptr, size_t sz)
{
    void * res = realloc(ptr, sz);
    if (res == NULL) {
        fprintf(stderr, nomem, sz);
        exit(EXIT_FAILURE);
    }
    return res;
}

str_to_argv_err_t
string_to_argv(char const * str, int * argc_p, char *** argv_p)
{
    int     argc = 0;
    int     act  = 10;
    char ** res  = Xmalloc(sizeof(char *) * 10);
    char ** argv = res;
    char *  scan;
    char *  dest;
    str_to_argv_err_t err;

    while (isspace((unsigned char)*str))  str++;
    str = scan = strdup(str);

    for (;;) {
        while (isspace((unsigned char)*scan))  scan++;
        if (*scan == NUL)
            break;

        if (++argc >= act) {
            act += act / 2;
            res  = Xrealloc(res, act * sizeof(char *));
            argv = res + (argc - 1);
        }

        *(argv++) = dest = scan;

        for (;;) {
            char ch = *(scan++);
            switch (ch) {
            case NUL:
                goto done;

            case '\\':
                if ( (*(dest++) = *(scan++)) == NUL)
                    goto done;
                break;

            case '\'':
                err = copy_raw_string(&dest, &scan);
                if (err != STR2AV_OK)
                    goto error_leave;
                break;

            case '"':
                err = copy_cooked_string(&dest, &scan);
                if (err != STR2AV_OK)
                    goto error_leave;
                break;

            case ' ':
            case '\t':
            case '\n':
            case '\f':
            case '\r':
            case '\v':
            case '\b':
                goto token_done;

            default:
                *(dest++) = ch;
            }
        }

    token_done:
        *dest = NUL;
    }

done:

    *argv_p = res;
    *argc_p = argc;
    *argv   = NULL;
    if (argc == 0)
        free((void *)str);

    return STR2AV_OK;

error_leave:

    free(res);
    free((void *)str);
    return err;
}

static str_to_argv_err_t
copy_raw_string(char ** dest_p, char ** src_p)
{
    for (;;) {
        char ch = *((*src_p)++);

        switch (ch) {
        case NUL: return STR2AV_UNBALANCED_QUOTE;
        case '\'':
            *(*dest_p) = NUL;
            return STR2AV_OK;

        case '\\':
            ch = *((*src_p)++);
            switch (ch) {
            case NUL:
                return STR2AV_UNBALANCED_QUOTE;

            default:
                /*
                 * unknown/invalid escape.  Copy escape character.
                 */
                *((*dest_p)++) = '\\';
                break;

            case '\\':
            case '\'':
                break;
            }
            /* FALLTHROUGH */

        default:
            *((*dest_p)++) = ch;
            break;
        }
    }
}

static char
escape_convt(char ** src_p)
{
    char ch = *((*src_p)++);

    /*
     *  Escape character is always eaten.  The next character is sometimes
     *  treated specially.
     */
    switch (ch) {
    case 'a': ch = '\a'; break;
    case 'b': ch = '\b'; break;
    case 't': ch = '\t'; break;
    case 'n': ch = '\n'; break;
    case 'v': ch = '\v'; break;
    case 'f': ch = '\f'; break;
    case 'r': ch = '\r'; break;
    }

    return ch;
}


static str_to_argv_err_t
copy_cooked_string(char ** dest_p, char ** src_p)
{
    for (;;) {
        char ch = *((*src_p)++);
        switch (ch) {
        case NUL: return STR2AV_UNBALANCED_QUOTE;
        case '"':
            *(*dest_p) = NUL;
            return STR2AV_OK;

        case '\\':
            ch = escape_convt(src_p);
            if (ch == NUL)
                return STR2AV_UNBALANCED_QUOTE;
            /* FALLTHROUGH */

        default:
            *((*dest_p)++) = ch;
            break;
        }
    }
}
于 2010-04-02T19:39:18.853 回答
0

您可以使用 std::string 的 c_str() 函数转换为 char*。strtok 函数将使用 ' ' 分隔符拆分字符串。

于 2009-10-02T21:14:03.193 回答
0

Matt Peitrek 的LIBTINYC有一个名为 argcargv.cpp 的模块，它接受一个字符串并将其解析为参数数组，同时考虑引用的参数。请注意，它是特定于 Windows 的，但它非常简单，因此应该很容易移动到您想要的任何平台。

如果你这样做，也将其更改为将放置计数的位置和指向 argv 数组的指针作为参数，而不是使用 externs（只是我的一点建议）。Matt 不需要它，因为 LIBTINYC是运行时。

或者，您可以查看编译器的运行时源代码（几乎都提供它）以查看它们如何解析命令行并直接调用它（如果结果证明可行）或从那段代码中借用想法。

于 2009-10-02T21:28:02.270 回答
0

回答这个问题可能为时已晚，但您可以使用标准 POSIX 函数glob或wordexp：

#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <wordexp.h>

int
main(int argc, char **argv)
{
   wordexp_t p;
   char *exec_path = "/bin/ls";

   p.we_offs = 1;
   wordexp("-l -t /etc", &p, WRDE_DOOFFS);
   p.we_wordv[ 0 ] = exec_path;
   execv(exec_path, p.we_wordv);

   /* This code is unreachable */
   exit(EXIT_SUCCESS);
}

它将准备 3 个参数：（-l长列表格式）、-t（按修改时间排序）和/etc要列出的目录，然后运行/bin/ls​​. Callwordexp()为您提供与之前推荐的 call 完全相同的结果，/bin/sh -c但生成的进程将没有父进程/bin/sh。

于 2016-11-16T21:14:05.200 回答
0

事实证明，为此在 boost 程序选项中存在某种隐藏的功能。split_unix() 函数适用于转义和引用的命令行。

#include "boost/program_options/parsers.hpp"


auto parts = boost::program_options::split_unix(commandLine);
std::vector<char*> cstrings ;
for(auto& str : parts){
    cstrings.push_back(const_cast<char*> (str.c_str()));
}

int argc = (int)cstrings.size();
char** argv = cstrings.data();
于 2018-10-31T18:02:41.833 回答