• Skip to content
• Skip to link menu

KDE 3.5 API Reference

• KDE API Reference
• API Reference

• Sitemap
• Contact Us

 

dcop

dcopserver.cpp

Go to the documentation of this file.

/*****************************************************************

#include "dcopserver.h"

Copyright (c) 1999,2000 Preston Brown <pbrown@kde.org>
Copyright (c) 1999,2000 Matthias Ettrich <ettrich@kde.org>
Copyright (c) 1999,2001 Waldo Bastian <bastian@kde.org>

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

******************************************************************/

#include <config.h>

#include <sys/types.h>
#ifdef HAVE_SYS_STAT_H
#include <sys/stat.h>
#endif
#ifdef HAVE_SYS_PARAM_H
#include <sys/param.h>
#endif
#include <sys/resource.h>
#include <sys/socket.h>

#include <unistd.h>
#include <stdlib.h>
#include <signal.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#ifdef HAVE_LIMITS_H
#include <limits.h>
#endif

#define QT_CLEAN_NAMESPACE 1
#include <qfile.h>
#include <qtextstream.h>
#include <qdatastream.h>
#include <qptrstack.h>
#include <qtimer.h>

#include "dcopserver.h"

#include <dcopsignals.h>
#include <dcopclient.h>
#include <dcopglobal.h>
#include "dcop-path.h"

#ifdef DCOP_LOG
#undef Unsorted
#include <qdir.h>
#include <string.h>
#endif

// #define DCOP_DEBUG

DCOPServer* the_server;

template class QDict<DCOPConnection>;
template class QPtrDict<DCOPConnection>;
template class QPtrList<DCOPListener>;

#define _DCOPIceSendBegin(x)    \
   int fd = IceConnectionNumber( x );       \
   long fd_fl = fcntl(fd, F_GETFL, 0);      \
   fcntl(fd, F_SETFL, fd_fl | O_NDELAY);
#define _DCOPIceSendEnd()   \
   fcntl(fd, F_SETFL, fd_fl);

static QCString findDcopserverShutdown()
{
#ifdef Q_OS_WIN32
    char szPath[512];
    char *pszFilePart;
    int ret;
    ret = SearchPathA(NULL,"dcopserver_shutdown","exe",sizeof(szPath)/sizeof(szPath[0]),szPath,&pszFilePart);
    if(ret != 0)
        return QCString(szPath);
#else
   QCString path = getenv("PATH");
   char *dir = strtok(path.data(), ":");
   while (dir)
   {
      QCString file = dir;
      file += "/dcopserver_shutdown";
      if (access(file.data(), X_OK) == 0)
         return file;
      dir = strtok(NULL, ":");
   }
   QCString file = DCOP_PATH;
   file += "/dcopserver_shutdown";
   if (access(file.data(), X_OK) == 0)
      return file;
#endif
   return QCString("dcopserver_shutdown");
}

static Bool HostBasedAuthProc ( char* /*hostname*/)
{
    return false; // no host based authentication
}

extern "C" {
extern IceWriteHandler _kde_IceWriteHandler;
extern IceIOErrorHandler _kde_IceIOErrorHandler;
void DCOPIceWriteChar(register IceConn iceConn, unsigned long nbytes, char *ptr);
}

static QCString readQCString(QDataStream &ds)
{
   QCString result;
   Q_UINT32 len;
   ds >> len;
   QIODevice *device = ds.device();
   int bytesLeft = device->size()-device->at();
   if ((bytesLeft < 0 ) || (len > (uint) bytesLeft))
   {
      qWarning("Corrupt data!\n");
      return result;
   }
   result.QByteArray::resize( (uint)len );
   if (len > 0)
      ds.readRawBytes( result.data(), (uint)len);
   return result;
}

static QByteArray readQByteArray(QDataStream &ds)
{
   QByteArray result;
   Q_UINT32 len;
   ds >> len;
   QIODevice *device = ds.device();
   int bytesLeft = device->size()-device->at();
   if ((bytesLeft < 0 ) || (len > (uint) bytesLeft))
   {
      qWarning("Corrupt data!\n");
      return result;
   }
   result.resize( (uint)len );
   if (len > 0)
      ds.readRawBytes( result.data(), (uint)len);
   return result;
}


extern "C" {
extern int _kde_IceTransWrite (void * ciptr, char *buf, int size);
}

static unsigned long writeIceData(IceConn iceConn, unsigned long nbytes, char *ptr)
{
    int fd = IceConnectionNumber(iceConn);
    unsigned long nleft = nbytes;
    while (nleft > 0)
    {
    int nwritten;

    if (iceConn->io_ok)
    {
        nwritten = send(fd, ptr, (int) nleft, 0);
    }
    else
        return 0;

    if (nwritten <= 0)
    {
            if (errno == EINTR)
               continue;

            if (errno == EAGAIN)
               return nleft;

        /*
         * Fatal IO error.  First notify each protocol's IceIOErrorProc
         * callback, then invoke the application IO error handler.
         */

        iceConn->io_ok = False;

        if (iceConn->connection_status == IceConnectPending)
        {
        /*
         * Don't invoke IO error handler if we are in the
         * middle of a connection setup.
         */

        return 0;
        }

        if (iceConn->process_msg_info)
        {
        int i;

        for (i = iceConn->his_min_opcode;
             i <= iceConn->his_max_opcode; i++)
        {
            _IceProcessMsgInfo *process;

            process = &iceConn->process_msg_info[
            i - iceConn->his_min_opcode];

            if (process->in_use)
            {
            IceIOErrorProc IOErrProc = process->accept_flag ?
                process->protocol->accept_client->io_error_proc :
                process->protocol->orig_client->io_error_proc;

            if (IOErrProc)
                (*IOErrProc) (iceConn);
            }
        }
        }

        (*_kde_IceIOErrorHandler) (iceConn);
        return 0;
    }

    nleft -= nwritten;
    ptr   += nwritten;
    }
    return 0;
}

void DCOPIceWriteChar(register IceConn iceConn, unsigned long nbytes, char *ptr)
{
    DCOPConnection* conn = the_server->findConn( iceConn );
#ifdef DCOP_DEBUG
qWarning("DCOPServer: DCOPIceWriteChar() Writing %d bytes to %d [%s]", nbytes, fd, conn ? conn->appId.data() : "<unknown>");
#endif

    if (conn)
    {
       if (conn->outputBlocked)
       {
          QByteArray _data(nbytes);
          memcpy(_data.data(), ptr, nbytes);
#ifdef DCOP_DEBUG
qWarning("DCOPServer: _IceWrite() outputBlocked. Queuing %d bytes.", _data.size());
#endif
          conn->outputBuffer.append(_data);
          return;
       }
       // assert(conn->outputBuffer.isEmpty());
    }

    unsigned long nleft = writeIceData(iceConn, nbytes, ptr);
    if ((nleft > 0) && conn)
    {
        QByteArray _data(nleft);
        memcpy(_data.data(), ptr, nleft);
        conn->waitForOutputReady(_data, 0);
        return;
    }
}

