QoIP ermöglicht die transparente QNX® Interprocess Communication (QNX® 4 IPC) mit Send-Receive-Reply und mit Proxy zwischen QNX® 4 Prozessen auf Basis von IP-Verbindungen (Internet Protocol).

QoIP ermöglicht die Anwendung der QNX® 4 Interprocess Communication auch auf dem OS QNX® 6.

QoIP ermöglicht die transparente QNX® 4 Interprocess Communication (IPC) zwischen Prozeßen unter QNX® 4 - QNX® 6 - Linux in beliebiger Richtung und Kombination. Bei Linux werden die Send-Receive-Reply-Module aus dem "SIMPL" Project benötigt, siehe http://www.holoweb.net/~simpl/.

Ist implementiert und funktioniert auch.

QoIP ist kein INFLEET !! QoIP verbindet einzelne Prozeße verschiedener OS und Rechner über das Internet, - es verbindet keine Netze!

QoIP arbeitet ähnlich wie QNX® 4 VC (Virtual Circuits), aber über tcp/ip. Pro Verbindung (qoip_name_locate) wird auf beiden Seiten je 1 tcp/ip Channel und für Proxy / Event Kommunikation 1 Reverse tcp/ip Channel geöffnet.

Für die QoIP-Kommunikation ist auf der Serverseite der IP-daemon qoipd zu installieren, der den QoiP Strom von einem definierten Port der IP-Verbindung liest bzw. schreibt und an die Anwendung des Nutzers weiterleitet. Auf der Seite des Clients ist der Proxy-Prozeß qoipp zu starten, welcher die Vertretung für die Anfragen der Anwendung aus der eingelinkten QoIP Library entgegennimmt und über die IP-Verbindung dem Server zuleitet.

Der Umfang der Libraries umfasst lediglich fünf Funktionen, so dass eine Anpassung bestehender verteilter QNX® 4 Anwendungen auf die Internet-Kommunikation ohne großen Aufwand möglich wird. Die Hauptlast der Kommunikation wird vom QoIP-Proxy-Prozeß und vom QoIP-Daemon geleistet.

Die nachfolgenden Beispiele zeigen, dass die Handhabung der QoIP-Funktionen sehr ähnlich der üblichen Verwendung der Funktionen des QNX® 4 IPC ist.

Für die Programmentwicklung des Clients werden folgende Libraries benötigt:

Für den QoIP-Server wird keine API-Library benötigt, sondern im Anwenderprogramm ist die Verwendung des Headers qoiplib.h - qiop_event_t Definition gefordert, siehe unten.

/usr/local/bitctrl/qoip/v1.0/bin/qoipp -> /usr/local/bin/qoipp
/usr/local/bitctrl/qoip/v1.0/bin/qoipd -> /usr/local/bin/qoipd
/usr/local/bitctrl/qoip/v1.0/lib/qoip3r.lib -> /usr/local/lib/qoip3r.lib
/usr/local/bitctrl/qoip/v1.0/include/qoip.h -> /usr/local/include/qoip.h
/usr/local/bitctrl/qoip/v1.0/etc/readme/qoip -> /etc/readme/qoip
/usr/local/bitctrl/qoip/v1.0/etc/version/qoip -> /etc/version/qoip

qoip/v1.0/
/--------+
|
+-bin	binäre Dateien
|   |qoipp	QoIP Proxy
|   |qoipd	QoIP Daemon
|
|
+---lib	Bibliothek(en)
|   \libqoip.a	QoIp Bibliothek
|
+---inc	Include Dateien
|   \qoip.h	QoIP Header Datei
|
+---src	Beispiel Quelldateien
|     |
|     +---server
|     |   |server.cc	Beispiel Server
|     |   \Makefile	makefile für Server
|     |
|     +---client
|     |   |client.cc	Beispiel Client
|     |   \Makefile	makefile für Client
|     |
|     +---include
|         \my.h	Gemeinsame Header Datei für Server und Client
|
+---etc	etc
|     |
|     +---licenses
|     |   \.licenses	Lizenzdatei
|     |
|     +---version
|     |   \qoip	Versionsdatei
|     |
|     +---readme
|         \qoip	Hilfedatei
\

