Wie führe ich ein externes Programm in C-Code in Linux mit Argumenten aus?

Ich möchte ein anderes Programm in C-Code ausführen. Ich möchte zum Beispiel einen Befehl ausführen

./foo 1 2 3

foo ist das Programm, das im selben Ordner vorhanden ist, und 1 2 3 sind Argumente.
foo Das Programm erstellt eine Datei, die in meinem Code verwendet wird.

Wie mache ich das?

Verwenden Sie für einen einfachen Weg system():

#include <stdlib.h>
...
int status = system("./foo 1 2 3");

system() wartet, bis foo die Ausführung abgeschlossen hat, und gibt dann eine Statusvariable zurück, mit der Sie z. B. den Exitcode überprüfen können (der Exitcode des Befehls wird mit 256 multipliziert, also teilen Sie den Rückgabewert von system() durch diesen, um den tatsächlichen Exitcode zu erhalten: int exitcode = status / 256).

Die Manpage für wait() (in Abschnitt 2, man 2 wait auf Ihrem Linux-System) listet die verschiedenen Makros auf, mit denen Sie den Status untersuchen können, die interessantesten wären WIFEXITED und WEXITSTATUS.

Alternativ, wenn Sie die Standardausgabe von foo lesen müssen, verwenden Sie popen(3)die einen Dateizeiger zurückgibt (FILE *); Die Interaktion mit der Standard-Ein-/Ausgabe des Befehls entspricht dann dem Lesen oder Schreiben in eine Datei.

Das system Funktion ruft eine Shell auf, um den Befehl auszuführen. Das ist zwar bequem, aber bekanntlich Auswirkungen auf die Sicherheit. Wenn Sie den Pfad zu dem Programm oder Skript, das Sie ausführen möchten, vollständig angeben können, können Sie es sich leisten, die Plattformunabhängigkeit zu verlieren system bietet, dann können Sie eine verwenden execve Wrapper wie in der abgebildet exec_prog Funktion unten, um Ihr Programm sicherer auszuführen.

So geben Sie die Argumente im Aufrufer an:

const char    *my_argv[64] = {"/foo/bar/baz" , "-foo" , "-bar" , NULL};

Dann ruf die an exec_prog funktionieren so:

int rc = exec_prog(my_argv);

Hier ist die exec_prog Funktion:

static int exec_prog(const char **argv)
{
    pid_t   my_pid;
    int     status, timeout /* unused ifdef WAIT_FOR_COMPLETION */;

    if (0 == (my_pid = fork())) {
            if (-1 == execve(argv[0], (char **)argv , NULL)) {
                    perror("child process execve failed [%m]");
                    return -1;
            }
    }

#ifdef WAIT_FOR_COMPLETION
    timeout = 1000;

    while (0 == waitpid(my_pid , &status , WNOHANG)) {
            if ( --timeout < 0 ) {
                    perror("timeout");
                    return -1;
            }
            sleep(1);
    }

    printf("%s WEXITSTATUS %d WIFEXITED %d [status %d]\n",
            argv[0], WEXITSTATUS(status), WIFEXITED(status), status);

    if (1 != WIFEXITED(status) || 0 != WEXITSTATUS(status)) {
            perror("%s failed, halt system");
            return -1;
    }

#endif
    return 0;
}

Denken Sie daran, dass Folgendes enthalten ist:

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

Siehe verwandten SE-Beitrag für Situationen, die eine Kommunikation mit dem ausgeführten Programm über Dateideskriptoren wie z stdin und stdout.

Sie können verwenden fork() und system() damit Ihr Programm nicht bis warten muss system() kehrt zurück.

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

int main(int argc,char* argv[]){

    int status;

    // By calling fork(), a child process will be created as a exact duplicate of the calling process.
    // Search for fork() (maybe "man fork" on Linux) for more information.
    if(fork() == 0){ 
        // Child process will return 0 from fork()
        printf("I'm the child process.\n");
        status = system("my_app");
        exit(0);
    }else{
        // Parent process will return a non-zero value from fork()
        printf("I'm the parent.\n");
    }

    printf("This is my main program and it will continue running and doing anything i want to...\n");

    return 0;
}

system() führt eine Shell aus, die dann für das Analysieren der Argumente und das Ausführen des gewünschten Programms verantwortlich ist. Um das Programm direkt auszuführen, verwenden Sie fork() und exec() (was system() verwendet, um die Shell auszuführen, sowie das, was die Shell selbst verwendet, um Befehle auszuführen).

#include <unistd.h>

int main() {
     if (fork() == 0) {
          /*
           * fork() returns 0 to the child process
           * and the child's PID to the parent.
           */
          execl("/path/to/foo", "foo", "arg1", "arg2", "arg3", 0);
          /*
           * We woundn't still be here if execl() was successful,
           * so a non-zero exit value is appropriate.
           */
          return 1;
     }

     return 0;
}

In C

#include <stdlib.h>

system("./foo 1 2 3");

In C++

#include <cstdlib>

std::system("./foo 1 2 3");

Öffnen und lesen Sie die Datei dann wie gewohnt.

Wie wäre es so:

char* cmd = "./foo 1 2 3";
system(cmd);

So können Sie auf variable Argumente erweitern, wenn Sie die Argumente nicht fest codiert haben (obwohl sie in diesem Beispiel technisch immer noch fest codiert sind, aber einfach herauszufinden sein sollten, wie sie erweitert werden …):

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

int argcount = 3;
const char* args[] = {"1", "2", "3"};
const char* binary_name = "mybinaryname";
char myoutput_array[5000];

sprintf(myoutput_array, "%s", binary_name);
for(int i = 0; i < argcount; ++i)
{
    strcat(myoutput_array, " ");
    strcat(myoutput_array, args[i]);
}
system(myoutput_array);