Three Methods to Execute External Programs in C on Linux: From system() to fork-execve

Introduction

In Linux system programming, C programs often need to invoke external executables to accomplish specific tasks. For example, a data processing program might call specialized tools to generate intermediate files before proceeding with further processing. This requirement is particularly common in system tool development, automation scripts, and modular software. Based on practical programming problems, this article systematically introduces three methods for executing external programs in C, each with its applicable scenarios and considerations.

Using the system() Function

The most straightforward approach is using the system() function from the standard library, declared in the <stdlib.h> header. system() invokes the system shell to execute the specified command string and waits for completion before returning a status value. For instance, to execute the foo program in the current directory with arguments 1, 2, and 3, you can write:

#include <stdlib.h>

int main() {
    int status = system("./foo 1 2 3");
    // Subsequent processing
    return 0;
}

The return value of system() contains exit status information of the called program. On Linux systems, the child process's exit code is multiplied by 256 and stored in the return value. Therefore, to obtain the actual exit code, execute int exitcode = status / 256. A more professional approach is to use macros related to the wait() system call to examine the status, such as WIFEXITED to check if the program exited normally and WEXITSTATUS to extract the exit code. These macros are defined in <sys/wait.h>; detailed documentation can be viewed via the man 2 wait command.

When needing to read the external program's output, system() becomes less flexible. In such cases, consider using the popen() function, which creates a pipe and starts a process, returning a file pointer that allows the parent process to interact with the child's standard input/output like reading from or writing to a file. For example:

FILE *fp = popen("./foo 1 2 3", "r");
if (fp) {
    char buffer[1024];
    while (fgets(buffer, sizeof(buffer), fp) != NULL) {
        // Process output
    }
    pclose(fp);
}

Although system() is simple to use, it relies on the system shell and may pose security risks. If the command string includes user input or untrusted data, it could lead to shell injection attacks. Thus, in security-sensitive contexts, more controlled methods are necessary.

Implementing Secure Execution with fork() and execve()

To avoid the security issues of system() and achieve finer process control, the combination of fork() and execve() can be used. This method executes programs directly through system calls without shell interpretation, thereby preventing injection vulnerabilities. The core steps are: first call fork() to create a child process, then in the child process call execve() to load and execute the target program, while the parent process waits for the child to finish using waitpid().

Parameter passing is crucial in this method. You need to construct an argument array where the first element is typically the program path, followed by each argument, and ending with a NULL pointer. For example:

const char *argv[] = {"./foo", "1", "2", "3", NULL};

Below is a complete execution function example demonstrating how to safely execute an external program and check its status:

#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <stdio.h>
#include <stdlib.h>

static int execute_program(const char **argv) {
    pid_t pid;
    int status;

    pid = fork();
    if (pid == -1) {
        perror("fork failed");
        return -1;
    }

    if (pid == 0) {
        // Child process
        execve(argv[0], (char **)argv, NULL);
        perror("execve failed");
        exit(EXIT_FAILURE);
    } else {
        // Parent process
        if (waitpid(pid, &status, 0) == -1) {
            perror("waitpid failed");
            return -1;
        }

        if (WIFEXITED(status)) {
            printf("Program exited with code: %d\n", WEXITSTATUS(status));
            return WEXITSTATUS(status);
        } else {
            printf("Program terminated abnormally\n");
            return -1;
        }
    }
}

int main() {
    const char *argv[] = {"./foo", "1", "2", "3", NULL};
    int result = execute_program(argv);
    // Handle subsequent logic based on result
    return 0;
}

Although this method involves more code, it provides complete control. You can customize environment variables, redirect standard input/output, set process groups, etc. Note that execve() does not return upon successful execution; it only returns -1 on failure. Therefore, the child process typically calls exit() directly after execve() to handle errors.

Asynchronous Execution: Combining fork() with system()

In some scenarios, the main program does not need to wait for the external program to complete but wishes to continue with other tasks. Here, fork() can be combined with system() to achieve asynchronous execution. The basic idea is: call system() in the child process to execute the external program, while the parent process returns immediately to continue execution.

Example code:

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

int main() {
    pid_t pid = fork();
    
    if (pid == 0) {
        // Child process
        printf("Child process executing external program...\n");
        int status = system("./foo 1 2 3");
        exit(0);
    } else if (pid > 0) {
        // Parent process
        printf("Parent process continues...\n");
        // Main program continues with other tasks
    } else {
        perror("fork failed");
        return 1;
    }

    printf("Main program executing concurrently.\n");
    return 0;
}

This method simply implements background execution but requires attention to zombie process handling. If the parent process does not care about the child's termination status, it should set signal handling to ignore SIGCHLD or call a non-blocking version of waitpid() periodically for cleanup. Otherwise, unreaped child processes become zombies, consuming system resources.

Method Comparison and Selection Guidelines

Each method has its advantages and disadvantages: system() is simplest, suitable for quick prototyping and simple tasks but carries security risks; fork() and execve() are safest and most controllable, ideal for production environments and scenarios requiring fine-grained control; combining fork() with system() enables asynchronous execution, fitting situations where the main program should not block.

Selection should consider factors such as security requirements, need for communication with the child process, platform compatibility (system() is a standard C function, while fork() and execve() are POSIX standards), performance overhead (fork() involves process duplication), etc. In practical development, it is recommended to prioritize fork() and execve() unless there are explicit simplification needs or cross-platform considerations.

Conclusion

Executing external programs in C on Linux is a common yet delicate task. This article details three mainstream methods, from the simple system() to the secure fork()-execve() combination, and variants for asynchronous execution. Each method is illustrated with code examples highlighting core usage and considerations. Developers should choose appropriate methods based on specific needs, especially avoiding direct use of system() with untrusted input in security-sensitive applications. Proper understanding of these techniques not only enhances program security but also improves control over system resources.