Execvp in C/C++

Mit execvp ist ein Programm in der Lage, Sys­tem­kom­man­dos wie das Starten von An­wen­dun­gen oder das Ausführen von Sys­tem­diens­ten zu in­iti­ie­ren. In Kom­bi­na­ti­on mit der fork()-Funktion kann auch Code nach execvp auf­ge­ru­fen werden.

Wie funk­tio­niert execvp?

Die Haupt­auf­ga­be von execvp ist es, einem Programm die Kontrolle über ein anderes zu übergeben, ohne den gesamten Prozess neu auf­zu­set­zen. Dies er­mög­licht das nahtlose Um­schal­ten zwischen ver­schie­de­nen Funk­tio­nen oder das Ausführen externer Befehle mit variablen Ar­gu­men­ten. execvp ist wie ein un­sicht­ba­rer Regisseur, der die Kulissen wechselt und zwischen ver­schie­de­nen Hand­lungs­strän­gen hin- und her­springt.

Durch die dy­na­mi­sche Pro­zess­aus­füh­rung können Sie den Pfad zum Programm und sogar dessen Argumente während der Laufzeit anpassen. Die execvp()-Funktion findet Anwendung in Sys­tem­auf­ru­fen, die komplexe Aufgaben wie Skript­aus­füh­rung, Sys­tem­kom­man­dos, Pipe­lining und Re­di­rek­tio­nen erfordern. Sie trägt we­sent­lich dazu bei, die Fle­xi­bi­li­tät von C-Pro­gram­men zu erhöhen.

Die grund­le­gen­de Syntax von execvp

Die Syntax von execvp erfordert den Dateipfad oder Namen zum aus­zu­füh­ren­den Programm sowie ein Array von Zei­chen­ket­ten, das die Argumente für dieses Programm enthält.

#include <unistd.h>
int execvp(const char*command, char* argv[]);

• const char *command: Dies ist der Dateipfad oder der Name des je­wei­li­gen Programms. Es kann sowohl ein absoluter als auch ein relativer Pfad sein. Bei Ver­wen­dung eines relativen Pfads sucht execvp nach der Datei im System-PATH.
• char *argv[]: Ein Array von Zei­chen­ket­ten, das die Argumente für das aus­zu­füh­ren­de Programm enthält; das Array muss mit einem NULL-Zeiger enden, um das Ende der Ar­gu­ment­lis­te zu kenn­zeich­nen. Der erste Eintrag in argv ist üb­li­cher­wei­se der Name des Programms selbst, gefolgt von den Ar­gu­men­ten.

Die execvp und andere Funk­tio­nen aus der exec-Familie sind spe­zi­fisch für Unix-basierte Be­triebs­sys­te­me. Die #include <unistd.h>-Anweisung ist eine Header-Datei in der C-Pro­gram­mie­rung. Sie enthält De­fi­ni­tio­nen und De­kla­ra­tio­nen von Funk­tio­nen, die mit dem Unix-basierten Be­triebs­sys­tem und der Pro­zess­kon­trol­le in­ter­agie­ren. Sie werden der Datei beim C-Lernen häufig begegnen.

Der prak­ti­sche Einsatz von execvp

Im vor­lie­gen­den C-Programm nutzen wir die execvp()-Funktion aus der unistd.h-Header-Datei, um das externe Programm ls mit den Ar­gu­men­ten -l und /usr/bin zu starten. Das Array args steht für die Argumente des Programms. Wenn die execvp()-Funktion er­folg­reich ist, wird der aktuelle Prozess durch das externe Programm ersetzt, und die nach­fol­gen­den Zeilen werden ignoriert. Im Feh­ler­fall erscheint eine Feh­ler­mel­dung über perror, und das Programm gibt den Sta­tus­code 1 zurück.

#include <unistd.h>
int main() {
    char *args[] = {"ls", "-l", "/usr/bin", NULL};
    execvp("ls", args);
    perror("execvp");
    return 1;
}

Mit fork() können Sie An­wei­sun­gen auch nach execvp aufrufen. Die fork()-Funktion schafft einen neuen Prozess. Dadurch wird im El­tern­pro­zess weiterhin Code aus­ge­führt, während der neue Prozess das externe Programm startet.

#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>
int main() {
    char* command = "ls";
    char *args[] = {"ls", "-l", "/usr/bin", NULL};
    printf("Before calling execvp()\n");
    pid_t child_pid = fork();
    if (child_pid == -1) {
        // Error creating the process
        perror("fork");
        return 1;
    }
    if (child_pid == 0) {
        // Code executed in the child process
        // Call execvp in the child process to execute "ls" with the specified arguments
        int status_code = execvp(command, args);
        // This line is reached if execvp encounters an error
        perror("execvp");
        // Print statement after execvp
        printf("ls -l /usr/bin has taken control of this child process. If this is printed, execvp encountered
       an error.\n");
        // Error handling in the child process
        return 1;
    } else {
        // Code executed in the parent process
        // Wait for the completion of the child process
        waitpid(child_pid, NULL, 0);
        printf("The child process has completed its execution.\n");
    }
    return 0;
}

Zuerst erstellen wir einen neuen Prozess mittels fork(). Durch die execvp()-Funktion übernimmt ls mit seinen Ar­gu­men­ten den Child Process. Der El­tern­pro­zess wartet mit waitpid auf den Abschluss des Kind­pro­zes­ses und gibt danach die Meldung aus.