- slotIter++;
- }
-}
-
-void SignalProxy::call(const char* signal, QVariant p1, QVariant p2, QVariant p3, QVariant p4, QVariant p5, QVariant p6, QVariant p7, QVariant p8, QVariant p9) {
- QByteArray func = QMetaObject::normalizedSignature(signal);
- QVariantList params;
- params << p1 << p2 << p3 << p4 << p5 << p6 << p7 << p8 << p9;
- call(func, params);
-}
-
-void SignalProxy::call(const QByteArray &funcName, const QVariantList ¶ms) {
- QVariantList packedFunc;
- packedFunc << funcName;
- packedFunc << params;
- foreach(QIODevice* dev, _peerByteCount.keys())
- writeDataToDevice(dev, QVariant(packedFunc));
-}
-
-void SignalProxy::receivePeerSignal(const QVariant &packedFunc) {
- QVariantList params(packedFunc.toList());
- QByteArray funcName = params.takeFirst().toByteArray();
- int numParams, methodId;
- QObject* receiver;
-
- SlotHash::const_iterator slot = _attachedSlots.constFind(funcName);
- while(slot != _attachedSlots.constEnd() && slot.key() == funcName) {
- receiver = (*slot).first;
- methodId = (*slot).second;
- numParams = argTypes(receiver, methodId).count();
- QGenericArgument args[9];
- for(int i = 0; i < numParams; i++)
- args[i] = QGenericArgument(params[i].typeName(), params[i].constData());
- if(!QMetaObject::invokeMethod(receiver, methodName(receiver, methodId),
- args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7], args[8])) {
- qWarning("SignalProxy::receivePeerSignal(): invokeMethod for \"%s\" failed ", methodName(receiver, methodId).constData());
- }
- slot++;
- }
-}
-
-void SignalProxy::dataAvailable() {
- // yet again. it's a private slot. no need for checks.
- QIODevice* ioDev = qobject_cast<QIODevice* >(sender());
- QVariant var;
- while(readDataFromDevice(ioDev, _peerByteCount[ioDev], var))
- receivePeerSignal(var);
-}
-
-void SignalProxy::writeDataToDevice(QIODevice *dev, const QVariant &item) {
- QAbstractSocket* sock = qobject_cast<QAbstractSocket*>(dev);
- if(!dev->isOpen() || (sock && sock->state()!=QAbstractSocket::ConnectedState)) {
- qWarning("SignalProxy: Can't call on a closed device");
- return;
- }
- QByteArray block;
- QDataStream out(&block, QIODevice::WriteOnly);
- out.setVersion(QDataStream::Qt_4_2);
- out << (quint32)0 << item;
- out.device()->seek(0);
- out << (quint32)(block.size() - sizeof(quint32));
- dev->write(block);
-}
-
-bool SignalProxy::readDataFromDevice(QIODevice *dev, quint32 &blockSize, QVariant &item) {
- QDataStream in(dev);
- in.setVersion(QDataStream::Qt_4_2);
-
- if(blockSize == 0) {
- if(dev->bytesAvailable() < (int)sizeof(quint32)) return false;
- in >> blockSize;
- }
-
- if(dev->bytesAvailable() < blockSize)
- return false;
- in >> item;
- blockSize = 0;
- return true;
-}
-
-void SignalProxy::dumpProxyStats() {
- QString mode;
- if(proxyMode() == Server)
- mode = "Server";
- else
- mode = "Client";
-
- int sigCount = 0;
- foreach(SignalRelay *relay, _relayHash.values())
- sigCount += relay->sigCount();
-
- 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 Classes cached:" << _classInfo.count();
+ dispatch(SyncMessage(eMeta->metaObject()->className(), obj->objectName(), QByteArray(funcname), params));
+}
+
+
+void SignalProxy::disconnectDevice(QIODevice *dev, const QString &reason)
+{
+ if (!reason.isEmpty())
+ qWarning() << qPrintable(reason);
+ QAbstractSocket *sock = qobject_cast<QAbstractSocket *>(dev);
+ if (sock)
+ qWarning() << qPrintable(tr("Disconnecting")) << qPrintable(sock->peerAddress().toString());
+ dev->close();
+}
+
+
+void SignalProxy::dumpProxyStats()
+{
+ QString mode;
+ if (proxyMode() == Server)
+ mode = "Server";
+ else
+ mode = "Client";
+
+ int slaveCount = 0;
+ foreach(ObjectId oid, _syncSlave.values())
+ slaveCount += oid.count();
+
+ qDebug() << this;
+ qDebug() << " Proxy Mode:" << mode;
+ qDebug() << " attached Slots:" << _attachedSlots.count();
+ qDebug() << " number of synced Slaves:" << slaveCount;
+ qDebug() << "number of Classes cached:" << _extendedMetaObjects.count();
+}
+
+
+void SignalProxy::updateSecureState()
+{
+ bool wasSecure = _secure;
+
+ _secure = !_peerMap.isEmpty();
+ for (auto peer : _peerMap.values()) {
+ _secure &= peer->isSecure();
+ }
+
+ if (wasSecure != _secure)
+ emit secureStateChanged(_secure);
+}
+
+QVariantList SignalProxy::peerData() {
+ QVariantList result;
+ for (auto &&peer : _peerMap.values()) {
+ QVariantMap data;
+ data["id"] = peer->id();
+ data["clientVersion"] = peer->clientVersion();
+ // We explicitly rename this, as, due to the Debian reproducability changes, buildDate isn’t actually the build
+ // date anymore, but on newer clients the date of the last git commit
+ data["clientVersionDate"] = peer->buildDate();
+ data["remoteAddress"] = peer->address();
+ data["connectedSince"] = peer->connectedSince();
+ data["secure"] = peer->isSecure();
+ data["features"] = static_cast<quint32>(peer->features().toLegacyFeatures());
+ data["featureList"] = peer->features().toStringList();
+ result << data;
+ }
+ return result;
+}
+
+Peer *SignalProxy::peerById(int peerId) {
+ return _peerMap[peerId];
+}
+
+void SignalProxy::restrictTargetPeers(QSet<Peer*> peers, std::function<void()> closure)
+{
+ auto previousRestrictMessageTarget = _restrictMessageTarget;
+ auto previousRestrictedTargets = _restrictedTargets;
+ _restrictMessageTarget = true;
+ _restrictedTargets = peers;
+
+ closure();
+
+ _restrictMessageTarget = previousRestrictMessageTarget;
+ _restrictedTargets = previousRestrictedTargets;
+}
+
+Peer *SignalProxy::sourcePeer() {
+ return _sourcePeer;
+}
+
+void SignalProxy::setSourcePeer(Peer *sourcePeer) {
+ _sourcePeer = sourcePeer;
+}
+
+Peer *SignalProxy::targetPeer() {
+ return _targetPeer;
+}
+
+void SignalProxy::setTargetPeer(Peer *targetPeer) {
+ _targetPeer = targetPeer;
+}
+
+// ==================================================
+// 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 QT_VERSION >= 0x050000
+ if (_meta->method(i).methodSignature().contains('*'))
+#else
+ if (QByteArray(_meta->method(i).signature()).contains('*'))
+#endif
+ 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<QByteArray> 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<QByteArray> 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!";
+#if QT_VERSION >= 0x050000
+ qWarning() << " - " << _meta->method(i).methodSignature() << "conflicts with" << _meta->method(_methodIds[method]).methodSignature();
+#else
+ qWarning() << " - " << _meta->method(i).signature() << "conflicts with" << _meta->method(_methodIds[method]).signature();
+#endif
+ }
+ 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<int, int> &SignalProxy::ExtendedMetaObject::receiveMap()
+{
+ if (_receiveMap.isEmpty()) {
+ QHash<int, int> 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;
+
+#if QT_VERSION >= 0x050000
+ signature = requestSlot.methodSignature();
+#else
+ signature = QByteArray(requestSlot.signature());
+#endif
+ 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;
+ }
+ }
+ _receiveMap = receiveMap;
+ }
+ return _receiveMap;
+}
+
+
+QByteArray SignalProxy::ExtendedMetaObject::methodName(const QMetaMethod &method)
+{
+#if QT_VERSION >= 0x050000
+ QByteArray sig(method.methodSignature());
+#else
+ QByteArray sig(method.signature());
+#endif
+ return sig.left(sig.indexOf("("));
+}
+
+
+QString SignalProxy::ExtendedMetaObject::methodBaseName(const QMetaMethod &method)
+{
+#if QT_VERSION >= 0x050000
+ QString methodname = QString(method.methodSignature()).section("(", 0, 0);
+#else
+ QString methodname = QString(method.signature()).section("(", 0, 0);
+#endif
+
+ // 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<QByteArray> paramTypes = method.parameterTypes();
+ QList<int> argTypes;
+ for (int i = 0; i < paramTypes.count(); i++) {
+ argTypes.append(QMetaType::type(paramTypes[i]));
+ }
+ _argTypes = argTypes;
+
+ // determine minArgCount
+#if QT_VERSION >= 0x050000
+ QString signature(method.methodSignature());
+#else
+ QString signature(method.signature());
+#endif
+ _minArgCount = method.parameterTypes().count() - signature.count("=");
+
+ _receiverMode = (_methodName.startsWith("request"))
+ ? SignalProxy::Server
+ : SignalProxy::Client;