POSIX Message Queues mit C-Programmierung

POSIX-Interprozesskommunikation (IPC)

IPC wird für Echtzeit-Erweiterungen verwendet. Diese Nachrichtenwarteschlangen sind ein Teil von Linux. Diese Aufrufe werden jetzt als Standard verwendet, könnten aber Teil moderner Versionen sein. Diese Aufrufe sind mit einer viel übersichtlicheren Oberfläche einfach zu implementieren.

POSIX-Nachrichtenwarteschlangen unter Linux

V-Nachrichtenwarteschlangen in einem Linux-System werden mithilfe von Schlüsseln identifiziert, die mit . abgerufen werden ftok Anrufe. Diese POSIX-Nachrichtenwarteschlangen verwenden normalerweise Namenszeichenfolgen. In Linux-Systemen werden POSIX-Warteschlangen als Strings bezeichnet. Es wird davon ausgegangen, dass diese Zeichenfolgen mit / beginnen und dann andere Zeichen haben. Prozesse, die folgen und den Namen des Warteschlangennamens mit entsprechenden Rechten kennen, können Nachrichten an die Warteschlange senden oder von ihr empfangen. Dies hilft bei der Ausführung wichtiger Funktionen help.

Was sind POSIX Message Queue-Aufrufe??

POSIX-Nachrichtenwarteschlangen müssen mit jeder Bibliothek verknüpft werden, die tatsächlich beendet wird. Im Folgenden sind einige Aufrufe aufgeführt, die verwendet werden:

librt verwendet die Compileroption -lrt

Anrufnamen beginnen mit dem mq_prefix

Die Details von Warteschlangenaufrufen werden unten erläutert:

>> mq_open, mq_close

Diese Funktion wird verwendet, um eine POSIX-Warteschlange zu öffnen.

Mq_open ist eine Funktion, die verwendet wird, um den Namen der Warteschlange aufzurufen. Der nächste Parameter ist ein Flag zum Empfangen der Nachrichten. O_WRONLY wird verwendet, um Nachrichten zu senden, und O_RDWR wird verwendet, um Operationen innerhalb der Warteschlange zu senden und zu empfangen. Benutzer können das Flag O_NONBLOCK verwenden, um die Warteschlange für den nicht blockierenden Modus festzulegen und mq_send und mq_receive um Daten in einer Warteschlange zu senden und zu empfangen.

Syntax
Die Syntax für den obigen Warteschlangenaufruf wird unten angezeigt:

#einschließen
/* zum Öffnen der Dateien verwendet */
#einschließen
/* um eine Datei basierend auf dem Pfad zu bestimmen */
#einschließen
/* um Beschreibungen der Nachrichtenwarteschlange einzuschließen */
mqd_t mq_open (konstantes Zeichen *name, int oflag);
/* um die Warteschlange zu öffnen und darauf zuzugreifen */
mqd_t mq_open (konstantes Zeichen *name, int oflag, mode_t mode,
struct mq_attribute *attribut);

Mq_Flags: Könnte O sein oder nicht blockieren

Mq_MaxMsg: Maximale Anzahl von Nachrichten, die in die Warteschlange eingegeben werden können

Mq_Msgsize: Maximale Anzahl von Bytes in einer Nachricht

Mq_CurMsgs: Derzeit gesendete Nachrichten innerhalb einer Warteschlange

mq_close Anrufe: Um alle Warteschlangen-Deskriptoren zu schließen.

mq_notify

Es handelt sich um einen Aufruf zum Registrieren und Abmelden von Ankunftsbenachrichtigungen, wenn eine Nachricht in eine leere Warteschlange eintritt.

Syntax

#einschließen
/* um alle Beschreibungen der Nachrichtenwarteschlange aus dem Code einzuschließen */
int mq_notify (mqd_t mqdes, const struct sigevent *sevp);
/* um das Eintreffen der Nachricht in einer Warteschlange zu benachrichtigen */

mq_unlink

Es wird verwendet, um die Warteschlange mit dem Warteschlangennamen zu entfernen.

Syntax

int mq_unlink(const char *queue_name);
/* Um die Warteschlange mit dem Namen Warteschlangenname zu entfernen */

mq_getattr, mq_setattr

Diese Funktion hat eine Attributstruktur:

struct mq_attr wird als Nachrichtenwarteschlange für Deskriptoren verwendet.

mq_setattr wird zum Setzen der Attribute innerhalb einer Warteschlange verwendet.

Syntax

