GNU/Linux >> LINUX-Kenntnisse >  >> Linux

Programm aus einem C-Programm heraus ausführen

Sie möchten popen verwenden . Es gibt Ihnen eine unidirektionale Pipe, mit der Sie auf stdin und stdout des Programms zugreifen können.

popen ist Standard auf modernen Unix- und Unix-ähnlichen Betriebssystemen, von denen Linux eines ist :-)

Geben Sie

ein
man popen

in einem Terminal, um mehr darüber zu erfahren.

BEARBEITEN

Ob popen erzeugt unidirektionale oder bidirektionale Rohre, hängt von der Implementierung ab. Unter Linux und OpenBSD popen erzeugt unidirektionale Pipes, die schreibgeschützt oder schreibgeschützt sind. Unter OS X, FreeBSD und NetBSD popen erzeugt bidirektionale Pipes.


Ich habe vor einiger Zeit einen Beispiel-C-Code für jemand anderen geschrieben, der zeigt, wie man das macht. Hier ist es für Sie:

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

void error(char *s);
char *data = "Some input data\n";

main()
{
  int in[2], out[2], n, pid;
  char buf[255];

  /* In a pipe, xx[0] is for reading, xx[1] is for writing */
  if (pipe(in) < 0) error("pipe in");
  if (pipe(out) < 0) error("pipe out");

  if ((pid=fork()) == 0) {
    /* This is the child process */

    /* Close stdin, stdout, stderr */
    close(0);
    close(1);
    close(2);
    /* make our pipes, our new stdin,stdout and stderr */
    dup2(in[0],0);
    dup2(out[1],1);
    dup2(out[1],2);

    /* Close the other ends of the pipes that the parent will use, because if
     * we leave these open in the child, the child/parent will not get an EOF
     * when the parent/child closes their end of the pipe.
     */
    close(in[1]);
    close(out[0]);

    /* Over-write the child process with the hexdump binary */
    execl("/usr/bin/hexdump", "hexdump", "-C", (char *)NULL);
    error("Could not exec hexdump");
  }

  printf("Spawned 'hexdump -C' as a child process at pid %d\n", pid);

  /* This is the parent process */
  /* Close the pipe ends that the child uses to read from / write to so
   * the when we close the others, an EOF will be transmitted properly.
   */
  close(in[0]);
  close(out[1]);

  printf("<- %s", data);
  /* Write some data to the childs input */
  write(in[1], data, strlen(data));

  /* Because of the small amount of data, the child may block unless we
   * close it's input stream. This sends an EOF to the child on it's
   * stdin.
   */
  close(in[1]);

  /* Read back any output */
  n = read(out[0], buf, 250);
  buf[n] = 0;
  printf("-> %s",buf);
  exit(0);
}

void error(char *s)
{
  perror(s);
  exit(1);
}

  1. Erstellen Sie zwei Pipes mit pipe(...) , eine für stdin , eine für stdout .
  2. fork(...) der Prozess.
  3. Im untergeordneten Prozess (derjenige, in dem fork(...) gibt 0 zurück) dup (...) die Leitungen zu stdin /stdout .
  4. exec[v][e] die zu startende Programmdatei im Kindprozess.
  5. Im übergeordneten Prozess (derjenige, in dem fork ) gibt die PID des Kindes zurück) führe eine Schleife aus, die aus dem stdout des Kindes liest (select(...) oder poll(...) , read(...) ) in einen Puffer, bis das Kind beendet wird (waitpid(...) ).
  6. Versorgen Sie das Kind schließlich mit Eingaben auf stdin wenn es welche erwartet.
  7. Wenn Sie fertig sind close(...) die Rohre.

Linux
  1. Senden von Eingaben an eine Bildschirmsitzung von außen?

  2. Wie macht man ein Programm überall ausführbar?

  3. Verhindern, dass Sigint untergeordnete Prozesse erreicht?

  4. Führen Sie Perl/PHP-Skripte von der Befehlszeile aus

  5. Wie erhalte ich einen Rückgabewert von CHILD PROCESS?

Programmieren Sie Hardware über die Linux-Befehlszeile

So installieren Sie ein Programm von der Quelle unter Linux

Führen Sie das Bash-Skript von der URL aus

Führen Sie Shell-Befehle aus einem Programm aus, das in WINE ausgeführt wird

Ist es sicher, innerhalb eines Threads zu forken?

Wie führe ich ein Python-Skript von Java aus aus?