Linux进程控制：system() vs fork()+exec，安全性与灵活性的深度对比

system() 和 fork() + exec() 都是 Linux/Unix 中用于在程序中执行其他程序的常用方法，但它们在实现机制、使用场景、安全性和灵活性上有显著差异。作为程序员，了解这两种进程控制方式的异同，对于编写稳健、安全的代码至关重要。

相同点

• 目的：在程序中启动一个新程序。
• 进程关系：最终都会产生一个新的进程（通过 fork 创建子进程），在子进程中加载并执行目标程序。
• 父子进程：调用进程（父进程）与新程序（子进程）之间存在父子关系。

不同点

1. 实现机制

2. 灵活性与控制

3. 安全性

4. 返回值与错误处理

5. 性能

使用场景

• 使用 system()：
  • 执行简单的 Shell 命令（如 ls -l、cp a b），且无需精细控制。
  • 需要 Shell 通配符、管道、重定向等特性。
  • 对安全性和错误处理要求不高。
• 使用 fork() + exec()：
  • 需要精确控制子进程的输入输出、环境、参数。
  • 执行带用户输入的程序，避免命令注入。
  • 需要异步执行（不等待子进程）。
  • 编写守护进程、网络服务等需要精细管理子进程的场景。

示例对比

使用 system()

int system_cmdExec(const char *cmd)
{
    if (!cmd)
    {
        DEBUG_PRINT("error bad parameter");
        return -1;
    }

    if (0 == cmdBlackListCheck(cmd))
    {
        DEBUG_PRINT("cmd is illegal");
        return -1;
    }

    DEBUG_PRINT("run cmd:%s", cmd);

    int ret = 0;

    /* system() */
    ret = system(cmd);
    if ( 0 != ret)
    {
        DEBUG_PRINT("system():run cmd:%s failed, ret:%d[%d(%s)]", cmd, ret, errno, strerror(errno));
        return 0;
    }

    DEBUG_PRINT("run cmd:%s OK", cmd);

    return 0;
}

使用 fork() + exec()

int fork_exec_cmdExec(const char *cmd)
{
    sigset_t mask = {0};
    sigset_t oldMask = {0};
    struct sigaction ign = {0};
    struct sigaction oldInt = {0};
    struct sigaction oldQuit = {0};
    pid_t pid = 0;
    int status = 0;

    if (0 == cmdBlackListCheck(cmd))
    {
        DEBUG_PRINT("cmd is illegal");
        return -1;
    }

    /* check if shell is avalaible */
    if (!cmd)
    {
        DEBUG_PRINT("check if shell is available");

        if (access("/bin/sh", X_OK) == 0)
        {
            DEBUG_PRINT("shell is available");
            return 1;
        }
        else
        {
            DEBUG_PRINT("shell is not available");
            return 0;
        }
    }

    DEBUG_PRINT("run cmd:%s", cmd);

    /* signal process (keep it same with system()'s behavior) */
    /* 1. block SIGCHILD to prevents child processes from being
     * reclaimed by other signal handlers before waitpid
     */
    sigemptyset(&mask);
    sigaddset(&mask, SIGCHLD);
    sigprocmask(SIG_BLOCK, &mask, &oldMask);

    /* 2. Ignore SIGINT and SIGQUIT temporarily to prevent them
     * from breaking the parent process‘s wait
     */
    ign.sa_handler = SIG_IGN;
    sigemptyset(&ign.sa_mask);
    ign.sa_flags = 0;
    sigaction(SIGINT, &ign, &oldInt);
    sigaction(SIGQUIT, &ign, &oldQuit);

    /* create child */
    pid = fork();
    if (-1 == pid)
    {
        DEBUG_PRINT("create child failed, will restore signal set");
        status = 1;
        goto restore;
    }

    if (0 == pid)
    {
        /* child */
        /* Restores the signal mask and handler set before the parent
         * process (the child process inherits a copy of the parent process)
         */
        sigprocmask(SIG_SETMASK, &oldMask, NULL);
        sigaction(SIGINT, &oldInt, NULL);
        sigaction(SIGQUIT, &oldQuit, NULL);

        /* create array of parameters */
        char *argv[] = {"sh", "-c", (char *)cmd, NULL};
        execve("/bin/sh", argv, environ);

        /* if exec failed, child exit and report error */
        DEBUG_PRINT("execve failed");
        _exit(127);/* typical error code f shell cannot execute */
    }

    /* parent process: wait child finish */
    while (waitpid(pid, &status, 0) == -1)
    {
        if (EINTR != errno)
        {
            /* no EINTR error, exit loop */
            DEBUG_PRINT("no EINTR error, exit loop");
            status = -1;
            break;
        }

        /* if ENTIR, continue to wait */
        DEBUG_PRINT("EINTR error, continue wait");
    }

    DEBUG_PRINT("run cmd:%s OK", cmd);

restore:
    /* restore original signal */
    sigaction(SIGINT, &oldInt, NULL);
    sigaction(SIGQUIT, &oldQuit, NULL);
    sigprocmask(SIG_SETMASK, &oldMask, NULL);

    if (-1 == status)
    {
        return -1;
    }

    /* analyze child exit status, keep it same with system()‘s */
    if (WIFEXITED(status))
    {
        return WEXITSTATUS(status);
    }
    else if (WIFSIGNALED(status))
    {
        return 128 + WTERMSIG(status);
    }
    else
    {
        /* if child terminated (e.g. receive SIGSTOP), system() will not occur, but to be complete  */
        return -1;
    }

    return 0;
}

总结

• system() 是一个便捷但受限的封装，适合执行简单命令，但存在安全风险和较低灵活性。
• fork() + exec() 是底层、灵活、安全的组合，允许对进程创建和执行进行全面控制，但需要开发者编写更多代码并处理更多细节。

选择哪个取决于具体需求：如果需要快速执行一条 Shell 命令且不关心细节，用 system()；如果需要精细控制、安全性或异步执行，用 fork() + exec()。掌握这些C语言函数的底层原理，能帮助你在实际开发中做出更优的选择。如果你对更多系统编程的实战经验感兴趣，欢迎到 云栈社区 交流探讨。