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.