static void DCOPIceWrite(IceConn iceConn, const QByteArray &_data)
{
    DCOPConnection* conn = the_server->findConn( iceConn );
#ifdef DCOP_DEBUG
qWarning("DCOPServer: DCOPIceWrite() Writing %d bytes to %d [%s]", _data.size(), fd, conn ? conn->appId.data() : "<unknown>");
#endif
    if (conn)
    {
       if (conn->outputBlocked)
       {
#ifdef DCOP_DEBUG
qWarning("DCOPServer: DCOPIceWrite() outputBlocked. Queuing %d bytes.", _data.size());
#endif
          conn->outputBuffer.append(_data);
          return;
       }
       // assert(conn->outputBuffer.isEmpty());
    }

    unsigned long nleft = writeIceData(iceConn, _data.size(), _data.data());
    if ((nleft > 0) && conn)
    {
        conn->waitForOutputReady(_data, _data.size() - nleft);
        return;
    }
}

void DCOPConnection::waitForOutputReady(const QByteArray &_data, int start)
{
#ifdef DCOP_DEBUG
qWarning("DCOPServer: waitForOutputReady fd = %d datasize = %d start = %d", socket(), _data.size(), start);
#endif
   outputBlocked = true;
   outputBuffer.append(_data);
   outputBufferStart = start;
   if (!outputBufferNotifier)
   {
      outputBufferNotifier = new QSocketNotifier(socket(), Write);
      connect(outputBufferNotifier, SIGNAL(activated(int)),
              the_server, SLOT(slotOutputReady(int)));
   }
   outputBufferNotifier->setEnabled(true);
   return;
}

void DCOPServer::slotOutputReady(int socket)
{
#ifdef DCOP_DEBUG
qWarning("DCOPServer: slotOutputReady fd = %d", socket);
#endif
   // Find out connection.
   DCOPConnection *conn = fd_clients.find(socket);
   //assert(conn);
   //assert(conn->outputBlocked);
   //assert(conn->socket() == socket);
   // Forward
   conn->slotOutputReady();
}


void DCOPConnection::slotOutputReady()
{
   //assert(outputBlocked);
   //assert(!outputBuffer.isEmpty());

   QByteArray data = outputBuffer.first();

   int fd = socket();

   long fd_fl = fcntl(fd, F_GETFL, 0);
   fcntl(fd, F_SETFL, fd_fl | O_NDELAY);
   /*
    Use special write handling on windows platform. The write function from
    the runtime library (on MSVC) does not allow to write on sockets.
   */
   int nwritten;
   nwritten = ::send(fd,data.data()+outputBufferStart,data.size()-outputBufferStart,0);
   
   int e = errno;
   fcntl(fd, F_SETFL, fd_fl);

#ifdef DCOP_DEBUG
qWarning("DCOPServer: slotOutputReady() %d bytes written", nwritten);
#endif

   if (nwritten < 0)
   {
      if ((e == EINTR) || (e == EAGAIN))
         return;
      (*_kde_IceIOErrorHandler) (iceConn);
      return;
   }
   outputBufferStart += nwritten;

   if (outputBufferStart == data.size())
   {
      outputBufferStart = 0;
      outputBuffer.remove(outputBuffer.begin());
      if (outputBuffer.isEmpty())
      {
#ifdef DCOP_DEBUG
qWarning("DCOPServer: slotOutputRead() all data transmitted.");
#endif
         outputBlocked = false;
         outputBufferNotifier->setEnabled(false);
      }
#ifdef DCOP_DEBUG
else
{
qWarning("DCOPServer: slotOutputRead() more data to send.");
}
#endif
   }
}

static void DCOPIceSendData(register IceConn _iceConn,
                            const QByteArray &_data)
{
   if (_iceConn->outbufptr > _iceConn->outbuf)
   {
#ifdef DCOP_DEBUG
qWarning("DCOPServer: Flushing data, fd = %d", IceConnectionNumber(_iceConn));
#endif
      IceFlush( _iceConn );
   }
   DCOPIceWrite(_iceConn, _data);
}

class DCOPListener : public QSocketNotifier
{
public:
    DCOPListener( IceListenObj obj )
    : QSocketNotifier( IceGetListenConnectionNumber( obj ),
               QSocketNotifier::Read, 0, 0)
{
    listenObj = obj;
}

    IceListenObj listenObj;
};

DCOPConnection::DCOPConnection( IceConn conn )
    : QSocketNotifier( IceConnectionNumber( conn ),
               QSocketNotifier::Read, 0, 0 )
{
    iceConn = conn;
    notifyRegister = 0;
    _signalConnectionList = 0;
    daemon = false;
    outputBlocked = false;
    outputBufferNotifier = 0;
    outputBufferStart = 0;
}

DCOPConnection::~DCOPConnection()
{
    delete _signalConnectionList;
    delete outputBufferNotifier;
}

DCOPSignalConnectionList *
DCOPConnection::signalConnectionList()
{
    if (!_signalConnectionList)
       _signalConnectionList = new DCOPSignalConnectionList;
    return _signalConnectionList;
}

static IceAuthDataEntry *authDataEntries;
static char *addAuthFile;

static IceListenObj *listenObjs;
static int numTransports;
static int ready[2];


/* for printing hex digits */
static void fprintfhex (FILE *fp, unsigned int len, char *cp)
{
    static char hexchars[] = "0123456789abcdef";

    for (; len > 0; len--, cp++) {
    unsigned char s = *cp;
    putc(hexchars[s >> 4], fp);
    putc(hexchars[s & 0x0f], fp);
    }
}

/*
 * We use temporary files which contain commands to add entries to
 * the .ICEauthority file.
 */
static void
write_iceauth (FILE *addfp, IceAuthDataEntry *entry)
{
    fprintf (addfp,
         "add %s \"\" %s %s ",
         entry->protocol_name,
         entry->network_id,
         entry->auth_name);
    fprintfhex (addfp, entry->auth_data_length, entry->auth_data);
    fprintf (addfp, "\n");
}

#ifndef HAVE_MKSTEMPS
#include <string.h>
#include <strings.h>

/* this is based on code taken from the GNU libc, distributed under the LGPL license */

/* Generate a unique temporary file name from TEMPLATE.

   TEMPLATE has the form:

   <path>/ccXXXXXX<suffix>

   SUFFIX_LEN tells us how long <suffix> is (it can be zero length).

   The last six characters of TEMPLATE before <suffix> must be "XXXXXX";
   they are replaced with a string that makes the filename unique.

   Returns a file descriptor open on the file for reading and writing.  */

int mkstemps (char* _template, int suffix_len)
{
  static const char letters[] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
  char *XXXXXX;
  int len;
  int count;
  int value;

  len = strlen (_template);

  if ((int) len < 6 + suffix_len || strncmp (&_template[len - 6 - suffix_len], "XXXXXX", 6))
      return -1;

  XXXXXX = &_template[len - 6 - suffix_len];

  value = rand();
  for (count = 0; count < 256; ++count)
  {
      int v = value;
      int fd;

      /* Fill in the random bits.  */
      XXXXXX[0] = letters[v % 62];
      v /= 62;
      XXXXXX[1] = letters[v % 62];
      v /= 62;
      XXXXXX[2] = letters[v % 62];
      v /= 62;
      XXXXXX[3] = letters[v % 62];
      v /= 62;
      XXXXXX[4] = letters[v % 62];
      v /= 62;
      XXXXXX[5] = letters[v % 62];

      fd = open (_template, O_RDWR|O_CREAT|O_EXCL, 0600);
      if (fd >= 0)
    /* The file does not exist.  */
    return fd;

      /* This is a random value.  It is only necessary that the next
     TMP_MAX values generated by adding 7777 to VALUE are different
     with (module 2^32).  */
      value += 7777;
    }
  /* We return the null string if we can't find a unique file name.  */
  _template[0] = '\0';
  return -1;
}

