Grundlegendes zu Pipes

[andi234]

Hallo,

ich habe jetzt schon viel über Pipes gelesen, aber irgendwie hab ich es immernoch nicht richtig kapiert – vor allem habe ich Probleme, wenn forks bzw. dups dazukommen. Zum Beispiel wie bei folgendem Code:

#include <stdio.h>
#define READ 0
#define WRITE 1

void Fehler (char *Text)
{
  fprintf (stderr, "Fehler : %s in %d\n", Text, getpid());
  exit (1);
}

int Pipe[2];
int Kommando (char *Cmd, char *Par, int Modus)
{
  char Zeile[80];
  int pid = fork();
  switch (pid)
    {
    case -1 : Fehler ("Fork()");
    case  0 : close (Modus);
              dup (Pipe[Modus]);
              close (Pipe[0]);
              close (Pipe[1]);
	  printf ("Forki erfolgreich: %d\n", pid);
              strcpy (Zeile, "/bin/");
              strcat (Zeile, Cmd);
              execl (Zeile, Cmd, Par, NULL);
    default : printf ("Fork erfolgreich: %d\n", pid);
    }
}

main()
{
  pipe (Pipe);
  Kommando ("cat", "ausgabe", WRITE);
  Kommando ("sort", NULL, READ);
}

In der main() wird eine Pipe erzeugt, sprich wir haben zunächst 1 Prozess mit einem Schreib- und einem Lese-Filedeskriptor(0 und 1). Dann wird zum ersten Mal die Funktion intKommando aufgerufen, in der der Prozess geforkt wird. Wir haben also jetzt einen Parent(P)- und einen Childprozess(C) mit einer Pipe dazwischen:

P 1----------------------------------------------0 C

0----------------------------------------------1

mit „case 0“ gehen wir dann in den Childprozess und schließen dort mit close(Modus) die Write-Seite:

P 1---------------------------------------------0 C

0-----------------------------------------------

und dann duplizieren wir die Pipe, bzw. nur deren Write-Seite (weil ja bei „dup (Pipe[Modus]);“ Modus als Parameter übergeben wird) – wie darf ich mir denn das dann vorstellen?

Vielen Dank für euere Antworten, Andi

P.S. Entschuldigt die schlechte grafische Darstellung der Pipes, aber ich hatte keine andere Idee.

[rüdiger]

Du schließt den Handler für die normale Standard-Ausgabe und mit dup kopierst du den Handler auf den ersten freien Hander (also Standard-Ausgabe). Ich versteh ehrlich gesagt dein Problem nicht.

btw. solltest du auf const-correctnes achten

[andi234]

@rüdiger

Sorry, vielleicht hätte ich mein Problem etwas genauer schildern sollen: Ich hab unter dup verstanden, dass meine Pipe kopiert wird, sprich, dass ich dann aus:

1----------------------------------------------0

0----------------------------------------------1

sowas wie:

1----------------------------------------------0

0----------------------------------------------1

1----------------------------------------------0

0----------------------------------------------1

mache (das soll die Kanäle der Pipes darstellen - musst Dir natürlich links den Parent und rechts das Child vorstellen)...

Aber wenn ich Dich richtig verstehe, bedeutet dup einfach nur die Pipe vom Prozess z.B. auf die Standartausgabe zu legen?

[rüdiger]

Du musst zwischen dem Handle, also dem Integer unterscheiden und zwischen der Ressource die dahinter steckt. Es wird bei dup quasi nur ein neues Handle für die gleiche Ressource ausgegeben, bei dem ersten freien Handler.

[andi234]

Sorry, dass ich so lange nicht geantwortet habe, aber ich hatte Urlaub

Leider verstehe ich das ganze immernoch nicht. Das Programm möchte ja im ersten Schritt die per Parameter mitgegebene Datei auslesen und im zweiten Schritt sortieren (das Prog. ist nicht von mir). Ich forke also meinen Prozess und habe dann dieses Szenario:

P 1----------------------------------------------0 C

0----------------------------------------------1

Dann schließe ich beim Child die Schreibseite, weil ich ja nur von Parent nach Child schreiben möchte (Zeile 19). Warum schließe ich jetzt nicht einfach noch beim Parent die Leseseite (womit dann der Parent nur schreiben und das Child nur lesen könnte)? Stattdessen dupliziere ich das mit dup auch noch? Ich komm da irgendwie überhaupt noch nicht mit...

[SideWinder]

Im switch fehlen imho break-Statements.

MfG SideWinder

[andi234]

SideWinder schrieb:

Im switch fehlen imho break-Statements.

MfG SideWinder

ja, da könntest Du recht haben...