some debug output

+ bugfix
besides some problems with the server IPC is working on X11
too

3 files changed, 9 insertions, 6 deletions

diff --git a/x11/ipc/client/ocopclient.cpp b/x11/ipc/client/ocopclient.cpp
index ac6e4a3..c1def73 100644
--- a/x11/ipc/client/ocopclient.cpp
+++ b/x11/ipc/client/ocopclient.cpp
@@ -86,65 +86,65 @@ OCOPPacket OCOPClient::packet() const{
     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, 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{
     /* 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();
 
     /* 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 ) {
     OCOPPacket pack(OCOPPacket::Call, chan, fu, arr );
     call( pack );
 }
 void OCOPClient::addChannel(const QCString& channel) {
     OCOPPacket pack(OCOPPacket::RegisterChannel, channel );
     call( pack );
 }
 void OCOPClient::delChannel(const QCString& chan ) {
     OCOPPacket pack(OCOPPacket::UnregisterChannel, chan );
     call( pack );
 }
 void OCOPClient::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() );
 }
 void OCOPClient::startUP() {
     qWarning("Start me up");
     pid_t pi = fork();
     if ( pi == 0 ) {
         setsid();
-        execlp("opie-ipc", "opie-ipc", NULL );
+        execlp("ocopserver", "ocopserver", NULL );
         _exit(1);
     }
 }
diff --git a/x11/ipc/server/ocopserver.cpp b/x11/ipc/server/ocopserver.cpp
index e76657e..421e49c 100644
--- a/x11/ipc/server/ocopserver.cpp
+++ b/x11/ipc/server/ocopserver.cpp
@@ -113,91 +113,91 @@ void OCopServer::newOnServer() {
     int fd = accept();
     if ( fd < 0 )
         return;
 
     /*
      * we got a successfull new connection
      * be happy
      * set SocketNotifier
      * connect it
      * and a OCOPClient
      */
     qWarning("Heureka new connection %d", fd );
 
 
     registerClient( fd );
 }
 int OCopServer::accept() {
     /*
      * accept it
      * the socket is currently blocking IIRC
      */
     return ::accept( m_serverfd,  (struct sockaddr*)&m_address, &m_adrlaenge );
 }
 void OCopServer::newOnClient( int fd ) {
-    int bug[4096];
-    //qWarning("new stuff for client on fd %d", fd );
     errno = 0;
     OCOPHead head;
     memset(&head, 0, sizeof(head) );
     int rea = ::read(fd, &head, sizeof(head) );
     //qWarning("read %d %d", rea,  errno);
     /*
      * I should get EPIPE but nothing like this happens
      * so if rea == 0 and we were signaled by the notifier
      * we close it and drop the clients...
      */
     if ( rea <= 0 ) {
         deregisterClient( fd );
         return;
     }
     /*
      * OCOPHead
      */
-    qWarning("data %s %d", bug, rea );
+    //qWarning("data %s %d", &bug, rea );
 
     /*
      * Check the magic
      * if chcked read till EOF if magic does not match
      * otherwise do read
      *  channel
      * func
      * data into mem
      * and then send the OCOPPacket
      *
      */
     if (head.magic == 47 ) {
         qWarning("magic match");
         QCString channel( head.chlen+1 );
         QCString func( head.funclen+1 );
         QByteArray data ( head.datalen );
 
         /*
          * we do not check for errors
          */
+        qWarning("read ");
         int s = read(fd, channel.data(), head.chlen );
         s = read(fd, func.data(), head.funclen );
         s = read(fd, data.data(), head.datalen );
+        qWarning("read");
 
         /* debug output */
         qWarning("channel %s %d", channel.data(), head.chlen );
         qWarning("func %s %d", func.data(), head.funclen );
         /* debug end */
 
         /*
          * now that we got the complete body
          * we need to make a package
          * and then we need to send it to clients
          * making a package is done here
          * dispatching it not
          */
         OCOPPacket packet( head.type, channel, func, data );
         dispatch( packet, fd );
 
     }else{
         qWarning("magic does not match");
         qWarning("magic %d", head.magic );
     }
 }
 void OCopServer::registerClient( int fd ) {
     if (m_clients.contains(fd) )
         return;
@@ -264,48 +264,49 @@ void OCopServer::dispatch( const OCOPPacket& packet, int sourceFD ) {
         deregisterClient(sourceFD );
         break;
     case OCOPPacket::Call:
         call( packet, sourceFD );
         break;
         /* not implemented */
     case OCOPPacket::Method:
         break;
         /* nit implemented */
     case OCOPPacket::Reply:
         break;
     case OCOPPacket::RegisterChannel:
         addChannel( packet.channel() , sourceFD );
         break;
     case OCOPPacket::UnregisterChannel:
         delChannel( packet.channel(), sourceFD );
         break;
         /* not implemented */
     case OCOPPacket::Return:
         break;
         /* not implemented :( */
     case OCOPPacket::Signal:
         break;
     case OCOPPacket::IsRegistered:
+        qWarning("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 );
 }
@@ -319,66 +320,67 @@ void OCopServer::addChannel( const QCString& channel,
     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) {
+    qWarning("isRegistered");
     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 ) {
+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 ) {
         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/ipc/server/ocopserver.pro b/x11/ipc/server/ocopserver.pro
index 1776063..e0a928c 100644
--- a/x11/ipc/server/ocopserver.pro
+++ b/x11/ipc/server/ocopserver.pro
@@ -1,9 +1,10 @@
 TEMPLATE	= app
+DESTDIR         = $(OPIEDIR)/bin
 CONFIG		= qt warn_on debug
 #CONFIG		= qt warn_on release
 HEADERS		= ../common/ocoppacket.h ocopclient.h ocopserver.h
 SOURCES		= ../common/ocoppacket.cpp main.cpp ocopserver.cpp
 INCLUDEPATH	+= $(OPIEDIR)/include
 DEPENDPATH	+= $(OPIEDIR)/include
 TARGET		= ocopserver