#endif

static char *unique_filename (const char *path, const char *prefix, int *pFd)
{
    char tempFile[PATH_MAX];
    char *ptr;

#ifdef Q_OS_WIN
    snprintf (tempFile, PATH_MAX, "%s\\%sXXXXXX", path, prefix);
#else
    snprintf (tempFile, PATH_MAX, "%s/%sXXXXXX", path, prefix);
#endif
    ptr = static_cast<char *>(malloc(strlen(tempFile) + 1));
    if (ptr != NULL)
    {
        int fd = mkstemps(tempFile, 0);
        if(fd >= 0)
        {
            *pFd = fd;
        strcpy(ptr, tempFile);
        }
        else
        {
            free(ptr);
            ptr = NULL;
        }
    }
    return ptr;
}

#define MAGIC_COOKIE_LEN 16

Status
SetAuthentication (int count, IceListenObj *_listenObjs,
           IceAuthDataEntry **_authDataEntries)
{
    FILE        *addfp = NULL;
    const char  *path;
    int         original_umask;
    int         i;
    QCString command;
    int         fd;

    original_umask = umask (0077);      /* disallow non-owner access */

#ifdef Q_OS_WIN
    char temppath[512];
    DWORD dw = GetTempPathA(sizeof(temppath),temppath);
    if(dw != 0)
    {
        temppath[dw - 1] = 0;
        path = temppath;
    }
    else
        path = ".";
#else
    path = getenv ("DCOP_SAVE_DIR");
    if (!path)
    path = "/tmp";
#endif
    if ((addAuthFile = unique_filename (path, "dcop", &fd)) == NULL)
    goto bad;

    if (!(addfp = fdopen(fd, "wb")))
    goto bad;

    if ((*_authDataEntries = static_cast<IceAuthDataEntry *>(malloc (count * 2 * sizeof (IceAuthDataEntry)))) == NULL)
    goto bad;

    for (i = 0; i < numTransports * 2; i += 2) {
    (*_authDataEntries)[i].network_id =
        IceGetListenConnectionString (_listenObjs[i/2]);
    (*_authDataEntries)[i].protocol_name = const_cast<char *>("ICE");
    (*_authDataEntries)[i].auth_name = const_cast<char *>("MIT-MAGIC-COOKIE-1");

    (*_authDataEntries)[i].auth_data =
        IceGenerateMagicCookie (MAGIC_COOKIE_LEN);
    (*_authDataEntries)[i].auth_data_length = MAGIC_COOKIE_LEN;

    (*_authDataEntries)[i+1].network_id =
        IceGetListenConnectionString (_listenObjs[i/2]);
    (*_authDataEntries)[i+1].protocol_name = const_cast<char *>("DCOP");
    (*_authDataEntries)[i+1].auth_name = const_cast<char *>("MIT-MAGIC-COOKIE-1");

    (*_authDataEntries)[i+1].auth_data =
        IceGenerateMagicCookie (MAGIC_COOKIE_LEN);
    (*_authDataEntries)[i+1].auth_data_length = MAGIC_COOKIE_LEN;

    write_iceauth (addfp, &(*_authDataEntries)[i]);
    write_iceauth (addfp, &(*_authDataEntries)[i+1]);

    IceSetPaAuthData (2, &(*_authDataEntries)[i]);

    IceSetHostBasedAuthProc (_listenObjs[i/2], HostBasedAuthProc);
    }

    fclose (addfp);

    umask (original_umask);

    command = DCOPClient::iceauthPath();

    if (command.isEmpty())
    {
       fprintf( stderr, "dcopserver: 'iceauth' not found in path, aborting.\n" );
       exit(1);
    }

    command += " source ";
    command += addAuthFile;
    system (command);

    unlink(addAuthFile);

    return (1);

 bad:

    if (addfp)
    fclose (addfp);

    if (addAuthFile) {
    unlink(addAuthFile);
    free(addAuthFile);
    }

    umask (original_umask);

    return (0);
}

/*
 * Free up authentication data.
 */
void
FreeAuthenticationData(int count, IceAuthDataEntry *_authDataEntries)
{
    /* Each transport has entries for ICE and XSMP */
    int i;

    for (i = 0; i < count * 2; i++) {
    free (_authDataEntries[i].network_id);
    free (_authDataEntries[i].auth_data);
    }

    free(_authDataEntries);
    free(addAuthFile);
}

void DCOPWatchProc ( IceConn iceConn, IcePointer client_data, Bool opening, IcePointer* watch_data)
{
    DCOPServer* ds = static_cast<DCOPServer*>(client_data);

    if (opening) {
    *watch_data = static_cast<IcePointer>(ds->watchConnection( iceConn ));
    }
    else  {
    ds->removeConnection( static_cast<void*>(*watch_data) );
    }
}

void DCOPProcessMessage( IceConn iceConn, IcePointer /*clientData*/,
             int opcode, unsigned long length, Bool swap)
{
    the_server->processMessage( iceConn, opcode, length, swap );
}