#einschließen
int mq_getattribute(mqd_t mqdes, struct mq_attribute *attribute);
int mq_setattribute(mqd_t mqdes, const struct mq_attribute *newattribute,
struct mq_attribute*oldattr);

Beispiel: Client-Server-Kommunikation über POSIX

Das Folgende ist ein Beispiel für die Durchführung der Client-Server-Kommunikation über POSIX-Nachrichtenwarteschlangen. Im Beispiel haben wir eine Client-Datei und eine Server-Datei.

Wir werden zwei Dateien haben: die erste (Server-)Datei ist Server.c, und die andere (Client-)Datei ist Klient.c.

Servercode

Das unten angezeigte Bild zeigt den Code, den wir für die Client-Server-Kommunikation verwendet haben. Zuerst haben wir einige Bibliotheken aufgerufen, um die Strings, Variablen und Funktionen zu definieren. Dann haben wir die definiert fcntl Funktion und der Name des Queue-Servers. Danach haben wir den Namen der Serverwarteschlange definiert, gefolgt von ihrer Nachrichtengröße und Puffergröße, um die Größe der Nachrichten zu definieren, die jeweils in unseren Puffer passen. Als nächstes haben wir die Warteschlangen aufgerufen und beschrieben, dann haben wir die nächsten Token generiert, um die Client-Antwort zu sehen, sobald sie an den Client gesendet wurde. Abschließend wurde die Bestätigung durch das Drucken der Nachricht von der Serverseite abgeschlossen. Im nächsten Abschnitt sehen Sie die im vorherigen Abschnitt besprochenen Flags.

Wir haben alle Flags initialisiert, einschließlich mq_flags, mq_maxmsgs, usw. um mit dem Speichern von Anfragen fortzufahren. Dann haben wir die Bedingung auf den Namen des Servers angewendet und die Nachrichten im Warteschlangenpuffer gespeichert. Danach haben wir zum Zeitpunkt der Speicherung sichergestellt, dass die Warteschlangen einer Prioritätsregel nach dem ersten Kommen folgten. Am Ende zeigt der Code eine Fehlermeldung an, wenn vom Client-Ende Fehler empfangen werden. Schließlich haben wir den Server verlassen, um die Anfrage an den Client zu senden.

Speichern Sie den Server.c-Datei

Kundencode

Wir werden jetzt die zweite Datei besprechen. Das unten angezeigte Bild ist der Code, den wir für die Client-Server-Kommunikation verwendet haben. Der Code begann mit dem Aufrufen von Standardbibliotheken und der Definition variabler Header. Dann haben wir die Strings und alle Arten von Daten definiert. Danach haben wir den Header der Warteschlange deklariert, um den Namen der Serverwarteschlange zu definieren. Als Nächstes haben wir die Berechtigungswarteschlangen und die Nachrichtengröße in der Warteschlange definiert, zusammen mit der Größe des Nachrichtenpuffers (die maximale Größe, die in die Warteschlange passen könnte).

Wir werden die Warteschlangen beschreiben und einen neuen Client erstellen, um die vom Ende des Servers gesendeten Nachrichten zu empfangen sent. Dann rufen wir die Flags auf und initialisieren sie und rufen die Client-End-Funktion auf. Im Fehlerfall wird die Funktion verlassen. Der Wert wird im Puffer gespeichert und eine Anforderungsantwort wird an den Server gesendet. Im Falle einer Antwort stellt der Server dann den Token zur Verfügung, der gedruckt wird, sobald die Client-Seite die Eingabe eingegeben hat. Im Fehlerfall werden die Fehlerwerte zurückgegeben, d.h.e., der Client konnte keine Nachricht an den Server senden. Danach verlassen wir den Client.

Speichern Sie den Kunden.c-Datei

Ausführen der Dateien

Wir verwenden a gcc Compiler zum Ausführen der Dateien. Um die Server-Enddatei auszuführen, geben Sie den angehängten Befehl im Terminalfenster ein:

$ sudo gcc-Server.c -lrt

Geben Sie als Nächstes Folgendes ein:

$ ./ein.aus

Die Ausgabe wird wie folgt aussehen:

Fahren Sie mit der Clientantwort fort und geben Sie Folgendes ein:

$ sudo gcc-Client.c -lrt

Führen Sie dann Folgendes aus:

$ ./ein.aus

Die Ausgabe wird wie folgt aussehen:

Fazit

In diesem Artikel haben Sie gelernt, wie Sie POSIX Message Queues mit C-Programmierung senden, sowie einige seiner Funktionen. Dann haben Sie einige Beispiele für diesen Prozess genauer gesehen.