Fix the IPC server and client

registering channel is done locally with refcounts
if the channel is already registered globally
Fix some sizes to allow proper communication..

4 files changed, 39 insertions, 13 deletions

diff --git a/x11/ipc/client/ocopclient.cpp b/x11/ipc/client/ocopclient.cpp
index 6085481..91827e7 100644
--- a/x11/ipc/client/ocopclient.cpp
+++ b/x11/ipc/client/ocopclient.cpp
@@ -96,43 +96,51 @@ OCOPPacket OCOPClient::packet() const{
     QCString func;
     QByteArray ar;
     OCOPHead head;
     memset(&head, 0, sizeof(head) );
     read(m_socket, &head, sizeof(head) );
     if ( head.magic == 47 ) {
+        qWarning("Client:Magic Match");
+        chan = QCString( head.chlen+1);
+        func = QCString( head.funclen+1 );
+        ar = QByteArray( head.datalen);
         read(m_socket, chan.data(), head.chlen );
         read(m_socket, func.data(), head.funclen );
         read(m_socket, ar.data(), head.datalen );
+	qWarning("Client:%d %s",head.chlen,chan.data() );
     }
     OCOPPacket pack(head.type, chan,  func, ar );
     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 ) const{
+    qWarning("OCopClient::isRegistered %s", chan.data() );
     /* should I disconnect the socket notfier? */
     OCOPPacket packe(OCOPPacket::IsRegistered, chan );
     OCOPHead head = packe.head();
     write(m_socket, &head, sizeof(head) );
     write(m_socket, chan.data(), chan.size() );
     /* block */
     OCOPPacket pack = packet();
+    qWarning("unblock %s %s", pack.channel().data(), chan.data() );
 
     /* connect here again */
     if ( pack.channel() == chan ) {
         QCString func = pack.header();
         if (func[0] == 1 )
             return true;
     }
 
     return false;
 };
 void OCOPClient::send( const QCString& chan, const QCString& fu, const QByteArray& arr ) {
+    qWarning("ClientSending %s %s", chan.data(), fu.data() );
     OCOPPacket pack(OCOPPacket::Call, chan, fu, arr );
     call( pack );
 }
 void OCOPClient::addChannel(const QCString& channel) {
     OCOPPacket pack(OCOPPacket::RegisterChannel, channel );
     call( pack );
diff --git a/x11/ipc/server/ocopserver.cpp b/x11/ipc/server/ocopserver.cpp
index 0f818b7..ee5ea18 100644
--- a/x11/ipc/server/ocopserver.cpp
+++ b/x11/ipc/server/ocopserver.cpp
@@ -164,13 +164,13 @@ void OCopServer::newOnClient( int fd ) {
      *
      */
     if (head.magic == 47 ) {
 //        qWarning("magic match");
         QCString channel( head.chlen+1 );
         QCString func( head.funclen+1 );
-        QByteArray data ( head.datalen );
+        QByteArray data ( head.datalen+1 );
 
         /*
          * we do not check for errors
          */
 //        qWarning("read ");
         int s = read(fd, channel.data(), head.chlen );
@@ -297,13 +297,13 @@ void OCopServer::dispatch( const OCOPPacket& packet, int sourceFD ) {
     case OCOPPacket::Return:
         break;
         /* not implemented :( */
     case OCOPPacket::Signal:
         break;
     case OCOPPacket::IsRegistered:
-        qWarning("IsRegistered");
+        qWarning("Server:IsRegistered %s", packet.channel().data() );
         isRegistered( packet.channel(), sourceFD );
         break;
     };
 }
 void OCopServer::errorOnServer() {
     /*
@@ -362,13 +362,13 @@ void OCopServer::delChannel( const QCString& channel,
             m_channels.replace( str, ints );
         }
         qWarning(" channel count is now %d", ints.count() );
     }
 }
 void OCopServer::isRegistered( const QCString& channel, int fd) {
-//    qWarning("isRegistered");
+    qWarning("Server:isRegistered %s", channel.data() );
     OCOPHead head;
     QCString func(2);
 
     memset(&head, 0, sizeof(head ) );
     head.magic = 47;
     head.type = OCOPPacket::IsRegistered;
@@ -376,14 +376,16 @@ void OCopServer::isRegistered( const QCString& channel, int fd) {
     head.funclen = func.size();
     head.datalen = 0;
 
     if ( isChannelRegistered( channel ) ) {
         //is registered
         func[0] = 1;
+	qWarning("Server:Channel is Registered %d", head.chlen);
     }else{
         func[0] = 0;
+	qWarning("Server:Channel is NotRegistered");
     }
 
     /**
      * write the head
      * and then channel
      * success/failure inside func
@@ -398,12 +400,13 @@ QValueList<int> OCopServer::clients( const QCString& channel ) {
 void OCopServer::call( const OCOPPacket& p, int ) {
     QValueList<int> cli = clients( p.channel() );
     QValueList<int>::Iterator it;
 
     OCOPHead head = p.head();
     for (it = cli.begin(); it != cli.end(); ++it ) {
+        qWarning("Server:calling %d %s %s", (*it), p.channel().data(), p.header().data() );
         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() );
     };
diff --git a/x11/libqpe-x11/qt/qcopchannel_qws.cpp b/x11/libqpe-x11/qt/qcopchannel_qws.cpp
index e90f056..1cea80c 100644
--- a/x11/libqpe-x11/qt/qcopchannel_qws.cpp
+++ b/x11/libqpe-x11/qt/qcopchannel_qws.cpp
@@ -1,37 +1,49 @@
 
 #include "../../ipc/client/ocopclient.h"
 
 #include <qcopchannel_qws.h>
 
 QList<QCopChannel>* QCopChannel::m_list = 0;
+QMap<QCString, int> QCopChannel::m_refCount;
 
 QCopChannel::QCopChannel( const QCString& channel, QObject* parent,
                           const char* name )
     : QObject( parent, name ),m_chan(channel) {
-    init();
     if (!m_list ) {
         m_list = new QList<QCopChannel>;
+        /* only connect once */
+        connect(OCOPClient::self(), SIGNAL(called(const QCString&, const QCString&, const QByteArray& ) ),
+                this, SLOT(rev(const QCString&, const QCString&, const QByteArray&) ) );
     }
+    /* first registration  or ref count is 0 for m_chan*/
+    if (!m_refCount.contains( m_chan ) || !m_refCount[m_chan]  ) {
+        m_refCount[m_chan] = 1;
+        OCOPClient::self()->addChannel( m_chan );
+    }else
+        m_refCount[m_chan]++;
+
     m_list->append(this);
 }
 void QCopChannel::receive( const QCString& msg, const QByteArray& ar ) {
     emit received( msg, ar );
 }
 QCopChannel::~QCopChannel() {
+    if (m_refCount[m_chan] == 1 ) {
+        OCOPClient::self()->delChannel( m_chan );
+        m_refCount[m_chan] = 0;
+    }else
+        m_refCount[m_chan]--;
+
+
     m_list->remove(this);
     if (m_list->count() == 0 ) {
         delete m_list;
         m_list = 0;
     }
-    OCOPClient::self()->delChannel( m_chan );
-}
-void QCopChannel::init() {
-    OCOPClient::self()->addChannel( m_chan );
-    connect(OCOPClient::self(), SIGNAL(called(const QCString&, const QCString&, const QByteArray& ) ),
-            this, SLOT(rev(const QCString&, const QCString&, const QByteArray&) ) );
+
 }
 QCString QCopChannel::channel()const {
     return m_chan;
 }
 bool QCopChannel::isRegistered( const QCString& chan) {;
     return OCOPClient::self()->isRegistered( chan );
@@ -44,20 +56,21 @@ bool QCopChannel::send( const QCString& chan, const QCString& msg,
                      const QByteArray& ar ) {
     OCOPClient::self()->send( chan, msg, ar );
     return true;
 }
 bool QCopChannel::sendLocally( const QCString& chann, const QCString& msg,
                                const QByteArray& ar ) {
+    qWarning("Client:sendLocally %s %s", chann.data(), msg.data() );
     if (!m_list )
         return true;
     QCopChannel* chan;
+
     for ( chan = m_list->first(); chan; chan = m_list->next() ) {
         if ( chan->channel() == chann )
             chan->receive( msg, ar );
     }
 
     return true;
 }
 void QCopChannel::rev( const QCString& chan, const QCString& msg, const QByteArray& ar ) {
-    if (chan == m_chan )
-        emit received(msg, ar );
+    sendLocally( chan, msg, ar );
 }
diff --git a/x11/libqpe-x11/qt/qcopchannel_qws.h b/x11/libqpe-x11/qt/qcopchannel_qws.h
index 94b199e..c1220cb 100644
--- a/x11/libqpe-x11/qt/qcopchannel_qws.h
+++ b/x11/libqpe-x11/qt/qcopchannel_qws.h
@@ -1,12 +1,13 @@
 #ifndef OPIE_QCOP_CHANNEL_QWS_H
 #define OPIE_QCOP_CHANNEL_QWS_H
 
 #include <qobject.h>
 #include <qcstring.h>
 #include <qlist.h>
+#include <qmap.h>
 
 class OCOPClient;
 class QCopChannel : public QObject {
     Q_OBJECT
 public:
     QCopChannel( const QCString& channel, QObject* parent = 0,
@@ -27,14 +28,15 @@ signals:
     void received( const QCString& msg, const QByteArray& );
 
 private slots:
     void rev( const QCString& chan, const QCString&, const QByteArray& );
 
 private:
-    void init();
+    bool isRegisteredLocally( const QCString& str);
     static QList<QCopChannel> *m_list;
+    static QMap<QCString, int> m_refCount;
     /* the channel */
     QCString m_chan;
     class Private;
     Private *d;
 
 };