void DCOPServer::processMessage( IceConn iceConn, int opcode,
                 unsigned long length, Bool /*swap*/)
{
    DCOPConnection* conn = clients.find( iceConn );
    if ( !conn ) {
    qWarning("DCOPServer::processMessage message from unknown connection. [opcode = %d]", opcode);
    return;
    }
    switch( opcode ) {
    case DCOPSend:
    case DCOPReplyDelayed:
    {
        DCOPMsg *pMsg = 0;
        IceReadMessageHeader(iceConn, sizeof(DCOPMsg), DCOPMsg, pMsg);
        CARD32 key = pMsg->key;
        QByteArray ba( length );
        IceReadData(iceConn, length, ba.data() );
        QDataStream ds( ba, IO_ReadOnly );
        QCString fromApp = readQCString(ds);
            QCString toApp = readQCString(ds);

        DCOPConnection* target = findApp( toApp );
        int datalen = ba.size();
        if ( opcode == DCOPReplyDelayed ) {
        if ( !target )
            qWarning("DCOPServer::DCOPReplyDelayed for unknown connection.");
        else if ( !conn )
            qWarning("DCOPServer::DCOPReplyDelayed from unknown connection.");
        else if (!conn->waitingForDelayedReply.removeRef( target->iceConn ))
            qWarning("DCOPServer::DCOPReplyDelayed from/to does not match. (#2)");
                else if (!target->waitingOnReply.removeRef(iceConn))
                       qWarning("DCOPServer::DCOPReplyDelayed for client who wasn't waiting on one!");
        }
        if ( target ) {
#ifdef DCOP_DEBUG
if (opcode == DCOPSend)
{
   QCString obj = readQCString(ds);
   QCString fun = readQCString(ds);
   qWarning("Sending %d bytes from %s to %s. DCOPSend %s", length, fromApp.data(), toApp.data(), fun.data());
}
#endif
        IceGetHeader( target->iceConn, majorOpcode, opcode,
                  sizeof(DCOPMsg), DCOPMsg, pMsg );
        pMsg->key = key;
        pMsg->length += datalen;
        _DCOPIceSendBegin( target->iceConn );
        DCOPIceSendData(target->iceConn, ba);
                _DCOPIceSendEnd();
        } else if ( toApp == "DCOPServer" ) {
        QCString obj = readQCString(ds);
        QCString fun = readQCString(ds);
        QByteArray data = readQByteArray(ds);

        QCString replyType;
        QByteArray replyData;
        if ( !receive( toApp, obj, fun, data, replyType, replyData, iceConn ) ) {
            qWarning("%s failure: object '%s' has no function '%s'", toApp.data(), obj.data(), fun.data() );
        }
        } else if ( toApp[toApp.length()-1] == '*') {
#ifdef DCOP_DEBUG
if (opcode == DCOPSend)
{
   QCString obj = readQCString(ds);
   QCString fun = readQCString(ds);
   qWarning("Sending %d bytes from %s to %s. DCOPSend %s", length, fromApp.data(), toApp.data(), fun.data());
}
#endif
        // handle a multicast.
        QAsciiDictIterator<DCOPConnection> aIt(appIds);
        int l = toApp.length()-1;
        for ( ; aIt.current(); ++aIt) {
            DCOPConnection *client = aIt.current();
            if (!l || (strncmp(client->appId.data(), toApp.data(), l) == 0))
            {
                IceGetHeader(client->iceConn, majorOpcode, DCOPSend,
                     sizeof(DCOPMsg), DCOPMsg, pMsg);
                pMsg->key = key;
                pMsg->length += datalen;
                _DCOPIceSendBegin( client->iceConn );
                DCOPIceSendData(client->iceConn, ba);
                            _DCOPIceSendEnd();
            }
        }
        }
    }
    break;
    case DCOPCall:
    case DCOPFind:
    {
        DCOPMsg *pMsg = 0;
        IceReadMessageHeader(iceConn, sizeof(DCOPMsg), DCOPMsg, pMsg);
        CARD32 key = pMsg->key;
        QByteArray ba( length );
        IceReadData(iceConn, length, ba.data() );
        QDataStream ds( ba, IO_ReadOnly );
        QCString fromApp = readQCString(ds);
        QCString toApp = readQCString(ds);
        DCOPConnection* target = findApp( toApp );
        int datalen = ba.size();

        if ( target ) {
#ifdef DCOP_DEBUG
if (opcode == DCOPCall)
{
   QCString obj = readQCString(ds);
   QCString fun = readQCString(ds);
   qWarning("Sending %d bytes from %s to %s. DCOPCall %s", length, fromApp.data(), toApp.data(), fun.data());
}
#endif
        target->waitingForReply.append( iceConn );
                conn->waitingOnReply.append( target->iceConn);

        IceGetHeader( target->iceConn, majorOpcode, opcode,
                  sizeof(DCOPMsg), DCOPMsg, pMsg );
        pMsg->key = key;
        pMsg->length += datalen;
        _DCOPIceSendBegin( target->iceConn );
        DCOPIceSendData(target->iceConn, ba);
                _DCOPIceSendEnd();
        } else {
        QCString replyType;
        QByteArray replyData;
        bool b = false;
        // DCOPServer itself does not do DCOPFind.
        if ( (opcode == DCOPCall) && (toApp == "DCOPServer") ) {
            QCString obj = readQCString(ds);
            QCString fun = readQCString(ds);
            QByteArray data = readQByteArray(ds);
            b = receive( toApp, obj, fun, data, replyType, replyData, iceConn );
            if ( !b )
            qWarning("%s failure: object '%s' has no function '%s'", toApp.data(), obj.data(), fun.data() );
        }

        if (b) {
            QByteArray reply;
            QDataStream replyStream( reply, IO_WriteOnly );
            replyStream << toApp << fromApp << replyType << replyData.size();
            int replylen = reply.size() + replyData.size();
            IceGetHeader( iceConn, majorOpcode, DCOPReply,
                  sizeof(DCOPMsg), DCOPMsg, pMsg );
            if ( key != 0 )
            pMsg->key = key;
            else
            pMsg->key = serverKey++;
            pMsg->length += replylen;
                    _DCOPIceSendBegin( iceConn );
            DCOPIceSendData( iceConn, reply);
            DCOPIceSendData( iceConn, replyData);
                    _DCOPIceSendEnd();
        } else {
            QByteArray reply;
            QDataStream replyStream( reply, IO_WriteOnly );
            replyStream << toApp << fromApp;
            IceGetHeader( iceConn, majorOpcode, DCOPReplyFailed,
                  sizeof(DCOPMsg), DCOPMsg, pMsg );
            if ( key != 0 )
            pMsg->key = key;
            else
            pMsg->key = serverKey++;
            pMsg->length += reply.size();
                    _DCOPIceSendBegin( iceConn );
            DCOPIceSendData( iceConn, reply );
                    _DCOPIceSendEnd();
        }
        }
    }
    break;
    case DCOPReply:
    case DCOPReplyFailed:
    case DCOPReplyWait:
    {
        DCOPMsg *pMsg = 0;
        IceReadMessageHeader(iceConn, sizeof(DCOPMsg), DCOPMsg, pMsg);
        CARD32 key = pMsg->key;
        QByteArray ba( length );
        IceReadData(iceConn, length, ba.data() );
        QDataStream ds( ba, IO_ReadOnly );
            QCString fromApp = readQCString(ds);
            QCString toApp = readQCString(ds);

        DCOPConnection* connreply = findApp( toApp );
        int datalen = ba.size();

        if ( !connreply )
        qWarning("DCOPServer::DCOPReply for unknown connection.");
        else {
        conn->waitingForReply.removeRef( connreply->iceConn );
        if ( opcode == DCOPReplyWait )
                {
            conn->waitingForDelayedReply.append( connreply->iceConn );
                }
                else
                { // DCOPReply or DCOPReplyFailed
                    if (!connreply->waitingOnReply.removeRef(iceConn))
                       qWarning("DCOPServer::DCOPReply from %s to %s who wasn't waiting on one!",
                               fromApp.data(), toApp.data());
                }
        IceGetHeader( connreply->iceConn, majorOpcode, opcode,
                  sizeof(DCOPMsg), DCOPMsg, pMsg );
        pMsg->key = key;
        pMsg->length += datalen;
                _DCOPIceSendBegin( connreply->iceConn );
        DCOPIceSendData(connreply->iceConn, ba);
                _DCOPIceSendEnd();
        }
    }
    break;
    default:
    qWarning("DCOPServer::processMessage unknown message");
    }
}

static const IcePaVersionRec DCOPServerVersions[] = {
    { DCOPVersionMajor, DCOPVersionMinor,  DCOPProcessMessage }
};

static const IcePoVersionRec DUMMYVersions[] = {
    { DCOPVersionMajor, DCOPVersionMinor, 0 }
};

static Status DCOPServerProtocolSetupProc ( IceConn /*iceConn*/,
                        int majorVersion, int minorVersion,
                        char* vendor, char* release,
                        IcePointer *clientDataRet,
                        char ** /*failureReasonRet*/)
{
    /*
     * vendor/release are undefined for ProtocolSetup in DCOP
     */

    if (vendor)
    free (vendor);
    if (release)
    free (release);

    *clientDataRet = 0;

    return (majorVersion == DCOPVersionMajor && minorVersion == DCOPVersionMinor);
}

#ifndef Q_OS_WIN
static int pipeOfDeath[2];

static void sighandler(int sig)
{
    if (sig == SIGHUP) {
    signal(SIGHUP, sighandler);
    return;
    }

    write(pipeOfDeath[1], "x", 1);
}
#endif

extern "C"
{
    extern int _kde_IceLastMajorOpcode; // from libICE
}