/usr/local/bitctrl/qoip/v1.0/bin/qoipp -> /usr/local/bin/qoipp
/usr/local/bitctrl/qoip/v1.0/bin/qoipd -> /usr/local/bin/qoipd
/usr/local/bitctrl/qoip/v1.0/lib/libqoip.a -> /usr/local/lib/libqoip.a
/usr/local/bitctrl/qoip/v1.0/include/qoip.h -> /usr/local/include/qoip.h

Server und Client befinden sich im gleichen QNX® 4- Netzwerk.
Die Programmierung geschieht normalerweise wie folgt:

Id = qnx_name_attach( 0, "bitctrl/common/test" );
pid = Receive( 0, &msg, sizeof( msg ) );
printf( "Received a message from %d.\n", pid );
Reply( pid, &msg, sizeof( msg ) );
qnx_name_detach(id);

pid = qnx_name_locate(0, "bitctrl/common/test", 0, 0);
Send (pid, &msg, &msg, sizof(msg), sizeof(msg));

Server in Honolulu (QNX® 4), Client in Leipzig bei BitCtrl (QNX® 4):

Id = qnx_name_attach( 0, "bitctrl/qoip/test" );
pid = Receive( 0, &msg, sizeof( msg ) );
printf( "Received a message from %d.\n", pid );
Reply( pid, &msg, sizeof( msg ) );
qnx_name_detach(id);

Pid = qoip_name_locate("bitctrl.honolulu.hi.us", "bitctrl/qoip/test", 0);
Send (pid, &msg, &msg, sizof(msg), sizeof(msg));

Server in Honolulu (QNX® 4), Client in Leipzig bei BitCtrl (QNX® 6):

Id = qnx_name_attach( 0, "bitctrl/qoip/test" );
pid = Receive( 0, &msg, sizeof( msg ) );
printf( "Received a message from %d.\n", pid );
Reply( pid, &msg, sizeof( msg ) );
qnx_name_detach(id);

pid = qoip_name_locate("bitctrl.honolulu.hi.us", "bitctrl/qoip/test", 0);
MsgSend(pid, &msg, sizof(msg), &msg, sizeof(msg));

Server in Leipzig (QNX® 6), Client in Berlin (Linux):

if ((attach = name_attach(NULL, "bitctrl/qoip/test", 0)) == NULL) {
   return EXIT_FAILURE;
}
while (1) {
   rcvid = MsgReceive(attach->chid, &msg, sizeof(msg), NULL);
   ...
   if (msg.type == MSG_GIVE_EVENT){
      MsgDeliverEvent(rcvid, (struct sigevent*) &msg.event );
   }
}

#include <srr.h>
#include <qoip.h>
pid_t pid, rcvid, proxy;
qoip_event_t event;     /* qoip.h:
                         typedef union {
                         pid_t proxy;
                         __sigevent_t event;
                         } qoip_event_t;
                         */

proxy = qnx_proxy_attach(0, 0, 0, -1)

/* like qnx_rem_proxy_attach */
qoip_event_rem_attach("bitctrl.de", (qoip_event_t *) &proxy, &event);

msg.type = MSG_GIVE_EVENT;
msg.event = event;
pid = qoip_name_locate("bitctrl.de", "bitctrl/qoip/test", 0);
Send (pid, &msg, &msg, sizof(msg), sizeof(msg));

rcvid = Receive(0, &msg, sizeof(msg));
if (rcvid == proxy) {
   printf("Got a proxy %d \n", proxy);
}
...
qoip_event_rem_detach(&event);
qoip_name_close(pid);

Lokalisiert einen auf einem anderen Rechner laufenden Prozeß anhand seines registrierten Namens.

Schließt die mit dem Funktionsaufruf qoip_name_locate() etablierte Verbindung.

Erzeugt einen virtuellen Event / Proxy auf einem 'entfernten' Rechner.

Gibt virtuellen Event/Proxy Prozeß auf einem 'entfernten' Rechner frei.