X-Git-Url: https://git.quassel-irc.org/?p=quassel.git;a=blobdiff_plain;f=src%2Fcommon%2Fsignalproxy.cpp;h=ebcf507696fef745a454269335f34962789242c4;hp=7808ad1087ca13fff4d98d6b2725fd49667c7d2c;hb=70283ef877bdf3339fb067667ad9130ceabd8b9a;hpb=aa7841638c6537034102da959cad8c36853bf280 diff --git a/src/common/signalproxy.cpp b/src/common/signalproxy.cpp index 7808ad10..ebcf5076 100644 --- a/src/common/signalproxy.cpp +++ b/src/common/signalproxy.cpp @@ -1,5 +1,5 @@ /*************************************************************************** - * Copyright (C) 2005-08 by the Quassel Project * + * Copyright (C) 2005-09 by the Quassel Project * * devel@quassel-irc.org * * * * This program is free software; you can redistribute it and/or modify * @@ -32,6 +32,9 @@ #include #include #include +#ifdef HAVE_SSL +#include +#endif #include #include #include @@ -58,150 +61,106 @@ public: }; // ================================================== -// SIGNALRELAY +// SignalRelay // ================================================== -class SignalRelay: public QObject { +class SignalProxy::SignalRelay : public QObject { /* Q_OBJECT is not necessary or even allowed, because we implement qt_metacall ourselves (and don't use any other features of the meta object system) */ public: - SignalRelay(SignalProxy* parent, QObject* source); + SignalRelay(SignalProxy *parent) : QObject(parent), _proxy(parent) {} + inline SignalProxy *proxy() const { return _proxy; } + int qt_metacall(QMetaObject::Call _c, int _id, void **_a); - void attachSignal(int methodId, const QByteArray &func); + void attachSignal(QObject *sender, int signalId, const QByteArray &funcName); + void detachSignal(QObject *sender, int signalId = -1); - void setSynchronize(bool); - bool synchronize() const; +private: + struct Signal { + QObject *sender; + int signalId; + QByteArray signature; + Signal(QObject *sender, int sigId, const QByteArray &signature) : sender(sender), signalId(sigId), signature(signature) {} + Signal() : sender(0), signalId(-1) {} + }; + + SignalProxy *_proxy; + QHash _slots; +}; - int sigCount() const; +void SignalProxy::SignalRelay::attachSignal(QObject *sender, int signalId, const QByteArray &funcName) { + // we ride without safetybelts here... all checking for valid method etc pp has to be done by the caller + // all connected methodIds are offset by the standard methodCount of QObject + int slotId; + for(int i = 0;; i++) { + if(!_slots.contains(i)) { + slotId = i; + break; + } + } -private: - bool isSyncMethod(int i); + QByteArray fn; + if(!funcName.isEmpty()) { + fn = QMetaObject::normalizedSignature(funcName); + } else { + fn = SIGNAL(fakeMethodSignature()); + fn = fn.replace("fakeMethodSignature()", sender->metaObject()->method(signalId).signature()); + } - SignalProxy* proxy; - QObject* caller; - QMultiHash sigNames; - bool _sync; -}; + _slots[slotId] = Signal(sender, signalId, fn); -SignalRelay::SignalRelay(SignalProxy* parent, QObject* source) - : QObject(parent), - proxy(parent), - caller(source), - _sync(false) -{ - QObject::connect(source, SIGNAL(destroyed()), parent, SLOT(detachSender())); + QMetaObject::connect(sender, signalId, this, QObject::staticMetaObject.methodCount() + slotId); } -int SignalRelay::qt_metacall(QMetaObject::Call _c, int _id, void **_a) { +void SignalProxy::SignalRelay::detachSignal(QObject *sender, int signalId) { + QHash::iterator slotIter = _slots.begin(); + while(slotIter != _slots.end()) { + if(slotIter->sender == sender && (signalId == -1 || slotIter->signalId == signalId)) { + slotIter = _slots.erase(slotIter); + if(signalId != -1) + break; + } else { + slotIter++; + } + } +} + +int SignalProxy::SignalRelay::qt_metacall(QMetaObject::Call _c, int _id, void **_a) { _id = QObject::qt_metacall(_c, _id, _a); if(_id < 0) return _id; + if(_c == QMetaObject::InvokeMetaMethod) { - if(sigNames.contains(_id) || synchronize()) { - const QList &argTypes = proxy->argTypes(caller, _id); + if(_slots.contains(_id)) { + QObject *caller = sender(); + + SignalProxy::ExtendedMetaObject *eMeta = proxy()->extendedMetaObject(caller->metaObject()); + Q_ASSERT(eMeta); + + const Signal &signal = _slots[_id]; + QVariantList params; - int n = argTypes.size(); - for(int i=0; i &argTypes = eMeta->argTypes(signal.signalId); + for(int i = 0; i < argTypes.size(); i++) { if(argTypes[i] == 0) { qWarning() << "SignalRelay::qt_metacall(): received invalid data for argument number" << i << "of signal" << QString("%1::%2").arg(caller->metaObject()->className()).arg(caller->metaObject()->method(_id).signature()); qWarning() << " - make sure all your data types are known by the Qt MetaSystem"; return _id; } - params.append(QVariant(argTypes[i], _a[i+1])); - } - QMultiHash::const_iterator funcIter = sigNames.constFind(_id); - while(funcIter != sigNames.constEnd() && funcIter.key() == _id) { - proxy->dispatchSignal(SignalProxy::RpcCall, QVariantList() << funcIter.value() << params); - funcIter++; + params << QVariant(argTypes[i], _a[i+1]); } - // dispatch Sync Signal if necessary - QByteArray signature(caller->metaObject()->method(_id).signature()); - SyncableObject *syncObject = qobject_cast(caller); - if(synchronize() && proxy->syncMap(syncObject).contains(signature)) { - //qDebug() << "__SYNC__ >>>" - // << caller->metaObject()->className() - // << caller->objectName() - // << signature - // << params; - // params.prepend(QVariant(_id)); - params.prepend(signature); - params.prepend(syncObject->objectName()); - params.prepend(syncObject->syncMetaObject()->className()); - proxy->dispatchSignal(SignalProxy::Sync, params); - } + proxy()->dispatchSignal(SignalProxy::RpcCall, params); } - _id -= QObject::staticMetaObject.methodCount(); + _id -= _slots.count(); } return _id; } -void SignalRelay::setSynchronize(bool sync) { - SyncableObject *syncObject = qobject_cast(caller); - if(!syncObject) - return; - - const QMetaObject *meta = syncObject->syncMetaObject(); - if(!_sync && sync) { - // enable Sync - for(int i = 0; i < meta->methodCount(); i++ ) { - if(isSyncMethod(i)) - QMetaObject::connect(caller, i, this, QObject::staticMetaObject.methodCount() + i); - } - } else if (_sync && !sync) { - // disable Sync - for(int i = 0; i < meta->methodCount(); i++ ) { - if(isSyncMethod(i)) - QMetaObject::disconnect(caller, i, this, QObject::staticMetaObject.methodCount() + i); - } - } - _sync = sync; -} - -bool SignalRelay::isSyncMethod(int i) { - SyncableObject *syncObject = qobject_cast(caller); - if(!syncObject) - return false; - - QByteArray signature = syncObject->syncMetaObject()->method(i).signature(); - if(!proxy->syncMap(syncObject).contains(signature)) - return false; - - if(proxy->proxyMode() == SignalProxy::Server && !signature.contains("Requested")) - return true; - - if(proxy->proxyMode() == SignalProxy::Client && signature.contains("Requested")) - return true; - - return false; -} - -bool SignalRelay::synchronize() const { - return _sync; -} - -int SignalRelay::sigCount() const { - // only for debuging purpose - return sigNames.count(); -} - -void SignalRelay::attachSignal(int methodId, const QByteArray &func) { - // we ride without safetybelts here... all checking for valid method etc pp has to be done by the caller - // all connected methodIds are offset by the standard methodCount of QObject - if(!sigNames.contains(methodId)) - QMetaObject::connect(caller, methodId, this, QObject::staticMetaObject.methodCount() + methodId); - - QByteArray fn; - if(!func.isEmpty()) { - fn = QMetaObject::normalizedSignature(func); - } else { - fn = QByteArray("2") + caller->metaObject()->method(methodId).signature(); - } - sigNames.insert(methodId, fn); -} - // ================================================== // Peers // ================================================== @@ -212,6 +171,20 @@ void SignalProxy::IODevicePeer::dispatchSignal(const RequestType &requestType, c dispatchPackedFunc(QVariant(packedFunc)); } +bool SignalProxy::IODevicePeer::isSecure() const { +#ifdef HAVE_SSL + QSslSocket *sslSocket = qobject_cast(_device); + if(sslSocket) + return sslSocket->isEncrypted() || sslSocket->localAddress() == QHostAddress::LocalHost || sslSocket->localAddress() == QHostAddress::LocalHostIPv6; +#endif + + QAbstractSocket *socket = qobject_cast(_device); + if(socket) + return socket->localAddress() == QHostAddress::LocalHost || socket->localAddress() == QHostAddress::LocalHostIPv6; + + return false; +} + QString SignalProxy::IODevicePeer::address() const { QAbstractSocket *socket = qobject_cast(_device); if(socket) @@ -258,9 +231,18 @@ SignalProxy::SignalProxy(ProxyMode mode, QIODevice* device, QObject* parent) } SignalProxy::~SignalProxy() { - QList senders = _relayHash.keys(); - foreach(QObject* sender, senders) - detachObject(sender); + QHash::iterator classIter = _syncSlave.begin(); + while(classIter != _syncSlave.end()) { + ObjectId::iterator objIter = classIter->begin(); + while(objIter != classIter->end()) { + SyncableObject *obj = objIter.value(); + objIter = classIter->erase(objIter); + obj->stopSynchronize(this); + } + classIter++; + } + _syncSlave.clear(); + removeAllPeers(); } @@ -289,8 +271,11 @@ void SignalProxy::setProxyMode(ProxyMode mode) { } void SignalProxy::init() { + _signalRelay = new SignalRelay(this); connect(&_heartBeatTimer, SIGNAL(timeout()), this, SLOT(sendHeartBeat())); _heartBeatTimer.start(30 * 1000); + _secure = false; + updateSecureState(); } void SignalProxy::initServer() { @@ -320,6 +305,13 @@ bool SignalProxy::addPeer(QIODevice* iodev) { connect(iodev, SIGNAL(disconnected()), this, SLOT(removePeerBySender())); connect(iodev, SIGNAL(readyRead()), this, SLOT(dataAvailable())); +#ifdef HAVE_SSL + QSslSocket *sslSocket = qobject_cast(iodev); + if(sslSocket) { + connect(iodev, SIGNAL(encrypted()), this, SLOT(updateSecureState())); + } +#endif + if(!iodev->parent()) iodev->setParent(this); @@ -328,6 +320,7 @@ bool SignalProxy::addPeer(QIODevice* iodev) { if(_peers.count() == 1) emit connected(); + updateSecureState(); return true; } @@ -355,6 +348,7 @@ bool SignalProxy::addPeer(SignalProxy* proxy) { if(_peers.count() == 1) emit connected(); + updateSecureState(); return true; } @@ -397,6 +391,8 @@ void SignalProxy::removePeer(QObject* dev) { delete peer; + updateSecureState(); + if(_peers.isEmpty()) emit disconnected(); } @@ -405,235 +401,52 @@ void SignalProxy::removePeerBySender() { removePeer(sender()); } -void SignalProxy::objectRenamed(const QString &newname, const QString &oldname) { - SyncableObject *syncObject = qobject_cast(sender()); - const QMetaObject *meta = syncObject->metaObject(); - const QByteArray className(meta->className()); - objectRenamed(className, newname, oldname); - +void SignalProxy::renameObject(const SyncableObject *obj, const QString &newname, const QString &oldname) { if(proxyMode() == Client) return; + const QMetaObject *meta = obj->syncMetaObject(); + const QByteArray className(meta->className()); + objectRenamed(className, newname, oldname); + QVariantList params; params << "__objectRenamed__" << className << newname << oldname; dispatchSignal(RpcCall, params); } void SignalProxy::objectRenamed(const QByteArray &classname, const QString &newname, const QString &oldname) { + if(proxyMode() == Server) + return; + if(_syncSlave.contains(classname) && _syncSlave[classname].contains(oldname) && oldname != newname) { SyncableObject *obj = _syncSlave[classname][newname] = _syncSlave[classname].take(oldname); requestInit(obj); } } -void SignalProxy::setArgTypes(QObject* obj, int methodId) { - const QMetaObject *meta = metaObject(obj); - QList p = meta->method(methodId).parameterTypes(); - QList argTypes; - int ct = p.count(); - for(int i=0; iargTypes.contains(methodId)); - _classInfo[meta]->argTypes[methodId] = argTypes; -} - -const QList &SignalProxy::argTypes(QObject *obj, int methodId) { - const QMetaObject *meta = metaObject(obj); - Q_ASSERT(_classInfo.contains(meta)); - if(!_classInfo[meta]->argTypes.contains(methodId)) - setArgTypes(obj, methodId); - return _classInfo[meta]->argTypes[methodId]; -} - -void SignalProxy::setReturnType(QObject *obj, int methodId) { - const QMetaObject *meta = metaObject(obj); - int returnType = QMetaType::type(meta->method(methodId).typeName()); - - Q_ASSERT(!_classInfo[meta]->returnType.contains(methodId)); - _classInfo[meta]->returnType[methodId] = returnType; -} - -const int &SignalProxy::returnType(QObject *obj, int methodId) { - const QMetaObject *meta = metaObject(obj); - Q_ASSERT(_classInfo.contains(meta)); - if(!_classInfo[meta]->returnType.contains(methodId)) - setReturnType(obj, methodId); - return _classInfo[meta]->returnType[methodId]; -} - -void SignalProxy::setMinArgCount(QObject *obj, int methodId) { - const QMetaObject *meta = metaObject(obj); - QString signature(meta->method(methodId).signature()); - int minCount = meta->method(methodId).parameterTypes().count() - signature.count("="); - Q_ASSERT(!_classInfo[meta]->minArgCount.contains(methodId)); - _classInfo[meta]->minArgCount[methodId] = minCount; -} - -const int &SignalProxy::minArgCount(QObject *obj, int methodId) { - const QMetaObject *meta = metaObject(obj); - Q_ASSERT(_classInfo.contains(meta)); - if(!_classInfo[meta]->minArgCount.contains(methodId)) - setMinArgCount(obj, methodId); - return _classInfo[meta]->minArgCount[methodId]; -} - -void SignalProxy::setMethodName(QObject *obj, int methodId) { - const QMetaObject *meta = metaObject(obj); - QByteArray method(::methodName(meta->method(methodId))); - Q_ASSERT(!_classInfo[meta]->methodNames.contains(methodId)); - _classInfo[meta]->methodNames[methodId] = method; -} - -const QByteArray &SignalProxy::methodName(QObject *obj, int methodId) { - const QMetaObject *meta = metaObject(obj); - Q_ASSERT(_classInfo.contains(meta)); - if(!_classInfo[meta]->methodNames.contains(methodId)) - setMethodName(obj, methodId); - return _classInfo[meta]->methodNames[methodId]; -} - - -void SignalProxy::setSyncMap(SyncableObject *obj) { - const QMetaObject *meta = obj->syncMetaObject(); - QHash syncMap; - - QList slotIndexes; - for(int i = 0; i < meta->methodCount(); i++) { - if(meta->method(i).methodType() == QMetaMethod::Slot) - slotIndexes << i; - } - - // we're faking sync pairs for sync replies - QByteArray slotSignature; - foreach(int slotIdx, slotIndexes) { - slotSignature = QByteArray(meta->method(slotIdx).signature()); - if(!slotSignature.startsWith("receive")) - continue; - syncMap[slotSignature] = slotIdx; - } - - QMetaMethod signal, slot; - int matchIdx; - for(int signalIdx = 0; signalIdx < meta->methodCount(); signalIdx++) { - signal = meta->method(signalIdx); - if(signal.methodType() != QMetaMethod::Signal) - continue; - - matchIdx = -1; - foreach(int slotIdx, slotIndexes) { - slot = meta->method(slotIdx); - if(methodsMatch(signal, slot)) { - matchIdx = slotIdx; - break; - } - } - if(matchIdx != -1) { - slotIndexes.removeAt(slotIndexes.indexOf(matchIdx)); - syncMap[QByteArray(signal.signature())] = matchIdx; - } - } - - Q_ASSERT(_classInfo[meta]->syncMap.isEmpty()); - _classInfo[meta]->syncMap = syncMap; -} - -const QHash &SignalProxy::syncMap(SyncableObject *obj) { - const QMetaObject *meta = obj->syncMetaObject(); - Q_ASSERT(_classInfo.contains(meta)); - if(_classInfo[meta]->syncMap.isEmpty()) - setSyncMap(obj); - return _classInfo[meta]->syncMap; -} - -void SignalProxy::setReceiveMap(SyncableObject *obj) { - const QMetaObject *meta = obj->syncMetaObject(); - Q_ASSERT(_classInfo.contains(meta)); - - QHash receiveMap; - - QMetaMethod requestSlot; - QByteArray returnTypeName; - QByteArray signature; - QByteArray methodName; - QByteArray params; - int paramsPos; - int receiverId; - const int methodCount = meta->methodCount(); - for(int i = 0; i < methodCount; i++) { - requestSlot = meta->method(i); - if(requestSlot.methodType() != QMetaMethod::Slot) - continue; - - returnTypeName = requestSlot.typeName(); - if(QMetaType::Void == (QMetaType::Type)returnType(obj, i)) - continue; - - signature = QByteArray(requestSlot.signature()); - if(!signature.startsWith("request")) - continue; - - paramsPos = signature.indexOf('('); - if(paramsPos == -1) - continue; - - methodName = signature.left(paramsPos); - params = signature.mid(paramsPos); - - methodName = methodName.replace("request", "receive"); - params = params.left(params.count() - 1) + ", " + returnTypeName + ")"; - - signature = QMetaObject::normalizedSignature(methodName + params); - receiverId = meta->indexOfSlot(signature); - - if(receiverId == -1) { - signature = QMetaObject::normalizedSignature(methodName + "(" + returnTypeName + ")"); - receiverId = meta->indexOfSlot(signature); - } - - if(receiverId != -1) - receiveMap[i] = receiverId; - } - _classInfo[meta]->receiveMap = receiveMap; -} - -const QHash &SignalProxy::receiveMap(SyncableObject *obj) { - const QMetaObject *meta = obj->syncMetaObject(); - Q_ASSERT(_classInfo.contains(meta)); - if(_classInfo[meta]->receiveMap.isEmpty()) - setReceiveMap(obj); - return _classInfo[meta]->receiveMap; -} - -void SignalProxy::setUpdatedRemotelyId(SyncableObject *obj) { - const QMetaObject *meta = obj->syncMetaObject(); - Q_ASSERT(_classInfo.contains(meta)); - _classInfo[meta]->updatedRemotelyId = meta->indexOfSignal("updatedRemotely()"); -} - -int SignalProxy::updatedRemotelyId(SyncableObject *obj) { - Q_ASSERT(_classInfo.contains(obj->syncMetaObject())); - return _classInfo[obj->syncMetaObject()]->updatedRemotelyId; -} - -const QMetaObject *SignalProxy::metaObject(QObject *obj) { - if(SyncableObject *syncObject = qobject_cast(obj)) +const QMetaObject *SignalProxy::metaObject(const QObject *obj) { + if(const SyncableObject *syncObject = qobject_cast(obj)) return syncObject->syncMetaObject(); else return obj->metaObject(); } -void SignalProxy::createClassInfo(QObject *obj) { - const QMetaObject *meta = metaObject(obj); - if(_classInfo.contains(meta)) - return; +SignalProxy::ExtendedMetaObject *SignalProxy::extendedMetaObject(const QMetaObject *meta) const { + if(_extendedMetaObjects.contains(meta)) + return _extendedMetaObjects[meta]; + else + return 0; +} - ClassInfo *classInfo = new ClassInfo(); - _classInfo[meta] = classInfo; +SignalProxy::ExtendedMetaObject *SignalProxy::createExtendedMetaObject(const QMetaObject *meta, bool checkConflicts) { + if(!_extendedMetaObjects.contains(meta)) { + _extendedMetaObjects[meta] = new ExtendedMetaObject(meta, checkConflicts); + } + return _extendedMetaObjects[meta]; } -bool SignalProxy::attachSignal(QObject* sender, const char* signal, const QByteArray& sigName) { - const QMetaObject* meta = metaObject(sender); +bool SignalProxy::attachSignal(QObject *sender, const char* signal, const QByteArray& sigName) { + const QMetaObject* meta = sender->metaObject(); QByteArray sig(meta->normalizedSignature(signal).mid(1)); int methodId = meta->indexOfMethod(sig.constData()); if(methodId == -1 || meta->method(methodId).methodType() != QMetaMethod::Signal) { @@ -641,20 +454,14 @@ bool SignalProxy::attachSignal(QObject* sender, const char* signal, const QByteA return false; } - createClassInfo(sender); - - SignalRelay* relay; - if(_relayHash.contains(sender)) - relay = _relayHash[sender]; - else - relay = _relayHash[sender] = new SignalRelay(this, sender); - - relay->attachSignal(methodId, sigName); + createExtendedMetaObject(meta); + _signalRelay->attachSignal(sender, methodId, sigName); + disconnect(sender, SIGNAL(destroyed(QObject *)), this, SLOT(detachObject(QObject *))); + connect(sender, SIGNAL(destroyed(QObject *)), this, SLOT(detachObject(QObject *))); return true; } - bool SignalProxy::attachSlot(const QByteArray& sigName, QObject* recv, const char* slot) { const QMetaObject* meta = recv->metaObject(); int methodId = meta->indexOfMethod(meta->normalizedSignature(slot).mid(1)); @@ -663,35 +470,24 @@ bool SignalProxy::attachSlot(const QByteArray& sigName, QObject* recv, const cha return false; } - createClassInfo(recv); + createExtendedMetaObject(meta); QByteArray funcName = QMetaObject::normalizedSignature(sigName.constData()); _attachedSlots.insert(funcName, qMakePair(recv, methodId)); - QObject::disconnect(recv, SIGNAL(destroyed()), this, SLOT(detachSender())); - QObject::connect(recv, SIGNAL(destroyed()), this, SLOT(detachSender())); + disconnect(recv, SIGNAL(destroyed(QObject *)), this, SLOT(detachObject(QObject *))); + connect(recv, SIGNAL(destroyed(QObject *)), this, SLOT(detachObject(QObject *))); return true; } void SignalProxy::synchronize(SyncableObject *obj) { - createClassInfo(obj); - setUpdatedRemotelyId(obj); - - // attaching all the Signals - SignalRelay* relay; - if(_relayHash.contains(obj)) - relay = _relayHash[obj]; - else - relay = _relayHash[obj] = new SignalRelay(this, obj); - - relay->setSynchronize(true); + createExtendedMetaObject(obj, true); // attaching as slave to receive sync Calls QByteArray className(obj->syncMetaObject()->className()); _syncSlave[className][obj->objectName()] = obj; if(proxyMode() == Server) { - connect(obj, SIGNAL(objectRenamed(QString, QString)), this, SLOT(objectRenamed(QString, QString))); obj->setInitialized(); emit objectInitialized(obj); } else { @@ -700,32 +496,17 @@ void SignalProxy::synchronize(SyncableObject *obj) { else requestInit(obj); } -} -void SignalProxy::requestInit(SyncableObject *obj) { - if(proxyMode() == Server || obj->isInitialized()) - return; - - QVariantList params; - params << obj->syncMetaObject()->className() - << obj->objectName(); - dispatchSignal(InitRequest, params); + obj->synchronize(this); } -void SignalProxy::detachSender() { - detachObject(sender()); -} - -void SignalProxy::detachObject(QObject* obj) { +void SignalProxy::detachObject(QObject *obj) { detachSignals(obj); detachSlots(obj); - stopSync(static_cast(obj)); } -void SignalProxy::detachSignals(QObject* sender) { - if(!_relayHash.contains(sender)) - return; - _relayHash.take(sender)->deleteLater(); +void SignalProxy::detachSignals(QObject *sender) { + _signalRelay->detachSignal(sender); } void SignalProxy::detachSlots(QObject* receiver) { @@ -738,10 +519,7 @@ void SignalProxy::detachSlots(QObject* receiver) { } } -void SignalProxy::stopSync(SyncableObject* obj) { - if(_relayHash.contains(obj)) - _relayHash[obj]->setSynchronize(false); - +void SignalProxy::stopSynchronize(SyncableObject *obj) { // we can't use a className here, since it might be effed up, if we receive the call as a result of a decon // gladly the objectName() is still valid. So we have only to iterate over the classes not each instance! *sigh* QHash::iterator classIter = _syncSlave.begin(); @@ -752,6 +530,7 @@ void SignalProxy::stopSync(SyncableObject* obj) { } classIter++; } + obj->stopSynchronize(this); } void SignalProxy::dispatchSignal(const RequestType &requestType, const QVariantList ¶ms) { @@ -791,6 +570,18 @@ void SignalProxy::receivePackedFunc(AbstractPeer *sender, const QVariant &packed } void SignalProxy::receivePeerSignal(AbstractPeer *sender, const RequestType &requestType, const QVariantList ¶ms) { + switch(requestType) { + // list all RequestTypes that shouldnot trigger a heartbeat counter reset here + case HeartBeatReply: + break; + default: + if(sender->type() == AbstractPeer::IODevicePeer) { + IODevicePeer *ioPeer = static_cast(sender); + ioPeer->sentHeartBeats = 0; + } + } + + // qDebug() << "SignalProxy::receivePeerSignal)" << requestType << params; switch(requestType) { case RpcCall: if(params.empty()) @@ -842,43 +633,50 @@ void SignalProxy::handleSync(AbstractPeer *sender, QVariantList params) { QByteArray className = params.takeFirst().toByteArray(); QString objectName = params.takeFirst().toString(); - QByteArray signal = params.takeFirst().toByteArray(); + QByteArray slot = params.takeFirst().toByteArray(); if(!_syncSlave.contains(className) || !_syncSlave[className].contains(objectName)) { - qWarning() << QString("no registered receiver for sync call: %1::%2 (objectName=\"%3\"). Params are:").arg(QString(className)).arg(QString(signal)).arg(objectName) + qWarning() << QString("no registered receiver for sync call: %1::%2 (objectName=\"%3\"). Params are:").arg(QString(className)).arg(QString(slot)).arg(objectName) << params; return; } SyncableObject *receiver = _syncSlave[className][objectName]; - if(!syncMap(receiver).contains(signal)) { - qWarning() << QString("no matching slot for sync call: %1::%2 (objectName=\"%3\"). Params are:").arg(QString(className)).arg(QString(signal)).arg(objectName) + ExtendedMetaObject *eMeta = extendedMetaObject(receiver); + if(!eMeta->slotMap().contains(slot)) { + qWarning() << QString("no matching slot for sync call: %1::%2 (objectName=\"%3\"). Params are:").arg(QString(className)).arg(QString(slot)).arg(objectName) << params; return; } - int slotId = syncMap(receiver)[signal]; + int slotId = eMeta->slotMap()[slot]; + if(proxyMode() != eMeta->receiverMode(slotId)) { + qWarning("SignalProxy::handleSync(): invokeMethod for \"%s\" failed. Wrong ProxyMode!", eMeta->methodName(slotId).constData()); + return; + } - QVariant returnValue((QVariant::Type)returnType(receiver, slotId)); + QVariant returnValue((QVariant::Type)eMeta->returnType(slotId)); if(!invokeSlot(receiver, slotId, params, returnValue)) { - qWarning("SignalProxy::handleSync(): invokeMethod for \"%s\" failed ", methodName(receiver, slotId).constData()); + qWarning("SignalProxy::handleSync(): invokeMethod for \"%s\" failed ", eMeta->methodName(slotId).constData()); return; } - if(returnValue.type() != QVariant::Invalid && receiveMap(receiver).contains(slotId)) { - int receiverId = receiveMap(receiver)[slotId]; + + if(returnValue.type() != QVariant::Invalid && eMeta->receiveMap().contains(slotId)) { + int receiverId = eMeta->receiveMap()[slotId]; QVariantList returnParams; returnParams << className << objectName - << QByteArray(receiver->metaObject()->method(receiverId).signature()); - if(argTypes(receiver, receiverId).count() > 1) + << eMeta->methodName(receiverId); + //QByteArray(receiver->metaObject()->method(receiverId).signature()); + if(eMeta->argTypes(receiverId).count() > 1) returnParams << params; returnParams << returnValue; sender->dispatchSignal(Sync, returnParams); } // send emit update signal - invokeSlot(receiver, updatedRemotelyId(receiver)); + invokeSlot(receiver, eMeta->updatedRemotelyId()); } void SignalProxy::handleInitRequest(AbstractPeer *sender, const QVariantList ¶ms) { @@ -952,20 +750,23 @@ void SignalProxy::handleSignal(const QVariantList &data) { while(slot != _attachedSlots.constEnd() && slot.key() == funcName) { receiver = (*slot).first; methodId = (*slot).second; - if(!invokeSlot(receiver, methodId, params)) - qWarning("SignalProxy::handleSignal(): invokeMethod for \"%s\" failed ", methodName(receiver, methodId).constData()); + if(!invokeSlot(receiver, methodId, params)) { + ExtendedMetaObject *eMeta = extendedMetaObject(receiver); + qWarning("SignalProxy::handleSignal(): invokeMethod for \"%s\" failed ", eMeta->methodName(methodId).constData()); + } slot++; } } bool SignalProxy::invokeSlot(QObject *receiver, int methodId, const QVariantList ¶ms, QVariant &returnValue) { - const QList args = argTypes(receiver, methodId); + ExtendedMetaObject *eMeta = extendedMetaObject(receiver); + const QList args = eMeta->argTypes(methodId); const int numArgs = params.count() < args.count() ? params.count() : args.count(); - if(minArgCount(receiver, methodId) > params.count()) { - qWarning() << "SignalProxy::invokeSlot(): not enough params to invoke" << methodName(receiver, methodId); + if(eMeta->minArgCount(methodId) > params.count()) { + qWarning() << "SignalProxy::invokeSlot(): not enough params to invoke" << eMeta->methodName(methodId); return false; } @@ -981,7 +782,7 @@ bool SignalProxy::invokeSlot(QObject *receiver, int methodId, const QVariantList return false; } if(args[i] != QMetaType::type(params[i].typeName())) { - qWarning() << "SignalProxy::invokeSlot(): incompatible param types to invoke" << methodName(receiver, methodId); + qWarning() << "SignalProxy::invokeSlot(): incompatible param types to invoke" << eMeta->methodName(methodId); return false; } _a[i+1] = const_cast(params[i].constData()); @@ -994,7 +795,7 @@ bool SignalProxy::invokeSlot(QObject *receiver, int methodId, const QVariantList ? Qt::DirectConnection : Qt::QueuedConnection; - if (type == Qt::DirectConnection) { + if(type == Qt::DirectConnection) { return receiver->qt_metacall(QMetaObject::InvokeMetaMethod, methodId, _a) < 0; } else { qWarning() << "Queued Connections are not implemented yet"; @@ -1052,6 +853,9 @@ void SignalProxy::writeDataToDevice(QIODevice *dev, const QVariant &item, bool c } bool SignalProxy::readDataFromDevice(QIODevice *dev, quint32 &blockSize, QVariant &item, bool compressed) { + if(!dev) + return false; + QDataStream in(dev); in.setVersion(QDataStream::Qt_4_2); @@ -1061,12 +865,12 @@ bool SignalProxy::readDataFromDevice(QIODevice *dev, quint32 &blockSize, QVarian } if(blockSize > 1 << 22) { - disconnectDevice(dev, tr("Client tried to send package larger than max package size!")); + disconnectDevice(dev, tr("Peer tried to send package larger than max package size!")); return false; } if(blockSize == 0) { - disconnectDevice(dev, tr("Client tried to send 0 byte package!")); + disconnectDevice(dev, tr("Peer tried to send 0 byte package!")); return false; } @@ -1083,7 +887,7 @@ bool SignalProxy::readDataFromDevice(QIODevice *dev, quint32 &blockSize, QVarian if(nbytes <= 4) { const char *data = rawItem.constData(); if(nbytes < 4 || (data[0]!=0 || data[1]!=0 || data[2]!=0 || data[3]!=0)) { - disconnectDevice(dev, tr("Client sent corrupted compressed data!")); + disconnectDevice(dev, tr("Peer sent corrupted compressed data!")); return false; } } @@ -1098,53 +902,21 @@ bool SignalProxy::readDataFromDevice(QIODevice *dev, quint32 &blockSize, QVarian } if(!item.isValid()) { - disconnectDevice(dev, tr("Client sent corrupt data: unable to load QVariant!")); + disconnectDevice(dev, tr("Peer sent corrupt data: unable to load QVariant!")); return false; } return true; } -bool SignalProxy::methodsMatch(const QMetaMethod &signal, const QMetaMethod &slot) const { - // if we don't even have the same basename it's a sure NO - if(methodBaseName(signal) != methodBaseName(slot)) - return false; - - // are the signatures compatible? - if(!QObject::staticMetaObject.checkConnectArgs(signal.signature(), slot.signature())) - return false; - - // we take an educated guess if the signals and slots match - QString signalsuffix = ::methodName(signal).mid(QString(::methodName(signal)).lastIndexOf(QRegExp("[A-Z]"))).toLower(); - QString slotprefix = ::methodName(slot).left(QString(::methodName(slot)).indexOf(QRegExp("[A-Z]"))).toLower(); - - uint sizediff = qAbs(slotprefix.size() - signalsuffix.size()); - int ratio = editingDistance(slotprefix, signalsuffix) - sizediff; - return (ratio < 2); -} - -QString SignalProxy::methodBaseName(const QMetaMethod &method) { - QString methodname = QString(method.signature()).section("(", 0, 0); - - // determine where we have to chop: - int upperCharPos; - if(method.methodType() == QMetaMethod::Slot) { - // we take evertyhing from the first uppercase char if it's slot - upperCharPos = methodname.indexOf(QRegExp("[A-Z]")); - if(upperCharPos == -1) - return QString(); - methodname = methodname.mid(upperCharPos); - } else { - // and if it's a signal we discard everything from the last uppercase char - upperCharPos = methodname.lastIndexOf(QRegExp("[A-Z]")); - if(upperCharPos == -1) - return QString(); - methodname = methodname.left(upperCharPos); - } - - methodname[0] = methodname[0].toUpper(); +void SignalProxy::requestInit(SyncableObject *obj) { + if(proxyMode() == Server || obj->isInitialized()) + return; - return methodname; + QVariantList params; + params << obj->syncMetaObject()->className() + << obj->objectName(); + dispatchSignal(InitRequest, params); } QVariantMap SignalProxy::initData(SyncableObject *obj) const { @@ -1157,7 +929,7 @@ void SignalProxy::setInitData(SyncableObject *obj, const QVariantMap &properties obj->fromVariantMap(properties); obj->setInitialized(); emit objectInitialized(obj); - invokeSlot(obj, updatedRemotelyId(obj)); + invokeSlot(obj, extendedMetaObject(obj)->updatedRemotelyId()); } void SignalProxy::sendHeartBeat() { @@ -1225,6 +997,34 @@ void SignalProxy::customEvent(QEvent *event) { } } +void SignalProxy::sync_call__(const SyncableObject *obj, SignalProxy::ProxyMode modeType, const char *funcname, va_list ap) { + // qDebug() << obj << modeType << "(" << _proxyMode << ")" << funcname; + if(modeType != _proxyMode) + return; + + ExtendedMetaObject *eMeta = extendedMetaObject(obj); + + QVariantList params; + params << eMeta->metaObject()->className() + << obj->objectName() + << QByteArray(funcname); + + const QList &argTypes = eMeta->argTypes(eMeta->methodId(QByteArray(funcname))); + + for(int i = 0; i < argTypes.size(); i++) { + if(argTypes[i] == 0) { + qWarning() << Q_FUNC_INFO << "received invalid data for argument number" << i << "of signal" << QString("%1::%2").arg(eMeta->metaObject()->className()).arg(funcname); + qWarning() << " - make sure all your data types are known by the Qt MetaSystem"; + return; + } + params << QVariant(argTypes[i], va_arg(ap, void *)); + } + + dispatchSignal(Sync, params); +} + + + void SignalProxy::disconnectDevice(QIODevice *dev, const QString &reason) { if(!reason.isEmpty()) qWarning() << qPrintable(reason); @@ -1241,7 +1041,6 @@ void SignalProxy::updateLag(IODevicePeer *peer, int lag) { } } - void SignalProxy::dumpProxyStats() { QString mode; if(proxyMode() == Server) @@ -1249,37 +1048,185 @@ void SignalProxy::dumpProxyStats() { else mode = "Client"; - int sigCount = 0; - foreach(SignalRelay *relay, _relayHash.values()) - sigCount += relay->sigCount(); - int slaveCount = 0; foreach(ObjectId oid, _syncSlave.values()) slaveCount += oid.count(); qDebug() << this; qDebug() << " Proxy Mode:" << mode; - qDebug() << "attached sending Objects:" << _relayHash.count(); - qDebug() << " number of Signals:" << sigCount; qDebug() << " attached Slots:" << _attachedSlots.count(); qDebug() << " number of synced Slaves:" << slaveCount; - qDebug() << "number of Classes cached:" << _classInfo.count(); + qDebug() << "number of Classes cached:" << _extendedMetaObjects.count(); } -void SignalProxy::dumpSyncMap(SyncableObject *object) { - const QMetaObject *meta = object->metaObject(); - qDebug() << "SignalProxy: SyncMap for Class" << meta->className(); - - QHash syncMap_ = syncMap(object); - QHash::const_iterator iter = syncMap_.constBegin(); - while(iter != syncMap_.constEnd()) { - qDebug() << iter.key() << "-->" << iter.value() << meta->method(iter.value()).signature(); - iter++; - } -// QHash syncMap_ = syncMap(object); -// QHash::const_iterator iter = syncMap_.constBegin(); -// while(iter != syncMap_.constEnd()) { -// qDebug() << iter.key() << meta->method(iter.key()).signature() << "-->" << iter.value() << meta->method(iter.value()).signature(); -// iter++; -// } +void SignalProxy::updateSecureState() { + bool wasSecure = _secure; + + _secure = !_peers.isEmpty(); + PeerHash::const_iterator peerIter; + for(peerIter = _peers.constBegin(); peerIter != _peers.constEnd(); peerIter++) { + _secure &= (*peerIter)->isSecure(); + } + + if(wasSecure != _secure) + emit secureStateChanged(_secure); } + + +// ================================================== +// ExtendedMetaObject +// ================================================== +SignalProxy::ExtendedMetaObject::ExtendedMetaObject(const QMetaObject *meta, bool checkConflicts) + : _meta(meta), + _updatedRemotelyId(_meta->indexOfSignal("updatedRemotely()")) +{ + for(int i = 0; i < _meta->methodCount(); i++) { + if(_meta->method(i).methodType() != QMetaMethod::Slot) + continue; + + if(QByteArray(_meta->method(i).signature()).contains('*')) + continue; // skip methods with ptr params + + QByteArray method = methodName(_meta->method(i)); + if(method.startsWith("init")) + continue; // skip initializers + + if(_methodIds.contains(method)) { + /* funny... moc creates for methods containing default parameters multiple metaMethod with separate methodIds. + we don't care... we just need the full fledged version + */ + const QMetaMethod ¤t = _meta->method(_methodIds[method]); + const QMetaMethod &candidate = _meta->method(i); + if(current.parameterTypes().count() > candidate.parameterTypes().count()) { + int minCount = candidate.parameterTypes().count(); + QList commonParams = current.parameterTypes().mid(0, minCount); + if(commonParams == candidate.parameterTypes()) + continue; // we already got the full featured version + } else { + int minCount = current.parameterTypes().count(); + QList commonParams = candidate.parameterTypes().mid(0, minCount); + if(commonParams == current.parameterTypes()) { + _methodIds[method] = i; // use the new one + continue; + } + } + if(checkConflicts) { + qWarning() << "class" << meta->className() << "contains overloaded methods which is currently not supported!"; + qWarning() << " - " << _meta->method(i).signature() << "conflicts with" << _meta->method(_methodIds[method]).signature(); + } + continue; + } + _methodIds[method] = i; + } +} + +const SignalProxy::ExtendedMetaObject::MethodDescriptor &SignalProxy::ExtendedMetaObject::methodDescriptor(int methodId) { + if(!_methods.contains(methodId)) { + _methods[methodId] = MethodDescriptor(_meta->method(methodId)); + } + return _methods[methodId]; +} + +const QHash &SignalProxy::ExtendedMetaObject::receiveMap() { + if(_receiveMap.isEmpty()) { + QHash receiveMap; + + QMetaMethod requestSlot; + QByteArray returnTypeName; + QByteArray signature; + QByteArray methodName; + QByteArray params; + int paramsPos; + int receiverId; + const int methodCount = _meta->methodCount(); + for(int i = 0; i < methodCount; i++) { + requestSlot = _meta->method(i); + if(requestSlot.methodType() != QMetaMethod::Slot) + continue; + + returnTypeName = requestSlot.typeName(); + if(QMetaType::Void == (QMetaType::Type)returnType(i)) + continue; + + signature = QByteArray(requestSlot.signature()); + if(!signature.startsWith("request")) + continue; + + paramsPos = signature.indexOf('('); + if(paramsPos == -1) + continue; + + methodName = signature.left(paramsPos); + params = signature.mid(paramsPos); + + methodName = methodName.replace("request", "receive"); + params = params.left(params.count() - 1) + ", " + returnTypeName + ")"; + + signature = QMetaObject::normalizedSignature(methodName + params); + receiverId = _meta->indexOfSlot(signature); + + if(receiverId == -1) { + signature = QMetaObject::normalizedSignature(methodName + "(" + returnTypeName + ")"); + receiverId = _meta->indexOfSlot(signature); + } + + if(receiverId != -1) { + receiveMap[i] = receiverId; + qDebug() << requestSlot.signature() << _meta->method(receiverId).signature() << "---" << i << receiverId; + } + } + _receiveMap = receiveMap; + } + return _receiveMap; +} + +QByteArray SignalProxy::ExtendedMetaObject::methodName(const QMetaMethod &method) { + QByteArray sig(method.signature()); + return sig.left(sig.indexOf("(")); +} + +QString SignalProxy::ExtendedMetaObject::methodBaseName(const QMetaMethod &method) { + QString methodname = QString(method.signature()).section("(", 0, 0); + + // determine where we have to chop: + int upperCharPos; + if(method.methodType() == QMetaMethod::Slot) { + // we take evertyhing from the first uppercase char if it's slot + upperCharPos = methodname.indexOf(QRegExp("[A-Z]")); + if(upperCharPos == -1) + return QString(); + methodname = methodname.mid(upperCharPos); + } else { + // and if it's a signal we discard everything from the last uppercase char + upperCharPos = methodname.lastIndexOf(QRegExp("[A-Z]")); + if(upperCharPos == -1) + return QString(); + methodname = methodname.left(upperCharPos); + } + + methodname[0] = methodname[0].toUpper(); + + return methodname; +} + +SignalProxy::ExtendedMetaObject::MethodDescriptor::MethodDescriptor(const QMetaMethod &method) + : _methodName(SignalProxy::ExtendedMetaObject::methodName(method)), + _returnType(QMetaType::type(method.typeName())) +{ + // determine argTypes + QList paramTypes = method.parameterTypes(); + QList argTypes; + for(int i = 0; i < paramTypes.count(); i++) { + argTypes.append(QMetaType::type(paramTypes[i])); + } + _argTypes = argTypes; + + // determine minArgCount + QString signature(method.signature()); + _minArgCount = method.parameterTypes().count() - signature.count("="); + + _receiverMode = (_methodName.startsWith("request")) + ? SignalProxy::Server + : SignalProxy::Client; +} +