DCOPServer::DCOPServer(bool _suicide)
    : QObject(0,0), currentClientNumber(0), appIds(263), clients(263)
{
    serverKey = 42;

    suicide = _suicide;
    shutdown = false;

    dcopSignals = new DCOPSignals;

    if (_kde_IceLastMajorOpcode < 1 )
        IceRegisterForProtocolSetup(const_cast<char *>("DUMMY"),
                    const_cast<char *>("DUMMY"),
                    const_cast<char *>("DUMMY"),
                    1, const_cast<IcePoVersionRec *>(DUMMYVersions),
                    DCOPAuthCount, const_cast<char **>(DCOPAuthNames),
                    DCOPClientAuthProcs, 0);
    if (_kde_IceLastMajorOpcode < 1 )
    qWarning("DCOPServer Error: incorrect major opcode!");

    the_server = this;
    if (( majorOpcode = IceRegisterForProtocolReply (const_cast<char *>("DCOP"),
                             const_cast<char *>(DCOPVendorString),
                             const_cast<char *>(DCOPReleaseString),
                             1, const_cast<IcePaVersionRec *>(DCOPServerVersions),
                             1, const_cast<char **>(DCOPAuthNames),
                             DCOPServerAuthProcs,
                             HostBasedAuthProc,
                             DCOPServerProtocolSetupProc,
                             NULL,  /* IceProtocolActivateProc - we don't care about
                                   when the Protocol Reply is sent, because the
                                   session manager can not immediately send a
                                   message - it must wait for RegisterClient. */
                             NULL   /* IceIOErrorProc */
                             )) < 0)
    {
        qWarning("Could not register DCOP protocol with ICE");
    }

    char errormsg[256];
    int orig_umask = umask(077); /*old libICE's don't reset the umask() they set */
    if (!IceListenForConnections (&numTransports, &listenObjs,
                  256, errormsg))
    {
        fprintf (stderr, "%s\n", errormsg);
        exit (1);
    } else {
        (void) umask(orig_umask);
        // publish available transports.
        QCString fName = DCOPClient::dcopServerFile();
        FILE *f;
        if(!(f = ::fopen(fName.data(), "w+"))) {
            fprintf (stderr, "Can not create file %s: %s\n",
             fName.data(), ::strerror(errno));
        exit(1);
        }
        char *idlist = IceComposeNetworkIdList(numTransports, listenObjs);
        if (idlist != 0) {
            fprintf(f, "%s", idlist);
        free(idlist);
        }
        fprintf(f, "\n%i\n", getpid());
        fclose(f);
#ifndef Q_OS_WIN32
        if (QCString(getenv("DCOPAUTHORITY")).isEmpty())
        {
                // Create a link named like the old-style (KDE 2.x) naming
                QCString compatName = DCOPClient::dcopServerFileOld();
                ::symlink(fName,compatName);
            }
#endif // Q_OS_WIN32
    }

#if 0
    if (!SetAuthentication_local(numTransports, listenObjs))
        qFatal("DCOPSERVER: authentication setup failed.");
#endif
    if (!SetAuthentication(numTransports, listenObjs, &authDataEntries))
        qFatal("DCOPSERVER: authentication setup failed.");

    IceAddConnectionWatch (DCOPWatchProc, static_cast<IcePointer>(this));
    _IceWriteHandler = DCOPIceWriteChar;

    listener.setAutoDelete( true );
    DCOPListener* con;
    for ( int i = 0; i < numTransports; i++) {
    con = new DCOPListener( listenObjs[i] );
    listener.append( con );
    connect( con, SIGNAL( activated(int) ), this, SLOT( newClient(int) ) );
    }
    char c = 0;
    write(ready[1], &c, 1); // dcopserver is started
    close(ready[1]);

    m_timer =  new QTimer(this);
    connect( m_timer, SIGNAL(timeout()), this, SLOT(slotTerminate()) );
    m_deadConnectionTimer = new QTimer(this);
    connect( m_deadConnectionTimer, SIGNAL(timeout()), this, SLOT(slotCleanDeadConnections()) );

#ifdef Q_OS_WIN
    char szEventName[256];
    sprintf(szEventName,"dcopserver%i",GetCurrentProcessId());
    m_evTerminate = CreateEventA(NULL,TRUE,FALSE,(LPCSTR)szEventName);
    ResetEvent(m_evTerminate);
    m_hTerminateThread = CreateThread(NULL,0,TerminatorThread,this,0,&m_dwTerminateThreadId);
    if(m_hTerminateThread)
        CloseHandle(m_hTerminateThread);
#endif

#ifdef DCOP_LOG
    char hostname_buffer[256];
    memset( hostname_buffer, 0, sizeof( hostname_buffer ) );
    if ( gethostname( hostname_buffer, 255 ) < 0 )
      hostname_buffer[0] = '\0';
    m_logger = new QFile( QString( "%1/.dcop-%2.log" ).arg( QDir::homeDirPath() ).arg( hostname_buffer ) );
    if ( m_logger->open( IO_WriteOnly ) ) {
        m_stream = new QTextStream( m_logger );
    }
#endif
}

DCOPServer::~DCOPServer()
{
    system(findDcopserverShutdown()+" --nokill");
    IceFreeListenObjs(numTransports, listenObjs);
    FreeAuthenticationData(numTransports, authDataEntries);
    delete dcopSignals;
#ifdef DCOP_LOG
    delete m_stream;
    m_logger->close();
    delete m_logger;
#endif
#ifdef Q_OS_WIN
    SetEvent(m_evTerminate);
    CloseHandle(m_evTerminate);
#endif
}

DCOPConnection* DCOPServer::findApp( const QCString& appId )
{
    if ( appId.isNull() )
    return 0;
    DCOPConnection* conn = appIds.find( appId );
    return conn;
}

void DCOPServer::slotCleanDeadConnections()
{
qWarning("DCOP Cleaning up dead connections.");
    while(!deadConnections.isEmpty())
    {
       IceConn iceConn = deadConnections.take(0);
       IceSetShutdownNegotiation (iceConn, False);
       (void) IceCloseConnection( iceConn );
    }
}

void DCOPServer::ioError( IceConn iceConn  )
{
    deadConnections.removeRef(iceConn);
    deadConnections.prepend(iceConn);
    m_deadConnectionTimer->start(0, true);
}


void DCOPServer::processData( int /*socket*/ )
{
    IceConn iceConn = static_cast<const DCOPConnection*>(sender())->iceConn;
    IceProcessMessagesStatus status = IceProcessMessages( iceConn, 0, 0 );
    if ( status == IceProcessMessagesIOError ) {
        deadConnections.removeRef(iceConn);
        if (deadConnections.isEmpty())
           m_deadConnectionTimer->stop();
    IceSetShutdownNegotiation (iceConn, False);
    (void) IceCloseConnection( iceConn );
    }
}

void DCOPServer::newClient( int /*socket*/ )
{
    IceAcceptStatus status;
    IceConn iceConn = IceAcceptConnection( static_cast<const  DCOPListener*>(sender())->listenObj, &status);
    if (!iceConn) {
      if (status == IceAcceptBadMalloc)
     qWarning("Failed to alloc connection object!\n");
      else // IceAcceptFailure
         qWarning("Failed to accept ICE connection!\n");
      return;
    }

    IceSetShutdownNegotiation( iceConn, False );

    IceConnectStatus cstatus;
    while ((cstatus = IceConnectionStatus (iceConn))==IceConnectPending) {
    (void) IceProcessMessages( iceConn, 0, 0 );
    }

    if (cstatus != IceConnectAccepted) {
    if (cstatus == IceConnectIOError)
        qWarning ("IO error opening ICE Connection!\n");
    else
        qWarning ("ICE Connection rejected!\n");
        deadConnections.removeRef(iceConn);
    (void) IceCloseConnection (iceConn);
    }
}

