summaryrefslogtreecommitdiff
Side-by-side diff
Diffstat (more/less context) (ignore whitespace changes)
-rw-r--r--x11/ipc/client/ocopclient.cpp129
-rw-r--r--x11/ipc/client/ocopclient.h56
-rw-r--r--x11/ipc/server/ocopserver.cpp1
3 files changed, 186 insertions, 0 deletions
diff --git a/x11/ipc/client/ocopclient.cpp b/x11/ipc/client/ocopclient.cpp
new file mode 100644
index 0000000..1c25271
--- a/dev/null
+++ b/x11/ipc/client/ocopclient.cpp
@@ -0,0 +1,129 @@
+#include <errno.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+
+
+#include <qfile.h>
+#include <qtimer.h>
+
+#include "../common/ocoppacket.h"
+
+#include "ocopclient.h"
+
+OCOPClient::OCOPClient( const QString& path, QObject* obj )
+ : QObject( obj )
+{
+ init(QFile::encodeName(path) );
+}
+OCOPClient::~OCOPClient() {
+ close( m_socket );
+}
+void OCOPClient::init( const QCString& str ) {
+ struct sockaddr_un unix_adr;
+ if ( (m_socket = socket(PF_UNIX, SOCK_STREAM, 0) ) < 0 ) {
+ qWarning("could not socket");
+ QTimer::singleShot(400, this,SLOT(init() ) );
+ return;
+ }
+ memset(&unix_adr, 0, sizeof(unix_adr ) );
+ unix_adr.sun_family = AF_UNIX;
+ sprintf(unix_adr.sun_path,"%s/.opie.cop", getenv("HOME") );
+ int length = sizeof(unix_adr.sun_family) + strlen(unix_adr.sun_path);
+
+ if ( ::connect(m_socket, (struct sockaddr*)&unix_adr, length ) < 0 ) {
+ qWarning("could not connect %d", errno );
+ close( m_socket );
+ QTimer::singleShot(400, this, SLOT(init() ) );
+ return;
+ }
+ m_notify = new QSocketNotifier(m_socket, QSocketNotifier::Read, this );
+ connect( m_notify, SIGNAL(activated(int) ),
+ this, SLOT(newData() ) );
+}
+/**
+ * new data
+ * read the header check magic number
+ * and maybe read body
+ */
+void OCOPClient::newData() {
+ OCOPPacket pack = packet();
+ if ( pack.channel().isEmpty() )
+ return;
+
+ switch( pack.type() ) {
+ case OCOPPacket::Register:
+ case OCOPPacket::Unregister:
+ case OCOPPacket::Method:
+ case OCOPPacket::RegisterChannel:
+ case OCOPPacket::UnregisterChannel:
+ case OCOPPacket::Return:
+ case OCOPPacket::Signal:
+ /* is Registered should be handled sync */
+ case OCOPPacket::isRegistered:
+ break;
+ /* emit the signal */
+ case OCOPPacket::Call:
+ emit called( pack.channel(), pack.header(), pack.content() );
+ break;
+ }
+}
+OCOPPacket OCOPClient::packet() {
+ QCString chan;
+ QCString func;
+ QByteArray ar;
+ OCOPHead head;
+ memset(&head, 0, sizeof(head) );
+ read(m_socket, &head, sizeof(head) );
+ if ( head.magic == 47 ) {
+ read(m_socket, chan.data(), head.chlen );
+ read(m_socket, func.data(), head.funclen );
+ read(m_socket, ar.data(), head.datalen );
+ }
+ OCOPPacket pack(head.type, chan, func, data );
+ return pack;
+}
+/*
+ * we've blocking IO here on these sockets
+ * so we send and go on read
+ * this will be blocked
+ */
+bool OCOPClient::isRegistered( const QCString& chan ) {
+ /* should I disconnect the socket notfier? */
+ OCOPPacket packe(OCOPPacket::IsRegistered, chan );
+ OCOPHead head = packe.head();
+ write(m_socket, &head, sizeof(head) );
+
+ /* block */
+ OCOPPacket pack = packet();
+
+ /* connect here again */
+ if ( pack.channel() == chan ) {
+ QCString func = pack.header();
+ if (func[0] == 1 )
+ return;
+ }
+
+ return false;
+};
+void OCOPClient::send( const QCString& chan, const QCString& fu, const QByteArray& arr ) {
+ OCOPPacket pack(OCOPPacket::Call, chan, fu, arr );
+ call( pack );
+}
+void OCOPClient::addChannel(const QCString& channet) {
+ OCOPPacket pack(OCOPPacket::RegisterChannel, channel );
+ call( pack );
+}
+void OCOPClient::delChannel(const QCString& chan ) {
+ OCOPPacket pack(OCOPPacket::UnregisterChannel, channel );
+ call( pack );
+}
+void OCOPPacket::call( const OCOPPacket& pack ) {
+ OCOPHead head = pack.head();
+ write(m_socket, &head, sizeof(head) );
+ write(m_socket, pack.channel().data(), pack.channel().size() );
+ write(m_socket, pack.header().data(), pack.header().size() );
+ write(m_socket, pack.content().data(), pack.content().size() );
+}
diff --git a/x11/ipc/client/ocopclient.h b/x11/ipc/client/ocopclient.h
new file mode 100644
index 0000000..5300132
--- a/dev/null
+++ b/x11/ipc/client/ocopclient.h
@@ -0,0 +1,56 @@
+#ifndef OPIE_OCOP_CLIENT_H
+#define OPIE_OCOP_CLIENT_H
+
+
+#include <qobject.h>
+#include <qcstring.h>
+#include <qmap.h>
+#include <qsignal.h>
+#include <qstring.h>
+#include <qsocketnotifier.h>
+
+
+/**
+ * This is the OCOP client
+ * It currently only supports
+ * asking if a Channel is registered,
+ * calling and receiving calls
+ */
+class OCOPPacket;
+class OCOPClient : public QObject{
+ Q_OBJECT
+public:
+
+ /**
+ * Occasionally I decide to start a Server from here
+ */
+ OCOPClient(const QString& pathToServer = QString::null, QObject* obj = 0l);
+ ~OCOPClient();
+
+ bool isRegistered( const QCString& )const;
+ void send( const QCString& chan, const QCString&, const QByteArray& msg );
+
+ /**
+ * add a channel and does connect to a signal
+ * callback is the object
+ * slot is the SLOT()
+ */
+ void addChannel( const QCString& channel );
+ void delChannel( const QCString& channel );
+/* no direct signals due the design */
+signals:
+ void called(const QCString&, const QCString&, const QByteArray );
+private slots:
+ void init(const QCString& pa);
+ void newData();
+private:
+ OCOPPacket packet();
+ void call( const OCOPPacket& );
+
+ QSocketNotifier* m_notify;
+ int m_socket;
+private slots:
+
+};
+
+#endif
diff --git a/x11/ipc/server/ocopserver.cpp b/x11/ipc/server/ocopserver.cpp
index 3df574b..e76657e 100644
--- a/x11/ipc/server/ocopserver.cpp
+++ b/x11/ipc/server/ocopserver.cpp
@@ -283,101 +283,102 @@ void OCopServer::dispatch( const OCOPPacket& packet, int sourceFD ) {
break;
/* not implemented :( */
case OCOPPacket::Signal:
break;
case OCOPPacket::IsRegistered:
isRegistered( packet.channel(), sourceFD );
break;
};
}
void OCopServer::errorOnServer() {
/*
* something is wrong on the server socket?
* what should we do?
* FIXME
*/
}
QStringList OCopServer::channels() {
QStringList list;
{
QMap<QCString, QValueList<int> >::Iterator it;
for (it = m_channels.begin(); it != m_channels.end(); ++it ) {
list << it.key();
};
}
return list;
}
bool OCopServer::isChannelRegistered( const QCString& chan ) const{
return m_channels.contains( chan );
}
void OCopServer::addChannel( const QCString& channel,
int fd ) {
QMap<QCString, QValueList<int> >::Iterator it;
it = m_channels.find( channel );
/* could be empty */
QValueList<int> list = it.data();
list.append( fd );
it = m_channels.replace( channel, list );
};
void OCopServer::delChannel( const QCString& channel,
int fd ) {
if (!m_channels.contains( channel ) )
return;
QMap<QCString, QValueList<int> >::Iterator it;
it = m_channels.find( channel );
if ( it.data().contains(fd) ) {
QValueList<int> ints = it.data();
if ( ints.count() == 1 )
m_channels.remove( it );
else{
QValueList<int> ints = it.data();
ints.remove( fd );
m_channels.replace( it.key(), ints );
}
}
}
void OCopServer::isRegistered( const QCString& channel, int fd) {
OCOPHead head;
QCString func(2);
memset(&head, 0, sizeof(head ) );
head.magic = 47;
head.type = OCOPPacket::IsRegistered;
head.chlen = channel.size();
head.funclen = func.size();
head.datalen = 0;
if ( isChannelRegistered( channel ) ) {
//is registered
func[0] = 1;
}else{
func[0] = 0;
}
/**
* write the head
* and then channel
* success/failure inside func
*/
write(fd, &head, sizeof(head) );
write(fd, channel.data(), channel.size() );
write(fd, func.data(), func.size() );
}
QValueList<int> OCopServer::clients( const QCString& channel ) {
return m_channels[channel];
}
void OCopServer::call( const OCOPPacket& p, int fd ) {
QValueList<int> cli = clients( p.channel() );
QValueList<int>::Iterator it;
OCOPHead head = p.head();
for (it = cli.begin(); it != cli.end(); ++it ) {
write( (*it), &head, sizeof(head ) );
+ /* expl. shared! */
write( (*it), p.channel().data(), p.channel().size() );
write( (*it), p.header().data(), p.header().size() );
write( (*it), p.content().data(), p.content().size() );
};
}