Skip to main content :: ::

KDE API Reference

:: Skip to Link Menu

/ API Reference / dcop

dcopclient.cpp /***************************************************************** Copyright (c) 1999 Preston Brown <pbrown@kde.org> Copyright (c) 1999 Matthias Ettrich <ettrich@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. ******************************************************************/ // qt <-> dcop integration #include <qobjectlist.h> #include <qmetaobject.h> #include <qvariant.h> #include <qtimer.h> #include <qintdict.h> #include <qeventloop.h> // end of qt <-> dcop integration #include "config.h" #include <config.h> #include <dcopref.h> #include <sys/time.h> #include <sys/types.h> #include <sys/stat.h> #include <sys/file.h> #include <sys/socket.h> #include <ctype.h> #include <unistd.h> #include <stdlib.h> #include <assert.h> #include <string.h> #ifndef QT_CLEAN_NAMESPACE #define QT_CLEAN_NAMESPACE #endif #include <qguardedptr.h> #include <qtextstream.h> #include <qfile.h> #include <qdir.h> #include <qapplication.h> #include <qsocketnotifier.h> #include <qregexp.h> #include <private/qucomextra_p.h> #include <dcopglobal.h> #include <dcopclient.h> #include <dcopobject.h> #if defined Q_WS_X11 && ! defined K_WS_QTONLY #include <X11/Xmd.h> #endif extern "C" { #include <KDE-ICE/ICElib.h> #include <KDE-ICE/ICEutil.h> #include <KDE-ICE/ICEmsg.h> #include <KDE-ICE/ICEproto.h> } // #define DCOPCLIENT_DEBUG 1 extern QMap<QCString, DCOPObject *> * kde_dcopObjMap; // defined in dcopobject.cpp /********************************************* * Keep track of local clients *********************************************/ typedef QAsciiDict<DCOPClient> client_map_t; static client_map_t *DCOPClient_CliMap = 0; static client_map_t *cliMap() { if (!DCOPClient_CliMap) DCOPClient_CliMap = new client_map_t; return DCOPClient_CliMap; } DCOPClient *DCOPClient::findLocalClient( const QCString &_appId ) { return cliMap()->find(_appId.data()); } static void registerLocalClient( const QCString &_appId, DCOPClient *client ) { cliMap()->replace(_appId.data(), client); } static void unregisterLocalClient( const QCString &_appId ) { client_map_t *map = cliMap(); map->remove(_appId.data()); } template class QPtrList<DCOPObjectProxy>; template class QPtrList<DCOPClientTransaction>; template class QPtrList<_IceConn>; struct DCOPClientMessage { int opcode; CARD32 key; QByteArray data; }; class DCOPClient::ReplyStruct { public: enum ReplyStatus { Pending, Ok, Failed }; ReplyStruct() { status = Pending; replyType = 0; replyData = 0; replyId = -1; transactionId = -1; replyObject = 0; } ReplyStatus status; QCString* replyType; QByteArray* replyData; int replyId; Q_INT32 transactionId; QCString calledApp; QGuardedPtr<QObject> replyObject; QCString replySlot; }; class DCOPClientPrivate { public: DCOPClient *parent; QCString appId; IceConn iceConn; int majorOpcode; // major opcode negotiated w/server and used to tag all comms. int majorVersion, minorVersion; // protocol versions negotiated w/server static const char* serverAddr; // location of server in ICE-friendly format. QSocketNotifier *notifier; bool non_blocking_call_lock; bool registered; bool foreign_server; bool accept_calls; bool accept_calls_override; // If true, user has specified policy. bool qt_bridge_enabled; QCString senderId; QCString objId; QCString function; QCString defaultObject; QPtrList<DCOPClientTransaction> *transactionList; bool transaction; Q_INT32 transactionId; int opcode; // Special key values: // 0 : Not specified // 1 : DCOPSend // 2 : Priority // >= 42: Normal CARD32 key; CARD32 currentKey; CARD32 currentKeySaved; QTimer postMessageTimer; QPtrList<DCOPClientMessage> messages; QPtrList<DCOPClient::ReplyStruct> pendingReplies; QPtrList<DCOPClient::ReplyStruct> asyncReplyQueue; struct LocalTransactionResult { QCString replyType; QByteArray replyData; }; QIntDict<LocalTransactionResult> localTransActionList; QTimer eventLoopTimer; }; class DCOPClientTransaction { public: Q_INT32 id; CARD32 key; QCString senderId; }; QCString DCOPClient::iceauthPath() { #ifdef Q_OS_WIN32 char szPath[512]; char * pszFilePart; int ret; ret = SearchPathA(NULL,"iceauth.exe",NULL,sizeof(szPath)/sizeof(szPath[0]),szPath,&pszFilePart); if(ret != 0) return QCString(szPath); #else QCString path = ::getenv("PATH"); if (path.isEmpty()) path = "/bin:/usr/bin"; path += ":/usr/bin/X11:/usr/X11/bin:/usr/X11R6/bin"; QCString fPath = strtok(path.data(), ":\b"); while (!fPath.isNull()) { fPath += "/iceauth"; if (access(fPath.data(), X_OK) == 0) { return fPath; } fPath = strtok(NULL, ":\b"); } #endif return 0; } static QCString dcopServerFile(const QCString &hostname, bool old) { QCString fName = ::getenv("DCOPAUTHORITY"); if (!old && !fName.isEmpty()) return fName; fName = QFile::encodeName( QDir::homeDirPath() ); // fName = ::getenv("HOME"); if (fName.isEmpty()) { fprintf(stderr, "Aborting. $HOME is not set.\n"); exit(1); } #ifdef Q_WS_X11 QCString disp = getenv("DISPLAY"); #elif defined(Q_WS_QWS) QCString disp = getenv("QWS_DISPLAY"); #else QCString disp; #endif if (disp.isEmpty()) disp = "NODISPLAY"; int i; if((i = disp.findRev('.')) > disp.findRev(KPATH_SEPARATOR) && i >= 0) disp.truncate(i); if (!old) { while( (i = disp.find(KPATH_SEPARATOR)) >= 0) disp[i] = '_'; } fName += "/.DCOPserver_"; if (hostname.isEmpty()) { char hostName[256]; hostName[0] = '\0'; if (gethostname(hostName, sizeof(hostName))) { fName += "localhost"; } else { hostName[sizeof(hostName)-1] = '\0'; fName += hostName; } } else { fName += hostname; } fName += "_"+disp; return fName; } // static QCString DCOPClient::dcopServerFile(const QCString &hostname) { return ::dcopServerFile(hostname, false); } // static QCString DCOPClient::dcopServerFileOld(const QCString &hostname) { return ::dcopServerFile(hostname, true); } const char* DCOPClientPrivate::serverAddr = 0; static void DCOPProcessInternal( DCOPClientPrivate *d, int opcode, CARD32 key, const QByteArray& dataReceived, bool canPost ); void DCOPClient::handleAsyncReply(ReplyStruct *replyStruct) { if (replyStruct->replyObject) { QObject::connect(this, SIGNAL(callBack(int, const QCString&, const QByteArray &)), replyStruct->replyObject, replyStruct->replySlot); emit callBack(replyStruct->replyId, *(replyStruct->replyType), *(replyStruct->replyData)); QObject::disconnect(this, SIGNAL(callBack(int, const QCString&, const QByteArray &)), replyStruct->replyObject, replyStruct->replySlot); } delete replyStruct; } static void DCOPProcessMessage(IceConn iceConn, IcePointer clientObject, int opcode, unsigned long length, Bool /*swap*/, IceReplyWaitInfo *replyWait, Bool *replyWaitRet) { DCOPMsg *pMsg = 0; DCOPClientPrivate *d = static_cast<DCOPClientPrivate *>(clientObject); DCOPClient::ReplyStruct *replyStruct = replyWait ? static_cast<DCOPClient::ReplyStruct*>(replyWait->reply) : 0; IceReadMessageHeader(iceConn, sizeof(DCOPMsg), DCOPMsg, pMsg); CARD32 key = pMsg->key; if ( d->key == 0 ) d->key = key; // received a key from the server QByteArray dataReceived( length ); IceReadData(iceConn, length, dataReceived.data() ); d->opcode = opcode; switch (opcode ) { case DCOPReplyFailed: if ( replyStruct ) { replyStruct->status = DCOPClient::ReplyStruct::Failed; replyStruct->transactionId = 0; *replyWaitRet = True; return; } else { qWarning("Very strange! got a DCOPReplyFailed opcode, but we were not waiting for a reply!"); return; } case DCOPReply: if ( replyStruct ) { QByteArray* b = replyStruct->replyData; QCString* t = replyStruct->replyType; replyStruct->status = DCOPClient::ReplyStruct::Ok; replyStruct->transactionId = 0; QCString calledApp, app; QDataStream ds( dataReceived, IO_ReadOnly ); ds >> calledApp >> app >> *t >> *b; *replyWaitRet = True; return; } else { qWarning("Very strange! got a DCOPReply opcode, but we were not waiting for a reply!"); return; } case DCOPReplyWait: if ( replyStruct ) { QCString calledApp, app; Q_INT32 id; QDataStream ds( dataReceived, IO_ReadOnly ); ds >> calledApp >> app >> id; replyStruct->transactionId = id; replyStruct->calledApp = calledApp; d->pendingReplies.append(replyStruct); *replyWaitRet = True; return; } else { qWarning("Very strange! got a DCOPReplyWait opcode, but we were not waiting for a reply!"); return; } case DCOPReplyDelayed: { QDataStream ds( dataReceived, IO_ReadOnly ); QCString calledApp, app; Q_INT32 id; ds >> calledApp >> app >> id; if (replyStruct && (id == replyStruct->transactionId) && (calledApp == replyStruct->calledApp)) { *replyWaitRet = True; } for(DCOPClient::ReplyStruct *rs = d->pendingReplies.first(); rs; rs = d->pendingReplies.next()) { if ((rs->transactionId == id) && (rs->calledApp == calledApp)) { d->pendingReplies.remove(); QByteArray* b = rs->replyData; QCString* t = rs->replyType; ds >> *t >> *b; rs->status = DCOPClient::ReplyStruct::Ok; rs->transactionId = 0; if (!rs->replySlot.isEmpty()) { d->parent->handleAsyncReply(rs); } return; } } } qWarning("Very strange! got a DCOPReplyDelayed opcode, but we were not waiting for a reply!"); return; case DCOPCall: case DCOPFind: case DCOPSend: DCOPProcessInternal( d, opcode, key, dataReceived, true ); } } void DCOPClient::processPostedMessagesInternal() { if ( d->messages.isEmpty() ) return; QPtrListIterator<DCOPClientMessage> it (d->messages ); DCOPClientMessage* msg ; while ( ( msg = it.current() ) ) { ++it; if ( d->currentKey && msg->key != d->currentKey ) continue; d->messages.removeRef( msg ); d->opcode = msg->opcode; DCOPProcessInternal( d, msg->opcode, msg->key, msg->data, false ); delete msg; } if ( !d->messages.isEmpty() ) d->postMessageTimer.start( 100, true ); } void DCOPProcessInternal( DCOPClientPrivate *d, int opcode, CARD32 key, const QByteArray& dataReceived, bool canPost ) { if (!d->accept_calls && (opcode == DCOPSend)) return; IceConn iceConn = d->iceConn; DCOPMsg *pMsg = 0; DCOPClient *c = d->parent; QDataStream ds( dataReceived, IO_ReadOnly ); QCString fromApp; ds >> fromApp; if (fromApp.isEmpty()) return; // Reserved for local calls if (!d->accept_calls) { QByteArray reply; QDataStream replyStream( reply, IO_WriteOnly ); // Call rejected. replyStream << d->appId << fromApp; IceGetHeader( iceConn, d->majorOpcode, DCOPReplyFailed, sizeof(DCOPMsg), DCOPMsg, pMsg ); int datalen = reply.size(); pMsg->key = key; pMsg->length += datalen; IceSendData( iceConn, datalen, const_cast<char *>(reply.data())); return; } QCString app, objId, fun; QByteArray data; ds >> app >> objId >> fun >> data; d->senderId = fromApp; d->objId = objId; d->function = fun; // qWarning("DCOP: %s got call: %s:%s:%s key = %d currentKey = %d", d->appId.data(), app.data(), objId.data(), fun.data(), key, d->currentKey); if ( canPost && d->currentKey && key != d->currentKey ) { DCOPClientMessage* msg = new DCOPClientMessage; msg->opcode = opcode; msg->key = key; msg->data = dataReceived; d->messages.append( msg ); d->postMessageTimer.start( 0, true ); return; } d->objId = objId; d->function = fun; QCString replyType; QByteArray replyData; bool b; CARD32 oldCurrentKey = d->currentKey; if ( opcode != DCOPSend ) // DCOPSend doesn't change the current key d->currentKey = key; if ( opcode == DCOPFind ) b = c->find(app, objId, fun, data, replyType, replyData ); else b = c->receive( app, objId, fun, data, replyType, replyData ); // set notifier back to previous state if ( opcode == DCOPSend ) return; if ((d->currentKey == key) || (oldCurrentKey != 2)) d->currentKey = oldCurrentKey; QByteArray reply; QDataStream replyStream( reply, IO_WriteOnly ); Q_INT32 id = c->transactionId(); if (id) { // Call delayed. Send back the transaction ID. replyStream << d->appId << fromApp << id; IceGetHeader( iceConn, d->majorOpcode, DCOPReplyWait, sizeof(DCOPMsg), DCOPMsg, pMsg ); pMsg->key = key; pMsg->length += reply.size(); IceSendData( iceConn, reply.size(), const_cast<char *>(reply.data())); return; } if ( !b ) { // Call failed. No data send back. replyStream << d->appId << fromApp; IceGetHeader( iceConn, d->majorOpcode, DCOPReplyFailed, sizeof(DCOPMsg), DCOPMsg, pMsg ); int datalen = reply.size(); pMsg->key = key; pMsg->length += datalen; IceSendData( iceConn, datalen, const_cast<char *>(reply.data())); return; } // Call successful. Send back replyType and replyData. replyStream << d->appId << fromApp << replyType << replyData.size(); // we are calling, so we need to set up reply data IceGetHeader( iceConn, d->majorOpcode, DCOPReply, sizeof(DCOPMsg), DCOPMsg, pMsg ); int datalen = reply.size() + replyData.size(); pMsg->key = key; pMsg->length += datalen; // use IceSendData not IceWriteData to avoid a copy. Output buffer // shouldn't need to be flushed. IceSendData( iceConn, reply.size(), const_cast<char *>(reply.data())); IceSendData( iceConn, replyData.size(), const_cast<char *>(replyData.data())); } static IcePoVersionRec DCOPClientVersions[] = { { DCOPVersionMajor, DCOPVersionMinor, DCOPProcessMessage } }; static DCOPClient* dcop_main_client = 0; DCOPClient* DCOPClient::mainClient() { return dcop_main_client; } void DCOPClient::setMainClient( DCOPClient* client ) { dcop_main_client = client; } DCOPClient::DCOPClient() { d = new DCOPClientPrivate; d->parent = this; d->iceConn = 0L; d->key = 0; d->currentKey = 0; d->majorOpcode = 0; d->appId = 0; d->notifier = 0L; d->non_blocking_call_lock = false; d->registered = false; d->foreign_server = true; d->accept_calls = true; d->accept_calls_override = false; d->qt_bridge_enabled = true; d->transactionList = 0L; d->transactionId = 0; QObject::connect( &d->postMessageTimer, SIGNAL( timeout() ), this, SLOT( processPostedMessagesInternal() ) ); QObject::connect( &d->eventLoopTimer, SIGNAL( timeout() ), this, SLOT( eventLoopTimeout() ) ); if ( !mainClient() ) setMainClient( this ); } DCOPClient::~DCOPClient() { #ifdef DCOPCLIENT_DEBUG qWarning("d->messages.count() = %d", d->messages.count()); QPtrListIterator<DCOPClientMessage> it (d->messages ); DCOPClientMessage* msg ; while ( ( msg = it.current() ) ) { ++it; d->messages.removeRef( msg ); qWarning("DROPPING UNHANDLED DCOP MESSAGE:"); qWarning(" opcode = %d key = %d", msg->opcode, msg->key); QDataStream ds( msg->data, IO_ReadOnly ); QCString fromApp, app, objId, fun; ds >> fromApp >> app >> objId >> fun; qWarning(" from = %s", fromApp.data()); qWarning(" to = %s / %s / %s", app.data(), objId.data(), fun.data()); delete msg; } #endif if (d->iceConn) if (IceConnectionStatus(d->iceConn) == IceConnectAccepted) detach(); if (d->registered) unregisterLocalClient( d->appId ); delete d->notifier; delete d->transactionList; d->messages.setAutoDelete(true); delete d; if ( mainClient() == this ) setMainClient( 0 ); } void DCOPClient::setServerAddress(const QCString &addr) { QCString env = "DCOPSERVER=" + addr; putenv(strdup(env.data())); delete [] DCOPClientPrivate::serverAddr; DCOPClientPrivate::serverAddr = qstrdup( addr.data() ); } bool DCOPClient::attach() { if (!attachInternal( true )) if (!attachInternal( true )) return false; // Try two times! return true; } void DCOPClient::bindToApp() { // check if we have a qApp instantiated. If we do, // we can create a QSocketNotifier and use it for receiving data. if (qApp) { if ( d->notifier ) delete d->notifier; d->notifier = new QSocketNotifier(socket(), QSocketNotifier::Read, 0, 0); QObject::connect(d->notifier, SIGNAL(activated(int)), SLOT(processSocketData(int))); } } void DCOPClient::suspend() { #ifdef Q_WS_WIN //TODO: remove (win32 ports sometimes do not create notifiers) if (!d->notifier) return; #endif assert(d->notifier); // Suspending makes no sense if we didn't had a qApp yet d->notifier->setEnabled(false); } void DCOPClient::resume() { #ifdef Q_WS_WIN //TODO: remove if (!d->notifier) return; #endif assert(d->notifier); // Should never happen d->notifier->setEnabled(true); } bool DCOPClient::isSuspended() const { #if defined(Q_WS_WIN) || defined(Q_WS_MAC) //TODO: REMOVE if (!d->notifier) return false; #endif return !d->notifier->isEnabled(); } #ifdef SO_PEERCRED // Check whether the remote end is owned by the same user. static bool peerIsUs(int sockfd) { struct ucred cred; socklen_t siz = sizeof(cred); if (getsockopt(sockfd, SOL_SOCKET, SO_PEERCRED, &cred, &siz) != 0) return false; return (cred.uid == getuid()); } #else // Check whether the socket is owned by the same user. static bool isServerSocketOwnedByUser(const char*server) { #ifdef Q_OS_WIN if (strncmp(server, "tcp/", 4) != 0) return false; // Not a local socket -> foreign. else return true; #else if (strncmp(server, "local/", 6) != 0) return false; // Not a local socket -> foreign. const char *path = strchr(server, KPATH_SEPARATOR); if (!path) return false; path++; struct stat stat_buf; if (stat(path, &stat_buf) != 0) return false; return (stat_buf.st_uid == getuid()); #endif } #endif bool DCOPClient::attachInternal( bool registerAsAnonymous ) { char errBuf[1024]; if ( isAttached() ) detach(); if ((d->majorOpcode = IceRegisterForProtocolSetup(const_cast<char *>("DCOP"), const_cast<char *>(DCOPVendorString), const_cast<char *>(DCOPReleaseString), 1, DCOPClientVersions, DCOPAuthCount, const_cast<char **>(DCOPAuthNames), DCOPClientAuthProcs, 0L)) < 0) { emit attachFailed(QString::fromLatin1( "Communications could not be established." )); return false; } bool bClearServerAddr = false; // first, check if serverAddr was ever set. if (!d->serverAddr) { // here, we obtain the list of possible DCOP connections, // and attach to them. QCString dcopSrv; dcopSrv = ::getenv("DCOPSERVER"); if (dcopSrv.isEmpty()) { QCString fName = dcopServerFile(); QFile f(QFile::decodeName(fName)); if (!f.open(IO_ReadOnly)) { emit attachFailed(QString::fromLatin1( "Could not read network connection list.\n" )+QFile::decodeName(fName)); return false; } int size = QMIN( 1024, f.size() ); // protection against a huge file QCString contents( size+1 ); if ( f.readBlock( contents.data(), size ) != size ) { qDebug("Error reading from %s, didn't read the expected %d bytes", fName.data(), size); // Should we abort ? } contents[size] = '\0'; int pos = contents.find('\n'); if ( pos == -1 ) // Shouldn't happen { qDebug("Only one line in dcopserver file !: %s", contents.data()); dcopSrv = contents; } else { if(contents[pos - 1] == '\r') // check for windows end of line pos--; dcopSrv = contents.left( pos ); //#ifndef NDEBUG // qDebug("dcopserver address: %s", dcopSrv.data()); //#endif } } d->serverAddr = qstrdup( const_cast<char *>(dcopSrv.data()) ); bClearServerAddr = true; } if ((d->iceConn = IceOpenConnection(const_cast<char*>(d->serverAddr), static_cast<IcePointer>(this), False, d->majorOpcode, sizeof(errBuf), errBuf)) == 0L) { qDebug("DCOPClient::attachInternal. Attach failed %s", errBuf); d->iceConn = 0; if (bClearServerAddr) { delete [] d->serverAddr; d->serverAddr = 0; } emit attachFailed(QString::fromLatin1( errBuf )); return false; } IceSetShutdownNegotiation(d->iceConn, False); int setupstat; char* vendor = 0; char* release = 0; setupstat = IceProtocolSetup(d->iceConn, d->majorOpcode, static_cast<IcePointer>(d), False, /* must authenticate */ &(d->majorVersion), &(d->minorVersion), &(vendor), &(release), 1024, errBuf); if (vendor) free(vendor); if (release) free(release); if (setupstat == IceProtocolSetupFailure || setupstat == IceProtocolSetupIOError) { IceCloseConnection(d->iceConn); d->iceConn = 0; if (bClearServerAddr) { delete [] d->serverAddr; d->serverAddr = 0; } emit attachFailed(QString::fromLatin1( errBuf )); return false; } else if (setupstat == IceProtocolAlreadyActive) { if (bClearServerAddr) { delete [] d->serverAddr; d->serverAddr = 0; } /* should not happen because 3rd arg to IceOpenConnection was 0. */ emit attachFailed(QString::fromLatin1( "internal error in IceOpenConnection" )); return false; } if (IceConnectionStatus(d->iceConn) != IceConnectAccepted) { if (bClearServerAddr) { delete [] d->serverAddr; d->serverAddr = 0; } emit attachFailed(QString::fromLatin1( "DCOP server did not accept the connection." )); return false; } #ifdef SO_PEERCRED d->foreign_server = !peerIsUs(socket()); #else d->foreign_server = !isServerSocketOwnedByUser(d->serverAddr); #endif if (!d->accept_calls_override) d->accept_calls = !d->foreign_server; bindToApp(); if ( registerAsAnonymous ) registerAs( "anonymous", true ); return true; } bool DCOPClient::detach() { int status; if (d->iceConn) { IceProtocolShutdown(d->iceConn, d->majorOpcode); status = IceCloseConnection(d->iceConn); if (status != IceClosedNow) return false; else d->iceConn = 0L; } if (d->registered) unregisterLocalClient(d->appId); delete d->notifier; d->notifier = 0L; d->registered = false; d->foreign_server = true; return true; } bool DCOPClient::isAttached() const { if (!d->iceConn) return false; return (IceConnectionStatus(d->iceConn) == IceConnectAccepted); } bool DCOPClient::isAttachedToForeignServer() const { return isAttached() && d->foreign_server; } bool DCOPClient::acceptCalls() const { return isAttached() && d->accept_calls; } void DCOPClient::setAcceptCalls(bool b) { d->accept_calls = b; d->accept_calls_override = true; } bool DCOPClient::qtBridgeEnabled() { return d->qt_bridge_enabled; } void DCOPClient::setQtBridgeEnabled(bool b) { d->qt_bridge_enabled = b; } QCString DCOPClient::registerAs( const QCString &appId, bool addPID ) { QCString result; QCString _appId = appId; if (addPID) { QCString pid; pid.sprintf("-%d", getpid()); _appId = _appId + pid; } if( d->appId == _appId ) return d->appId; #if 0 // no need to detach, dcopserver can handle renaming // Detach before reregistering. if ( isRegistered() ) { detach(); } #endif if ( !isAttached() ) { if (!attachInternal( false )) if (!attachInternal( false )) return result; // Try two times } // register the application identifier with the server QCString replyType; QByteArray data, replyData; QDataStream arg( data, IO_WriteOnly ); arg << _appId; if ( call( "DCOPServer", "", "registerAs(QCString)", data, replyType, replyData ) ) { QDataStream reply( replyData, IO_ReadOnly ); reply >> result; } d->appId = result; d->registered = !result.isNull(); if (d->registered) registerLocalClient( d->appId, this ); return result; } bool DCOPClient::isRegistered() const { return d->registered; } QCString DCOPClient::appId() const { return d->appId; } int DCOPClient::socket() const { if (d->iceConn) return IceConnectionNumber(d->iceConn); return 0; } static inline bool isIdentChar( char x ) { // Avoid bug in isalnum return x == '_' || (x >= '0' && x <= '9') || (x >= 'a' && x <= 'z') || (x >= 'A' && x <= 'Z'); } QCString DCOPClient::normalizeFunctionSignature( const QCString& fun ) { if ( fun.isEmpty() ) // nothing to do return fun.copy(); QCString result( fun.size() ); char *from = fun.data(); char *to = result.data(); char *first = to; char last = 0; while ( true ) { while ( *from && isspace(*from) ) from++; if ( last && isIdentChar( last ) && isIdentChar( *from ) ) *to++ = 0x20; while ( *from && !isspace(*from) ) { last = *from++; *to++ = last; } if ( !*from ) break; } if ( to > first && *(to-1) == 0x20 ) to--; *to = '\0'; result.resize( (int)((long)to - (long)result.data()) + 1 ); return result; } QCString DCOPClient::senderId() const { return d->senderId; } bool DCOPClient::send(const QCString &remApp, const QCString &remObjId, const QCString &remFun, const QByteArray &data) { if (remApp.isEmpty()) return false; DCOPClient *localClient = findLocalClient( remApp ); if ( localClient ) { bool saveTransaction = d->transaction; Q_INT32 saveTransactionId = d->transactionId; QCString saveSenderId = d->senderId; d->senderId = 0; // Local call QCString replyType; QByteArray replyData; (void) localClient->receive( remApp, remObjId, remFun, data, replyType, replyData ); d->transaction = saveTransaction; d->transactionId = saveTransactionId; d->senderId = saveSenderId; // send() returns true if the data could be send to the DCOPServer, // regardles of receiving the data on the other application. // So we assume the data is successfully send to the (virtual) server // and return true in any case. return true; } if ( !isAttached() ) return false; DCOPMsg *pMsg; QByteArray ba; QDataStream ds(ba, IO_WriteOnly); ds << d->appId << remApp << remObjId << normalizeFunctionSignature(remFun) << data.size(); IceGetHeader(d->iceConn, d->majorOpcode, DCOPSend, sizeof(DCOPMsg), DCOPMsg, pMsg); pMsg->key = 1; // DCOPSend always uses the magic key 1 int datalen = ba.size() + data.size(); pMsg->length += datalen; IceSendData( d->iceConn, ba.size(), const_cast<char *>(ba.data()) ); IceSendData( d->iceConn, data.size(), const_cast<char *>(data.data()) ); //IceFlush(d->iceConn); if (IceConnectionStatus(d->iceConn) == IceConnectAccepted) return true; return false; } bool DCOPClient::send(const QCString &remApp, const QCString &remObjId, const QCString &remFun, const QString &data) { QByteArray ba; QDataStream ds(ba, IO_WriteOnly); ds << data; return send(remApp, remObjId, remFun, ba); } bool DCOPClient::findObject(const QCString &remApp, const QCString &remObj, const QCString &remFun, const QByteArray &data, QCString &foundApp, QCString &foundObj, bool useEventLoop) { return findObject( remApp, remObj, remFun, data, foundApp, foundObj, useEventLoop, -1 ); } bool DCOPClient::findObject(const QCString &remApp, const QCString &remObj, const QCString &remFun, const QByteArray &data, QCString &foundApp, QCString &foundObj, bool useEventLoop, int timeout) { QCStringList appList; QCString app = remApp; if (app.isEmpty()) app = "*"; foundApp = 0; foundObj = 0; if (app[app.length()-1] == '*') { // Find all apps that match 'app'. // NOTE: It would be more efficient to do the filtering in // the dcopserver itself. int len = app.length()-1; QCStringList apps=registeredApplications(); for( QCStringList::ConstIterator it = apps.begin(); it != apps.end(); ++it) { if ( strncmp( (*it).data(), app.data(), len) == 0) appList.append(*it); } } else { appList.append(app); } // We do all the local clients in phase1 and the rest in phase2 for(int phase=1; phase <= 2; phase++) { for( QCStringList::ConstIterator it = appList.begin(); it != appList.end(); ++it) { QCString remApp = *it; QCString replyType; QByteArray replyData; bool result = false; DCOPClient *localClient = findLocalClient( remApp ); if ( (phase == 1) && localClient ) { // In phase 1 we do all local clients bool saveTransaction = d->transaction; Q_INT32 saveTransactionId = d->transactionId; QCString saveSenderId = d->senderId; d->senderId = 0; // Local call result = localClient->find( remApp, remObj, remFun, data, replyType, replyData ); Q_INT32 id = localClient->transactionId(); if (id) { // Call delayed. We have to wait till it has been processed. do { QApplication::eventLoop()->processEvents( QEventLoop::WaitForMore); } while( !localClient->isLocalTransactionFinished(id, replyType, replyData)); result = true; } d->transaction = saveTransaction; d->transactionId = saveTransactionId; d->senderId = saveSenderId; } else if ((phase == 2) && !localClient) { // In phase 2 we do the other clients result = callInternal(remApp, remObj, remFun, data, replyType, replyData, useEventLoop, timeout, DCOPFind); } if (result) { if (replyType == "DCOPRef") { DCOPRef ref; QDataStream reply( replyData, IO_ReadOnly ); reply >> ref; if (ref.app() == remApp) // Consistency check { // replyType contains objId. foundApp = ref.app(); foundObj = ref.object(); return true; } } } } } return false; } bool DCOPClient::process(const QCString &, const QByteArray &, QCString&, QByteArray &) { return false; } bool DCOPClient::isApplicationRegistered( const QCString& remApp) { QCString replyType; QByteArray data, replyData; QDataStream arg( data, IO_WriteOnly ); arg << remApp; int result = false; if ( call( "DCOPServer", "", "isApplicationRegistered(QCString)", data, replyType, replyData ) ) { QDataStream reply( replyData, IO_ReadOnly ); reply >> result; } return result; }