void* DCOPServer::watchConnection( IceConn iceConn )
{
    DCOPConnection* con = new DCOPConnection( iceConn );
    connect( con, SIGNAL( activated(int) ), this, SLOT( processData(int) ) );

    clients.insert(iceConn, con );
    fd_clients.insert( IceConnectionNumber(iceConn), con);

    return static_cast<void*>(con);
}

void DCOPServer::removeConnection( void* data )
{
    DCOPConnection* conn = static_cast<DCOPConnection*>(data);

    dcopSignals->removeConnections(conn);

    clients.remove(conn->iceConn );
    fd_clients.remove( IceConnectionNumber(conn->iceConn) );

    // Send DCOPReplyFailed to all in conn->waitingForReply
    while (!conn->waitingForReply.isEmpty()) {
    IceConn iceConn = conn->waitingForReply.take(0);
    if (iceConn) {
        DCOPConnection* target = clients.find( iceConn );
        qWarning("DCOP aborting call from '%s' to '%s'", target ? target->appId.data() : "<unknown>" , conn->appId.data() );
        QByteArray reply;
        DCOPMsg *pMsg;
        IceGetHeader( iceConn, majorOpcode, DCOPReplyFailed,
              sizeof(DCOPMsg), DCOPMsg, pMsg );
        pMsg->key = 1;
        pMsg->length += reply.size();
            _DCOPIceSendBegin( iceConn );
        DCOPIceSendData(iceConn, reply);
            _DCOPIceSendEnd();
            if (!target)
               qWarning("DCOP Error: unknown target in waitingForReply");
            else if (!target->waitingOnReply.removeRef(conn->iceConn))
               qWarning("DCOP Error: client in waitingForReply wasn't waiting on reply");
    }
    }

    // Send DCOPReplyFailed to all in conn->waitingForDelayedReply
    while (!conn->waitingForDelayedReply.isEmpty()) {
    IceConn iceConn = conn->waitingForDelayedReply.take(0);
    if (iceConn) {
        DCOPConnection* target = clients.find( iceConn );
        qWarning("DCOP aborting (delayed) call from '%s' to '%s'", target ? target->appId.data() : "<unknown>", conn->appId.data() );
        QByteArray reply;
        DCOPMsg *pMsg;
        IceGetHeader( iceConn, majorOpcode, DCOPReplyFailed,
              sizeof(DCOPMsg), DCOPMsg, pMsg );
        pMsg->key = 1;
        pMsg->length += reply.size();
            _DCOPIceSendBegin( iceConn );
        DCOPIceSendData( iceConn, reply );
            _DCOPIceSendEnd();
            if (!target)
               qWarning("DCOP Error: unknown target in waitingForDelayedReply");
            else if (!target->waitingOnReply.removeRef(conn->iceConn))
               qWarning("DCOP Error: client in waitingForDelayedReply wasn't waiting on reply");
    }
    }
    while (!conn->waitingOnReply.isEmpty())
    {
    IceConn iceConn = conn->waitingOnReply.take(0);
        if (iceConn) {
           DCOPConnection* target = clients.find( iceConn );
           if (!target)
           {
               qWarning("DCOP Error: still waiting for answer from non-existing client.");
               continue;
           }
           qWarning("DCOP aborting while waiting for answer from '%s'", target->appId.data());
           if (!target->waitingForReply.removeRef(conn->iceConn) &&
               !target->waitingForDelayedReply.removeRef(conn->iceConn))
              qWarning("DCOP Error: called client has forgotten about caller");
        }
    }

    if ( !conn->appId.isNull() ) {
#ifndef NDEBUG
    qDebug("DCOP: unregister '%s'", conn->appId.data() );
#endif
        if ( !conn->daemon )
        {
            currentClientNumber--;
        }

    appIds.remove( conn->appId );

        broadcastApplicationRegistration( conn, "applicationRemoved(QCString)", conn->appId );
    }

    delete conn;

    if ( suicide && (currentClientNumber == 0) )
    {
        m_timer->start( 10000 ); // if within 10 seconds nothing happens, we'll terminate
    }
    if ( shutdown && appIds.isEmpty())
    {
        m_timer->start( 10 ); // Exit now
    }
}

void DCOPServer::slotTerminate()
{
#ifndef NDEBUG
    fprintf( stderr, "DCOPServer : slotTerminate() -> sending terminateKDE signal.\n" );
#endif
    QByteArray data;
    dcopSignals->emitSignal(0L /* dcopserver */, "terminateKDE()", data, false);
    disconnect( m_timer, SIGNAL(timeout()), this, SLOT(slotTerminate()) );
    connect( m_timer, SIGNAL(timeout()), this, SLOT(slotSuicide()) );
    system(findDcopserverShutdown()+" --nokill");
}

void DCOPServer::slotSuicide()
{
#ifndef NDEBUG
    fprintf( stderr, "DCOPServer : slotSuicide() -> exit.\n" );
#endif
    exit(0);
}

void DCOPServer::slotShutdown()
{
#ifndef NDEBUG
    fprintf( stderr, "DCOPServer : slotShutdown() -> waiting for clients to disconnect.\n" );
#endif
    char c;
#ifndef Q_OS_WIN
    read(pipeOfDeath[0], &c, 1);
#endif
    if (!shutdown)
    {
       shutdown = true;
       QByteArray data;
       dcopSignals->emitSignal(0L /* dcopserver */, "terminateKDE()", data, false);
       m_timer->start( 10000 ); // if within 10 seconds nothing happens, we'll terminate
       disconnect( m_timer, SIGNAL(timeout()), this, SLOT(slotTerminate()) );
       connect( m_timer, SIGNAL(timeout()), this, SLOT(slotExit()) );
       if (appIds.isEmpty())
         slotExit(); // Exit now
    }
}

void DCOPServer::slotExit()
{
#ifndef NDEBUG
    fprintf( stderr, "DCOPServer : slotExit() -> exit.\n" );
#endif
#ifdef Q_OS_WIN
    SetEvent(m_evTerminate);
    if(m_dwTerminateThreadId != GetCurrentThreadId())
        WaitForSingleObject(m_hTerminateThread,INFINITE);
    CloseHandle(m_hTerminateThread);
#endif
    exit(0);
}

