Howto: Wie arbeitet man mit Pipes?

Kommunikation von Prozessen unter Linux lässt sich auf verschiedene Art und
Weisen bewerkstelligen. In diesem kurzem Tutorial will ich auf die Möglichkeit
Pipes eingehen. 

  Was sind pipes?

Pipes beziehungsweise Fifos werden als Interprocess Communication (oder auch 
IPC) bezeichnet. Dabei wird Voll- und Halbdublex-IPCs unterschieden.
Pipes stellen Halbdublex-IPCs dar, da sie entweder nur lesen oder aber nur
schreiben können. Will man einen Volldublex-IPC heranziehen, so greift man 
sich einen Socket heran. Hier soll es nur um Pipes gehen.

  Wie verwendet man pipes?
Pipes stellen also eine Möglichkeit dar, zwischen Prozessen zu kommunizieren. 
Dabei gibt es die Einschränkung, dass man mit Pipes nur zwischen verwandten
Prozessen kommunizieren kann. Will man zum Beispiel in einem Programm mit 
dem Systembefehl grep kommunizieren, so werden Fifo notwendig (siehe hierzu 
[1]}.
Einen Pipe erzeugt man mit folgenden Code:

  //Notwendigen Header einbinden
  #include <unistd.h>
  // Erzeuge einen Pipe
  int pipe(fDesc[2]);

Der Array fDesc[2] stellt die Filedeskriptoren dar, mit denen der Dateaustausch
gewährleistet wird:
  
  ssize_t read (int fDesc, void *puffer, size_t lenght);
  ssize_t write (int fDesc, void *puffer, size_t lenght);

Der Puffer soll 1024 Bytes enthalten:

  char puffer[1024];

Diese beiden elementaren I/O-Operationen reichen in diesem Beispiel erst einmal
aus. Nun brauchen wir einen Childprozess, den wir mit fork() erzeugen:

   __pid_t pid;
   pid=fork();

Mittels dieser Anweisung wird eine exakte Kopie des Prozesses im Speicher
erzeugt. Der Elternprozess erhält einen Wert > 0, der Kindprozess einen 
Wert = 0. 
Da jede Pipe (im Eltern- oder Kindprozess entweder nur schreiben oder nur 
lesen dürfen, muss der andere File-Deskripto mit close(fDesc) geschlossen  
werden: 
Fuer den Eltern-Prozess

  // Lesehandle schliessen, da er schreiben soll
  close (filed[0]);

Für den Kind-Prozess
  // Schliesse Schreibhandle, da er lesen soll
  close (filed[1]);

Die Kommunikation erfolgt dann mit read und write:

Für den Eltern-Prozess:

  write (filed[1], "Mein kleiner Pipe-test!", 
      sizeof("Mein kleiner Pipe-test!"));

Für den Kind-Prozess:

  read (filed[0], puffer, sizeof(puffer));

Abscliessend muss man nun noch den nch offenen File-Deskriptor schliessen

Für den Eltern-Prozess:

   close(filed[1]);

Für den Kind-Prozess:

   close(filed[0]);

Und das war schon alles. 

Mehr Infos? Hier einige Links:
[1]  http://www.linux-magazin.de/Artikel/ausgabe/1998/07/Pipe/pipe.html
[2]  http://www.nt.fh-koeln.de/fachgebiete/inf/diplom/proc_sync/4/4.8.html

Wer einen Fehler gefunden hat, oder aber noch Anregungen hat:
Mail: sir_kimmi@gmx.de
HP:   http://www.sir-kimmi.de