Wie führe ich einen untergeordneten Prozess mit Piped-Standard-E/A in C aus?

Übergabe von Standard-E/A-Parametern an untergeordnete Prozesse über Pipes

Das Ziel besteht darin, eine C-Funktion zu erstellen, die einen untergeordneten Prozess ausführt (" foo") mit der bereitgestellten Zeichenfolge als Standardeingabe ("s") und gibt die Standardausgabe des untergeordneten Elements in einer Zeichenfolgenvariablen zurück.

Systemaufrufe und POSIX-Funktionen

Die folgenden Systemaufrufe und POSIX-Funktionen sind für diese Aufgabe erforderlich:

• pipe(): Erstellt eine Pipe für die Kommunikation zwischen übergeordneten und untergeordneten Prozessen.
• fork(): Erstellt einen neuen untergeordneten Prozess.
• dup2(): Dupliziert einen Dateideskriptor in einen anderen descriptor.
• execve(): Führt ein neues Programmbild im aktuellen Prozess aus.
• write(): Schreibt Daten in einen Dateideskriptor.
• read(): Liest Daten aus einem Dateideskriptor.

Funktion Implementierung

Die folgende Funktion folgt diesen Schritten, um einen untergeordneten Prozess mit weitergeleiteter Standard-E/A auszuführen:

1. Erstellen Sie zwei Pipes, eine für die Standardeingabe und eine für die Standardausgabe .
2. Forken Sie einen neuen untergeordneten Prozess.

3. Im Kind Prozess:

   • Seine Standardeingabe zum Leseende der Eingabepipe umleiten.
   • Seine Standardausgabe und seinen Standardfehler zum Schreibende der Ausgabepipe umleiten.
   • Schließen Sie alle nicht verwendeten Dateideskriptoren, die vom übergeordneten Element geerbt wurden.
   • Führen Sie das untergeordnete Programm („foo“) mit aus execve().

4. Im übergeordneten Prozess:

   • Schließen Sie die nicht verwendeten Enden der Pipes.
   • Schreiben Sie die Eingabe Zeichenfolge an das schreibende Ende der Eingabepipe.
   • Lesen und speichern Sie die Standardausgabe des Kindes vom lesenden Ende der Ausgabe Pipe.
   • Warten Sie mit fork(), bis der untergeordnete Prozess fertig ist.

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

#define PIPE_READ 0
#define PIPE_WRITE 1

string f(string s) {
  int inputPipe[2];
  int outputPipe[2];
  pid_t childPid;
  char c;
  string result;

  if (pipe(inputPipe) < 0 || pipe(outputPipe) < 0) {
    perror("Error creating pipes");
    return "";
  }

  if ((childPid = fork()) == -1) {
    perror("Error creating child process");
    return "";
  } else if (childPid == 0) {  // Child process
    // Redirect standard input
    if (dup2(inputPipe[PIPE_READ], STDIN_FILENO) < 0) {
      perror("Error redirecting standard input");
      exit(errno);
    }

    // Redirect standard output and standard error
    if (dup2(outputPipe[PIPE_WRITE], STDOUT_FILENO) < 0) {
      perror("Error redirecting standard output");
      exit(errno);
    }
    if (dup2(outputPipe[PIPE_WRITE], STDERR_FILENO) < 0) {
      perror("Error redirecting standard error");
      exit(errno);
    }

    // Close unused pipes
    close(inputPipe[PIPE_READ]);
    close(inputPipe[PIPE_WRITE]);
    close(outputPipe[PIPE_READ]);

    // Execute child process
    execl("/bin/sh", "sh", "-c", s.c_str(), NULL);
    perror("Error executing child process");
    exit(errno);
  } else {  // Parent process
    // Close unused pipes
    close(inputPipe[PIPE_READ]);
    close(outputPipe[PIPE_WRITE]);

    // Write input string to child's standard input
    write(inputPipe[PIPE_WRITE], s.c_str(), s.size());

    // Read output from child's standard output
    while (read(outputPipe[PIPE_READ], &c, 1) > 0) {
      result += c;
    }

    // Close pipes
    close(inputPipe[PIPE_WRITE]);
    close(outputPipe[PIPE_READ]);

    // Wait for child to finish
    waitpid(childPid, NULL, 0);
  }

  return result;
}

Das obige ist der detaillierte Inhalt vonWie führe ich einen untergeordneten Prozess mit Piped-Standard-E/A in C aus?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!