bool DCOPServer::receive(const QCString &/*app*/, const QCString &obj,
             const QCString &fun, const QByteArray& data,
             QCString& replyType, QByteArray &replyData,
             IceConn iceConn)
{
#ifdef DCOP_LOG
    (*m_stream) << "Received a message: obj =\""
                << obj << "\", fun =\""
                << fun << "\", replyType =\""
                << replyType << "\", data.size() =\""
                << data.size() << "\", replyData.size() ="
                << replyData.size() << "\n";
    m_logger->flush();
#endif

    if ( obj == "emit")
    {
        DCOPConnection* conn = clients.find( iceConn );
        if (conn) {
        //qDebug("DCOPServer: %s emits %s", conn->appId.data(), fun.data());
        dcopSignals->emitSignal(conn, fun, data, false);
        }
        replyType = "void";
        return true;
    }
    if ( fun == "setDaemonMode(bool)" ) {
        QDataStream args( data, IO_ReadOnly );
        if ( !args.atEnd() ) {
            Q_INT8 iDaemon;
            bool daemon;
            args >> iDaemon;

            daemon = static_cast<bool>( iDaemon );

        DCOPConnection* conn = clients.find( iceConn );
            if ( conn && !conn->appId.isNull() ) {
                if ( daemon ) {
                    if ( !conn->daemon )
                    {
                        conn->daemon = true;

#ifndef NDEBUG
                        qDebug( "DCOP: new daemon %s", conn->appId.data() );
#endif

                        currentClientNumber--;

// David says it's safer not to do this :-)
//                        if ( currentClientNumber == 0 )
//                            m_timer->start( 10000 );
                    }
                } else
                {
                    if ( conn->daemon ) {
                        conn->daemon = false;

                        currentClientNumber++;

                        m_timer->stop();
                    }
                }
            }

            replyType = "void";
            return true;
        }
    }
    if ( fun == "registerAs(QCString)" ) {
    QDataStream args( data, IO_ReadOnly );
    if (!args.atEnd()) {
        QCString app2 = readQCString(args);
        QDataStream reply( replyData, IO_WriteOnly );
        DCOPConnection* conn = clients.find( iceConn );
        if ( conn && !app2.isEmpty() ) {
        if ( !conn->appId.isNull() &&
             appIds.find( conn->appId ) == conn ) {
            appIds.remove( conn->appId );

        }

                QCString oldAppId;
        if ( conn->appId.isNull() )
                {
                    currentClientNumber++;
                    m_timer->stop(); // abort termination if we were planning one
#ifndef NDEBUG
                    qDebug("DCOP: register '%s' -> number of clients is now %d", app2.data(), currentClientNumber );
#endif
                }
#ifndef NDEBUG
        else
                {
                    oldAppId = conn->appId;
            qDebug("DCOP:  '%s' now known as '%s'", conn->appId.data(), app2.data() );
                }
#endif

        conn->appId = app2;
        if ( appIds.find( app2 ) != 0 ) {
            // we already have this application, unify
            int n = 1;
            QCString tmp;
            do {
            n++;
            tmp.setNum( n );
            tmp.prepend("-");
            tmp.prepend( app2 );
            } while ( appIds.find( tmp ) != 0 );
            conn->appId = tmp;
        }
        appIds.insert( conn->appId, conn );

        int c = conn->appId.find( '-' );
        if ( c > 0 )
            conn->plainAppId = conn->appId.left( c );
        else
            conn->plainAppId = conn->appId;

                if( !oldAppId.isEmpty())
                    broadcastApplicationRegistration( conn,
                        "applicationRemoved(QCString)", oldAppId );
                broadcastApplicationRegistration( conn, "applicationRegistered(QCString)", conn->appId );
        }
        replyType = "QCString";
        reply << conn->appId;
        return true;
    }
    }
    else if ( fun == "registeredApplications()" ) {
    QDataStream reply( replyData, IO_WriteOnly );
    QCStringList applications;
    QAsciiDictIterator<DCOPConnection> it( appIds );
    while ( it.current() ) {
        applications << it.currentKey();
        ++it;
    }
    replyType = "QCStringList";
    reply << applications;
    return true;
    } else if ( fun == "isApplicationRegistered(QCString)" ) {
    QDataStream args( data, IO_ReadOnly );
    if (!args.atEnd()) {
        QCString s = readQCString(args);
        QDataStream reply( replyData, IO_WriteOnly );
        int b = ( findApp( s ) != 0 );
        replyType = "bool";
        reply << b;
        return true;
    }
    } else if ( fun == "setNotifications(bool)" ) {
    QDataStream args( data, IO_ReadOnly );
    if (!args.atEnd()) {
        Q_INT8 notifyActive;
        args >> notifyActive;
        DCOPConnection* conn = clients.find( iceConn );
        if ( conn ) {
        if ( notifyActive )
            conn->notifyRegister++;
        else if ( conn->notifyRegister > 0 )
            conn->notifyRegister--;
        }
        replyType = "void";
        return true;
    }
    } else if ( fun == "connectSignal(QCString,QCString,QCString,QCString,QCString,bool)") {
        DCOPConnection* conn = clients.find( iceConn );
        if (!conn) return false;
        QDataStream args(data, IO_ReadOnly );
        if (args.atEnd()) return false;
        QCString sender = readQCString(args);
        QCString senderObj = readQCString(args);
        QCString signal = readQCString(args);
        QCString receiverObj = readQCString(args);
        QCString slot = readQCString(args);
        Q_INT8 Volatile;
        args >> Volatile;
        //qDebug("DCOPServer: connectSignal(sender = %s senderObj = %s signal = %s recvObj = %s slot = %s)", sender.data(), senderObj.data(), signal.data(), receiverObj.data(), slot.data());
        bool b = dcopSignals->connectSignal(sender, senderObj, signal, conn, receiverObj, slot, (Volatile != 0));
        replyType = "bool";
        QDataStream reply( replyData, IO_WriteOnly );
        reply << (Q_INT8) (b?1:0);
        return true;
    } else if ( fun == "disconnectSignal(QCString,QCString,QCString,QCString,QCString)") {
        DCOPConnection* conn = clients.find( iceConn );
        if (!conn) return false;
        QDataStream args(data, IO_ReadOnly );
        if (args.atEnd()) return false;
        QCString sender = readQCString(args);
        QCString senderObj = readQCString(args);
        QCString signal = readQCString(args);
        QCString receiverObj = readQCString(args);
        QCString slot = readQCString(args);
        //qDebug("DCOPServer: disconnectSignal(sender = %s senderObj = %s signal = %s recvObj = %s slot = %s)", sender.data(), senderObj.data(), signal.data(), receiverObj.data(), slot.data());
        bool b = dcopSignals->disconnectSignal(sender, senderObj, signal, conn, receiverObj, slot);
        replyType = "bool";
        QDataStream reply( replyData, IO_WriteOnly );
        reply << (Q_INT8) (b?1:0);
        return true;
    }

    return false;
}

void DCOPServer::broadcastApplicationRegistration( DCOPConnection* conn, const QCString type,
    const QCString& appId )
{
    QByteArray data;
    QDataStream datas( data, IO_WriteOnly );
    datas << appId;
    QPtrDictIterator<DCOPConnection> it( clients );
    QByteArray ba;
    QDataStream ds( ba, IO_WriteOnly );
    ds <<QCString("DCOPServer") <<  QCString("") << QCString("")
       << type << data;
    int datalen = ba.size();
    DCOPMsg *pMsg = 0;
    while ( it.current() ) {
        DCOPConnection* c = it.current();
        ++it;
        if ( c->notifyRegister && (c != conn) ) {
            IceGetHeader( c->iceConn, majorOpcode, DCOPSend,
                          sizeof(DCOPMsg), DCOPMsg, pMsg );
            pMsg->key = 1;
        pMsg->length += datalen;
            _DCOPIceSendBegin(c->iceConn);
        DCOPIceSendData( c->iceConn, ba );
            _DCOPIceSendEnd();
        }
    }
}

