[C++] Interprozess-Kommunikation mit FIFOs und Qt 3

[KL47]

Wenn ihr von außen (also mit irgendwelchen anderen Programmen) auf ein bereits laufendes Programm zugreifen wollt, bietet es sich an, dies unter Linux über "Named Pipes" zu machen (siehe dazu "man fifo" oder den entsprechenden Eintrag in der Wikipedia).

Hier soll nun erläutert werden, wie ihr in euer Programm mit QT 3 (Produkt von Trolltech) einen Thread einbaut, der Eingaben von einer bestimmten Pipe empfängt (die Bearbeitung der Eingaben bleibt euch selbst überlassen ). Einige Kenntnisse in C++ und QT werden vorausgesetzt.

Wir brauchen zunächst einen Namen für das Programm, wir nennen es ThreadApp (). Anschließend legen wir einen Ordner "/var/run/threadapp/" an und erstellen in diesem Ordner eine Pipe:

mkdir /var/run/threadapp
cd /var/run/threadapp
mkfifo input.fifo

Wir erstellen jetzt die Quellcode-Dateien für unser Projekt. Erstellt mit $EDITOR die beiden folgenden Dateien:

ThreadApp.h

#include <iostream>
#include <string>

#include <qfile.h>
#include <qtextstream.h>
#include <qstring.h>

#include <qthread.h>

class ThreadApp : public QThread
{
public:
  ThreadApp();
  
  void run();
  void stop();
    
private:  
  bool stopped;
};

ThreadApp.cpp

#include "ThreadApp.h"

ThreadApp::ThreadApp()
{
  this->stopped = false;
}


void ThreadApp::run()
{
  QFile file("/var/run/threadapp/input.fifo");
  
  if (!file.open(IO_ReadOnly | IO_Translate)) return;
  
  while (!this->stopped)
  {
    QTextStream stream(&file);
  
    QString s;
  
    while ((s = stream.readLine()) != NULL)
    {
      // Mit dem String könnt ihr jetzt tun, was immer ihr wollt,
      // mit std::string(s) könnt ihr ihn auch in einen STL-String
      // umwandeln
      // Denkt bei der Ausgabe an das "std::endl", da ansonsten der
      // Buffer nicht geleert wird und nichts ausgegeben wird.
      // Achtung: "\n" != std::endl
      std::cout << s << std::endl;
    }
  }
}


void ThreadApp::stop()
{
  this->stopped = true;
}


int main()
{
  ThreadApp t;
  
  t.start(QThread::HighestPriority);
  
  // Verhindert, dass das Programm zu früh beendet wird
  while (t.running())
  {
  }
  
  return 0;
}

Das Projekt wird kompiliert, indem zunächst mit "qmake" ein Makefile erzeugt und anschließend mit "make" das Programm erzeugt wird, vorher müssen wir noch eine Projektdatei erstellen und diese ein wenig modifizieren (es wird davon ausgegangen, dass die Quellcode-Dateien in dem Ordner "ThreadApp" sind, ansonsten heißt die Projektdatei anders, *.pro müsste es genauso tun):

qmake -project
echo "CONFIG += thread" >> ThreadApp.pro
qmake
make

Nun könnt ihr euer Programm testen:

./ThreadApp &
echo "Test" > /var/run/threadapp/input.fifo

Viel Spaß noch. Wenn ihr Fehler findet, postet einfach mal, mal schaun was sich machen lässt...