void
DCOPServer::sendMessage(DCOPConnection *conn, const QCString &sApp,
                        const QCString &rApp, const QCString &rObj,
                        const QCString &rFun,  const QByteArray &data)
{
   QByteArray ba;
   QDataStream ds( ba, IO_WriteOnly );
   ds << sApp << rApp << rObj << rFun << data;
   int datalen = ba.size();
   DCOPMsg *pMsg = 0;

   IceGetHeader( conn->iceConn, majorOpcode, DCOPSend,
                 sizeof(DCOPMsg), DCOPMsg, pMsg );
   pMsg->length += datalen;
   pMsg->key = 1; // important!

#ifdef DCOP_LOG
   (*m_stream) << "Sending a message: sApp =\""
               << sApp << "\", rApp =\""
               << rApp << "\", rObj =\""
               << rObj << "\", rFun =\""
               << rFun << "\", datalen ="
               << datalen << "\n";
   m_logger->flush();
#endif

   _DCOPIceSendBegin( conn->iceConn );
   DCOPIceSendData(conn->iceConn, ba);
   _DCOPIceSendEnd();
}

void IoErrorHandler ( IceConn iceConn)
{
    the_server->ioError( iceConn );
}

static bool isRunning(const QCString &fName, bool printNetworkId = false)
{
    if (::access(fName.data(), R_OK) == 0) {
    QFile f(fName);
    f.open(IO_ReadOnly);
    int size = QMIN( 1024, f.size() ); // protection against a huge file
    QCString contents( size+1 );
    bool ok = f.readBlock( contents.data(), size ) == size;
    contents[size] = '\0';
    int pos = contents.find('\n');
    ok = ok && ( pos != -1 );
    pid_t pid = ok ? contents.mid(pos+1).toUInt(&ok) : 0;
    f.close();
    if (ok && pid && (kill(pid, SIGHUP) == 0)) {
        if (printNetworkId)
            qWarning("%s", contents.left(pos).data());
        else
        qWarning( "---------------------------------\n"
              "It looks like dcopserver is already running. If you are sure\n"
              "that it is not already running, remove %s\n"
              "and start dcopserver again.\n"
              "---------------------------------\n",
              fName.data() );

        // lock file present, die silently.
        return true;
    } else {
        // either we couldn't read the PID or kill returned an error.
        // remove lockfile and continue
        unlink(fName.data());
    }
    } else if (errno != ENOENT) {
        // remove lockfile and continue
        unlink(fName.data());
    }
    return false;
}

const char* const ABOUT =
"Usage: dcopserver [--nofork] [--nosid] [--help]\n"
"       dcopserver --serverid\n"
"\n"
"DCOP is KDE's Desktop Communications Protocol. It is a lightweight IPC/RPC\n"
"mechanism built on top of the X Consortium's Inter Client Exchange protocol.\n"
"It enables desktop applications to communicate reliably with low overhead.\n"
"\n"
"Copyright (C) 1999-2001, The KDE Developers <http://www.kde.org>\n"
;

extern "C" DCOP_EXPORT int kdemain( int argc, char* argv[] )
{
    bool serverid = false;
    bool nofork = false;
    bool nosid = false;
    bool suicide = false;
    for(int i = 1; i < argc; i++) {
    if (strcmp(argv[i], "--nofork") == 0)
        nofork = true;
    else if (strcmp(argv[i], "--nosid") == 0)
        nosid = true;
    else if (strcmp(argv[i], "--nolocal") == 0)
        ; // Ignore
    else if (strcmp(argv[i], "--suicide") == 0)
        suicide = true;
    else if (strcmp(argv[i], "--serverid") == 0)
        serverid = true;
    else {
        fprintf(stdout, "%s", ABOUT );
        return 0;
    }
    }

    if (serverid)
    {
       if (isRunning(DCOPClient::dcopServerFile(), true))
          return 0;
       return 1;
    }

    // check if we are already running
    if (isRunning(DCOPClient::dcopServerFile()))
       return 0;
#ifndef Q_OS_WIN32
    if (QCString(getenv("DCOPAUTHORITY")).isEmpty() &&
        isRunning(DCOPClient::dcopServerFileOld()))
    {
       // Make symlink for compatibility
       QCString oldFile = DCOPClient::dcopServerFileOld();
       QCString newFile = DCOPClient::dcopServerFile();
       symlink(oldFile.data(), newFile.data());
       return 0;
    }

    struct rlimit limits;

    int retcode = getrlimit(RLIMIT_NOFILE, &limits);
    if (!retcode) {
       if (limits.rlim_max > 512 && limits.rlim_cur < 512)
       {
          int cur_limit = limits.rlim_cur;
          limits.rlim_cur = 512;
          retcode = setrlimit(RLIMIT_NOFILE, &limits);

          if (retcode != 0)
          {
             qWarning("dcopserver: Could not raise limit on number of open files.");
             qWarning("dcopserver: Current limit = %d", cur_limit);
          }
       }
    }
#endif
    pipe(ready);

#ifndef Q_OS_WIN32
    if (!nofork) {
        pid_t pid = fork();
    if (pid > 0) {
        char c = 1;
        close(ready[1]);
        read(ready[0], &c, 1); // Wait till dcopserver is started
        close(ready[0]);
        // I am the parent
        if (c == 0)
            {
               // Test whether we are functional.
               DCOPClient client;
               if (client.attach())
                  return 0;
            }
            qWarning("DCOPServer self-test failed.");
            system(findDcopserverShutdown()+" --kill");
            return 1;
    }
    close(ready[0]);

    if (!nosid)
        setsid();

    if (fork() > 0)
        return 0; // get rid of controlling terminal
    }

    pipe(pipeOfDeath);

    signal(SIGHUP, sighandler);
    signal(SIGTERM, sighandler);
    signal(SIGPIPE, SIG_IGN);
#else
    {
        char c = 1;
        close(ready[1]);
        read(ready[0], &c, 1); // Wait till dcopserver is started
        close(ready[0]);
    }
#endif
    putenv(strdup("SESSION_MANAGER="));

    QApplication a( argc, argv, false );

    IceSetIOErrorHandler (IoErrorHandler );
    DCOPServer *server = new DCOPServer(suicide); // this sets the_server

#ifdef Q_OS_WIN
    SetConsoleCtrlHandler(DCOPServer::dcopServerConsoleProc,TRUE);
#else
    QSocketNotifier DEATH(pipeOfDeath[0], QSocketNotifier::Read, 0, 0);
        server->connect(&DEATH, SIGNAL(activated(int)), SLOT(slotShutdown()));
#endif

    int ret = a.exec();
    delete server;
    return ret;
}

#ifdef Q_OS_WIN
#include "dcopserver_win.cpp"
#endif

#include "dcopserver.moc"

dcop

Skip menu "dcop"

• Main Page
• Modules
• Namespace List
• Class Hierarchy
• Alphabetical List
• Class List
• File List
• Class Members
• Related Pages

API Reference

Skip menu "API Reference"

• dcop
• DNSSD
• interfaces
• Kate
• kconf_update
• KDECore
• KDED
• kdefx
• KDEsu
• kdeui
• KDocTools
• KHTML
• KImgIO
• KInit
• kio
• kioslave
• KJS
• KNewStuff
• KParts
• KUtils

Generated for API Reference by doxygen 1.5.9
This website is maintained by Adriaan de Groot and Allen Winter.
KDE^® and the K Desktop Environment^® logo are registered trademarks of KDE e.V. | Legal