X-Git-Url: https://git.quassel-irc.org/?p=quassel.git;a=blobdiff_plain;f=src%2Fcommon%2Fsignalproxy.cpp;h=8935538370348d5dbe1661cbfd7de05288cb2721;hp=a2661b5540d6c38e6f30f36a60e16cb8712c6453;hb=e2188dc438be6f3eb0d9cdf47d28821aefe9835e;hpb=694f9bfbf7f1af19108461c7e00d133e55082bce

diff --git a/src/common/signalproxy.cpp b/src/common/signalproxy.cpp
index a2661b55..89355383 100644
--- a/src/common/signalproxy.cpp
+++ b/src/common/signalproxy.cpp
@@ -1,5 +1,5 @@
 /***************************************************************************
- *   Copyright (C) 2005-09 by the Quassel Project                          *
+ *   Copyright (C) 2005-2018 by the Quassel Project                        *
  *   devel@quassel-irc.org                                                 *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
@@ -15,52 +15,36 @@
  *   You should have received a copy of the GNU General Public License     *
  *   along with this program; if not, write to the                         *
  *   Free Software Foundation, Inc.,                                       *
- *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
+ *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.         *
  ***************************************************************************/
 
-#include "signalproxy.h"
+#include <utility>
 
-#include <QObject>
-#include <QIODevice>
-#include <QAbstractSocket>
+#include <QCoreApplication>
 #include <QHostAddress>
-#include <QHash>
-#include <QMultiHash>
-#include <QList>
-#include <QSet>
-#include <QDebug>
 #include <QMetaMethod>
 #include <QMetaProperty>
-#include <QRegExp>
+#include <QThread>
+
 #ifdef HAVE_SSL
-#include <QSslSocket>
+    #include <QSslSocket>
 #endif
-#include <QThread>
-#include <QTime>
-#include <QEvent>
-#include <QCoreApplication>
 
+#include "signalproxy.h"
+
+#include "peer.h"
+#include "protocol.h"
 #include "syncableobject.h"
 #include "util.h"
+#include "types.h"
 
-// ==================================================
-//  PeerSignalEvent
-// ==================================================
-class PeerSignalEvent : public QEvent
-{
-public:
-    PeerSignalEvent(SignalProxy *sender, SignalProxy::RequestType requestType, const QVariantList &params) : QEvent(QEvent::Type(SignalProxy::PeerSignal)), sender(sender), requestType(requestType), params(params) {}
-    SignalProxy *sender;
-    SignalProxy::RequestType requestType;
-    QVariantList params;
-};
-
+using namespace Protocol;
 
 class RemovePeerEvent : public QEvent
 {
 public:
-    RemovePeerEvent(QObject *peer) : QEvent(QEvent::Type(SignalProxy::RemovePeer)), peer(peer) {}
-    QObject *peer;
+    RemovePeerEvent(Peer *peer) : QEvent(QEvent::Type(SignalProxy::RemovePeerEvent)), peer(peer) {}
+    Peer *peer;
 };
 
 
@@ -77,18 +61,18 @@ public:
     SignalRelay(SignalProxy *parent) : QObject(parent), _proxy(parent) {}
     inline SignalProxy *proxy() const { return _proxy; }
 
-    int qt_metacall(QMetaObject::Call _c, int _id, void **_a);
+    int qt_metacall(QMetaObject::Call _c, int _id, void **_a) override;
 
     void attachSignal(QObject *sender, int signalId, const QByteArray &funcName);
     void detachSignal(QObject *sender, int signalId = -1);
 
 private:
     struct Signal {
-        QObject *sender;
-        int signalId;
+        QObject *sender{nullptr};
+        int signalId{-1};
         QByteArray signature;
-        Signal(QObject *sender, int sigId, const QByteArray &signature) : sender(sender), signalId(sigId), signature(signature) {}
-        Signal() : sender(0), signalId(-1) {}
+        Signal(QObject *sender, int sigId, QByteArray signature) : sender(sender), signalId(sigId), signature(std::move(signature)) {}
+        Signal() = default;
     };
 
     SignalProxy *_proxy;
@@ -114,7 +98,7 @@ void SignalProxy::SignalRelay::attachSignal(QObject *sender, int signalId, const
     }
     else {
         fn = SIGNAL(fakeMethodSignature());
-        fn = fn.replace("fakeMethodSignature()", sender->metaObject()->method(signalId).signature());
+        fn = fn.replace("fakeMethodSignature()", sender->metaObject()->method(signalId).methodSignature());
     }
 
     _slots[slotId] = Signal(sender, signalId, fn);
@@ -133,7 +117,7 @@ void SignalProxy::SignalRelay::detachSignal(QObject *sender, int signalId)
                 break;
         }
         else {
-            slotIter++;
+            ++slotIter;
         }
     }
 }
@@ -155,19 +139,24 @@ int SignalProxy::SignalRelay::qt_metacall(QMetaObject::Call _c, int _id, void **
             const Signal &signal = _slots[_id];
 
             QVariantList params;
-            params << signal.signature;
 
             const QList<int> &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() << "SignalRelay::qt_metacall(): received invalid data for argument number" << i << "of signal" << QString("%1::%2").arg(caller->metaObject()->className()).arg(caller->metaObject()->method(signal.signalId).methodSignature().constData());
                     qWarning() << "                            - make sure all your data types are known by the Qt MetaSystem";
                     return _id;
                 }
                 params << QVariant(argTypes[i], _a[i+1]);
             }
 
-            proxy()->dispatchSignal(SignalProxy::RpcCall, params);
+            if (proxy()->_restrictMessageTarget) {
+                for (auto peer : proxy()->_restrictedTargets) {
+                    if (peer != nullptr)
+                        proxy()->dispatch(peer, RpcCall(signal.signature, params));
+                }
+            } else
+                proxy()->dispatch(RpcCall(signal.signature, params));
         }
         _id -= _slots.count();
     }
@@ -176,61 +165,13 @@ int SignalProxy::SignalRelay::qt_metacall(QMetaObject::Call _c, int _id, void **
 
 
 // ==================================================
-//  Peers
+//  SignalProxy
 // ==================================================
-void SignalProxy::IODevicePeer::dispatchSignal(const RequestType &requestType, const QVariantList &params)
-{
-    QVariantList packedFunc;
-    packedFunc << (qint16)requestType
-               << params;
-    dispatchPackedFunc(QVariant(packedFunc));
-}
-
 
-bool SignalProxy::IODevicePeer::isSecure() const
-{
-#ifdef HAVE_SSL
-    QSslSocket *sslSocket = qobject_cast<QSslSocket *>(_device);
-    if (sslSocket)
-        return sslSocket->isEncrypted() || sslSocket->localAddress() == QHostAddress::LocalHost || sslSocket->localAddress() == QHostAddress::LocalHostIPv6;
-#endif
-
-    QAbstractSocket *socket = qobject_cast<QAbstractSocket *>(_device);
-    if (socket)
-        return socket->localAddress() == QHostAddress::LocalHost || socket->localAddress() == QHostAddress::LocalHostIPv6;
-
-    return false;
+namespace {
+thread_local SignalProxy *_current{nullptr};
 }
 
-
-QString SignalProxy::IODevicePeer::address() const
-{
-    QAbstractSocket *socket = qobject_cast<QAbstractSocket *>(_device);
-    if (socket)
-        return socket->peerAddress().toString();
-    else
-        return QString();
-}
-
-
-void SignalProxy::SignalProxyPeer::dispatchSignal(const RequestType &requestType, const QVariantList &params)
-{
-    Qt::ConnectionType type = QThread::currentThread() == receiver->thread()
-                              ? Qt::DirectConnection
-                              : Qt::QueuedConnection;
-
-    if (type == Qt::DirectConnection) {
-        receiver->receivePeerSignal(sender, requestType, params);
-    }
-    else {
-        QCoreApplication::postEvent(receiver, new PeerSignalEvent(sender, requestType, params));
-    }
-}
-
-
-// ==================================================
-//  SignalProxy
-// ==================================================
 SignalProxy::SignalProxy(QObject *parent)
     : QObject(parent)
 {
@@ -247,15 +188,6 @@ SignalProxy::SignalProxy(ProxyMode mode, QObject *parent)
 }
 
 
-SignalProxy::SignalProxy(ProxyMode mode, QIODevice *device, QObject *parent)
-    : QObject(parent)
-{
-    setProxyMode(mode);
-    addPeer(device);
-    init();
-}
-
-
 SignalProxy::~SignalProxy()
 {
     QHash<QByteArray, ObjectId>::iterator classIter = _syncSlave.begin();
@@ -266,30 +198,27 @@ SignalProxy::~SignalProxy()
             objIter = classIter->erase(objIter);
             obj->stopSynchronize(this);
         }
-        classIter++;
+        ++classIter;
     }
     _syncSlave.clear();
 
     removeAllPeers();
+
+    _current = nullptr;
+}
+
+
+SignalProxy *SignalProxy::current()
+{
+    return _current;
 }
 
 
 void SignalProxy::setProxyMode(ProxyMode mode)
 {
-    PeerHash::iterator peer = _peers.begin();
-    while (peer != _peers.end()) {
-        if ((*peer)->type() != AbstractPeer::IODevicePeer) {
-            IODevicePeer *ioPeer = static_cast<IODevicePeer *>(*peer);
-            if (ioPeer->isOpen()) {
-                qWarning() << "SignalProxy: Cannot change proxy mode while connected";
-                return;
-            }
-        }
-        if ((*peer)->type() != AbstractPeer::SignalProxyPeer) {
-            qWarning() << "SignalProxy: Cannot change proxy mode while connected to another internal SignalProxy";
-            return;
-        }
-        peer++;
+    if (!_peerMap.empty()) {
+        qWarning() << Q_FUNC_INFO << "Cannot change proxy mode while connected";
+        return;
     }
 
     _proxyMode = mode;
@@ -299,17 +228,15 @@ void SignalProxy::setProxyMode(ProxyMode mode)
         initClient();
 }
 
-
 void SignalProxy::init()
 {
     _heartBeatInterval = 0;
     _maxHeartBeatCount = 0;
     _signalRelay = new SignalRelay(this);
-    connect(&_heartBeatTimer, SIGNAL(timeout()), this, SLOT(sendHeartBeat()));
     setHeartBeatInterval(30);
     setMaxHeartBeatCount(2);
-    _heartBeatTimer.start();
     _secure = false;
+    _current = this;
     updateSecureState();
 }
 
@@ -321,89 +248,65 @@ void SignalProxy::initServer()
 
 void SignalProxy::initClient()
 {
-    attachSlot("__objectRenamed__", this, SLOT(objectRenamed(QByteArray, QString, QString)));
-}
-
-
-bool SignalProxy::addPeer(QIODevice *iodev)
-{
-    if (!iodev)
-        return false;
-
-    if (_peers.contains(iodev))
-        return true;
-
-    if (proxyMode() == Client && !_peers.isEmpty()) {
-        qWarning("SignalProxy: only one peer allowed in client mode!");
-        return false;
-    }
-
-    if (!iodev->isOpen()) {
-        qWarning("SignalProxy::addPeer(QIODevice *iodev): iodev needs to be open!");
-        return false;
-    }
-
-    connect(iodev, SIGNAL(disconnected()), this, SLOT(removePeerBySender()));
-    connect(iodev, SIGNAL(readyRead()), this, SLOT(dataAvailable()));
-
-#ifdef HAVE_SSL
-    QSslSocket *sslSocket = qobject_cast<QSslSocket *>(iodev);
-    if (sslSocket) {
-        connect(iodev, SIGNAL(encrypted()), this, SLOT(updateSecureState()));
-    }
-#endif
-
-    if (!iodev->parent())
-        iodev->setParent(this);
-
-    _peers[iodev] = new IODevicePeer(iodev, iodev->property("UseCompression").toBool());
-
-    if (_peers.count() == 1)
-        emit connected();
-
-    updateSecureState();
-    return true;
+    attachSlot("__objectRenamed__", this, SLOT(objectRenamed(QByteArray,QString,QString)));
 }
 
 
 void SignalProxy::setHeartBeatInterval(int secs)
 {
-    if (secs != _heartBeatInterval) {
+    if (_heartBeatInterval != secs) {
         _heartBeatInterval = secs;
-        _heartBeatTimer.setInterval(secs * 1000);
+        emit heartBeatIntervalChanged(secs);
     }
 }
 
 
 void SignalProxy::setMaxHeartBeatCount(int max)
 {
-    _maxHeartBeatCount = max;
+    if (_maxHeartBeatCount != max) {
+        _maxHeartBeatCount = max;
+        emit maxHeartBeatCountChanged(max);
+    }
 }
 
 
-bool SignalProxy::addPeer(SignalProxy *proxy)
+bool SignalProxy::addPeer(Peer *peer)
 {
-    if (!proxy)
+    if (!peer)
         return false;
 
-    if (proxyMode() == proxy->proxyMode()) {
-        qWarning() << "SignalProxy::addPeer(): adding a SignalProxy as peer requires one proxy to be server and one client!";
+    if (_peerMap.values().contains(peer))
+        return true;
+
+    if (!peer->isOpen()) {
+        qWarning("SignalProxy: peer needs to be open!");
         return false;
     }
 
-    if (_peers.contains(proxy)) {
-        return true;
+    if (proxyMode() == Client) {
+        if (!_peerMap.isEmpty()) {
+            qWarning("SignalProxy: only one peer allowed in client mode!");
+            return false;
+        }
+        connect(peer, SIGNAL(lagUpdated(int)), SIGNAL(lagUpdated(int)));
     }
 
-    if (proxyMode() == Client && !_peers.isEmpty()) {
-        qWarning("SignalProxy: only one peer allowed in client mode!");
-        return false;
+    connect(peer, SIGNAL(disconnected()), SLOT(removePeerBySender()));
+    connect(peer, SIGNAL(secureStateChanged(bool)), SLOT(updateSecureState()));
+
+    if (!peer->parent())
+        peer->setParent(this);
+
+    if (peer->id() < 0) {
+        peer->setId(nextPeerId());
+        peer->setConnectedSince(QDateTime::currentDateTimeUtc());
     }
 
-    _peers[proxy] = new SignalProxyPeer(this, proxy);
-    proxy->addPeer(this);
+    _peerMap[peer->id()] = peer;
 
-    if (_peers.count() == 1)
+    peer->setSignalProxy(this);
+
+    if (peerCount() == 1)
         emit connected();
 
     updateSecureState();
@@ -413,56 +316,51 @@ bool SignalProxy::addPeer(SignalProxy *proxy)
 
 void SignalProxy::removeAllPeers()
 {
-    Q_ASSERT(proxyMode() == Server || _peers.count() <= 1);
+    Q_ASSERT(proxyMode() == Server || peerCount() <= 1);
     // wee need to copy that list since we modify it in the loop
-    QList<QObject *> peers = _peers.keys();
-    foreach(QObject *peer, peers) {
+    QList<Peer *> peers = _peerMap.values();
+    for (auto peer : peers) {
         removePeer(peer);
     }
 }
 
 
-void SignalProxy::removePeer(QObject *dev)
+void SignalProxy::removePeer(Peer *peer)
 {
-    if (_peers.isEmpty()) {
-        qWarning() << "SignalProxy::removePeer(): No peers in use!";
+    if (!peer) {
+        qWarning() << Q_FUNC_INFO << "Trying to remove a null peer!";
         return;
     }
 
-    Q_ASSERT(dev);
-    if (!_peers.contains(dev)) {
-        qWarning() << "SignalProxy: unknown Peer" << dev;
+    if (_peerMap.isEmpty()) {
+        qWarning() << "SignalProxy::removePeer(): No peers in use!";
         return;
     }
 
-    AbstractPeer *peer = _peers[dev];
-    _peers.remove(dev);
-
-    disconnect(dev, 0, this, 0);
-    if (peer->type() == AbstractPeer::IODevicePeer)
-        emit peerRemoved(static_cast<QIODevice *>(dev));
-
-    if (peer->type() == AbstractPeer::SignalProxyPeer) {
-        SignalProxy *proxy = static_cast<SignalProxy *>(dev);
-        if (proxy->_peers.contains(this))
-            proxy->removePeer(this);
+    if (!_peerMap.values().contains(peer)) {
+        qWarning() << "SignalProxy: unknown Peer" << peer;
+        return;
     }
 
-    if (dev->parent() == this)
-        dev->deleteLater();
+    disconnect(peer, nullptr, this, nullptr);
+    peer->setSignalProxy(nullptr);
+
+    _peerMap.remove(peer->id());
+    emit peerRemoved(peer);
 
-    delete peer;
+    if (peer->parent() == this)
+        peer->deleteLater();
 
     updateSecureState();
 
-    if (_peers.isEmpty())
+    if (_peerMap.isEmpty())
         emit disconnected();
 }
 
 
 void SignalProxy::removePeerBySender()
 {
-    removePeer(sender());
+    removePeer(qobject_cast<Peer *>(sender()));
 }
 
 
@@ -475,9 +373,7 @@ void SignalProxy::renameObject(const SyncableObject *obj, const QString &newname
     const QByteArray className(meta->className());
     objectRenamed(className, newname, oldname);
 
-    QVariantList params;
-    params << "__objectRenamed__" << className << newname << oldname;
-    dispatchSignal(RpcCall, params);
+    dispatch(RpcCall("__objectRenamed__", QVariantList() << className << newname << oldname));
 }
 
 
@@ -492,7 +388,7 @@ void SignalProxy::objectRenamed(const QByteArray &classname, const QString &newn
 
 const QMetaObject *SignalProxy::metaObject(const QObject *obj)
 {
-    if (const SyncableObject *syncObject = qobject_cast<const SyncableObject *>(obj))
+    if (const auto *syncObject = qobject_cast<const SyncableObject *>(obj))
         return syncObject->syncMetaObject();
     else
         return obj->metaObject();
@@ -504,7 +400,7 @@ SignalProxy::ExtendedMetaObject *SignalProxy::extendedMetaObject(const QMetaObje
     if (_extendedMetaObjects.contains(meta))
         return _extendedMetaObjects[meta];
     else
-        return 0;
+        return nullptr;
 }
 
 
@@ -581,8 +477,11 @@ void SignalProxy::synchronize(SyncableObject *obj)
 
 void SignalProxy::detachObject(QObject *obj)
 {
-    detachSignals(obj);
-    detachSlots(obj);
+    // Don't try to connect SignalProxy from itself on shutdown
+    if (obj != this) {
+        detachSignals(obj);
+        detachSlots(obj);
+    }
 }
 
 
@@ -600,7 +499,7 @@ void SignalProxy::detachSlots(QObject *receiver)
             slotIter = _attachedSlots.erase(slotIter);
         }
         else
-            slotIter++;
+            ++slotIter;
     }
 }
 
@@ -615,145 +514,64 @@ void SignalProxy::stopSynchronize(SyncableObject *obj)
             classIter->remove(obj->objectName());
             break;
         }
-        classIter++;
+        ++classIter;
     }
     obj->stopSynchronize(this);
 }
 
 
-void SignalProxy::dispatchSignal(const RequestType &requestType, const QVariantList &params)
+template<class T>
+void SignalProxy::dispatch(const T &protoMessage)
 {
-    QVariant packedFunc(QVariantList() << (qint16)requestType << params);
-    PeerHash::iterator peer = _peers.begin();
-    while (peer != _peers.end()) {
-        switch ((*peer)->type()) {
-        case AbstractPeer::IODevicePeer:
-        {
-            IODevicePeer *ioPeer = static_cast<IODevicePeer *>(*peer);
-            if (ioPeer->isOpen())
-                ioPeer->dispatchPackedFunc(packedFunc);
-            else
-                QCoreApplication::postEvent(this, new RemovePeerEvent(peer.key()));
-        }
-        break;
-        case AbstractPeer::SignalProxyPeer:
-            (*peer)->dispatchSignal(requestType, params);
-            break;
-        default:
-            Q_ASSERT(false); // there shouldn't be any peers with wrong / unknown type
-        }
-        peer++;
+    for (auto&& peer : _peerMap.values()) {
+        dispatch(peer, protoMessage);
     }
 }
 
 
-void SignalProxy::receivePackedFunc(AbstractPeer *sender, const QVariant &packedFunc)
+template<class T>
+void SignalProxy::dispatch(Peer *peer, const T &protoMessage)
 {
-    QVariantList params(packedFunc.toList());
-
-    if (params.isEmpty()) {
-        qWarning() << "SignalProxy::receivePeerSignal(): received incompatible Data:" << packedFunc;
-        return;
-    }
-
-    RequestType requestType = (RequestType)params.takeFirst().value<int>();
-    receivePeerSignal(sender, requestType, params);
-}
-
-
-void SignalProxy::receivePeerSignal(AbstractPeer *sender, const RequestType &requestType, const QVariantList &params)
-{
-    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<IODevicePeer *>(sender);
-            ioPeer->sentHeartBeats = 0;
-        }
-    }
-
-    // qDebug() << "SignalProxy::receivePeerSignal)" << requestType << params;
-    switch (requestType) {
-    case RpcCall:
-        if (params.empty())
-            qWarning() << "SignalProxy::receivePeerSignal(): received empty RPC-Call";
-        else
-            handleSignal(params);
-        //handleSignal(params.takeFirst().toByteArray(), params);
-        break;
-
-    case Sync:
-        handleSync(sender, params);
-        break;
-
-    case InitRequest:
-        handleInitRequest(sender, params);
-        break;
-
-    case InitData:
-        handleInitData(sender, params);
-        break;
-
-    case HeartBeat:
-        receiveHeartBeat(sender, params);
-        break;
+    _targetPeer = peer;
 
-    case HeartBeatReply:
-        receiveHeartBeatReply(sender, params);
-        break;
+    if (peer && peer->isOpen())
+        peer->dispatch(protoMessage);
+    else
+        QCoreApplication::postEvent(this, new ::RemovePeerEvent(peer));
 
-    default:
-        qWarning() << "SignalProxy::receivePeerSignal(): received undefined CallType" << requestType << params;
-    }
+    _targetPeer = nullptr;
 }
 
 
-void SignalProxy::receivePeerSignal(SignalProxy *sender, const RequestType &requestType, const QVariantList &params)
+void SignalProxy::handle(Peer *peer, const SyncMessage &syncMessage)
 {
-    if (!_peers.contains(sender)) {
-        // we output only the pointer value. otherwise Qt would try to pretty print. As the object might already been destroyed, this is not a good idea.
-        qWarning() << "SignalProxy::receivePeerSignal(): received Signal from unknown Proxy" << reinterpret_cast<void *>(sender);
+    if (!_syncSlave.contains(syncMessage.className) || !_syncSlave[syncMessage.className].contains(syncMessage.objectName)) {
+        qWarning() << QString("no registered receiver for sync call: %1::%2 (objectName=\"%3\"). Params are:").arg(syncMessage.className, syncMessage.slotName, syncMessage.objectName)
+                   << syncMessage.params;
         return;
     }
-    receivePeerSignal(_peers[sender], requestType, params);
-}
-
 
-void SignalProxy::handleSync(AbstractPeer *sender, QVariantList params)
-{
-    if (params.count() < 3) {
-        qWarning() << "received invalid Sync call" << params;
-        return;
-    }
-
-    QByteArray className = params.takeFirst().toByteArray();
-    QString objectName = params.takeFirst().toString();
-    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(slot)).arg(objectName)
-                   << params;
-        return;
-    }
-
-    SyncableObject *receiver = _syncSlave[className][objectName];
+    SyncableObject *receiver = _syncSlave[syncMessage.className][syncMessage.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;
+    if (!eMeta->slotMap().contains(syncMessage.slotName)) {
+        qWarning() << QString("no matching slot for sync call: %1::%2 (objectName=\"%3\"). Params are:").arg(syncMessage.className, syncMessage.slotName, syncMessage.objectName)
+                   << syncMessage.params;
         return;
     }
 
-    int slotId = eMeta->slotMap()[slot];
+    int slotId = eMeta->slotMap()[syncMessage.slotName];
     if (proxyMode() != eMeta->receiverMode(slotId)) {
         qWarning("SignalProxy::handleSync(): invokeMethod for \"%s\" failed. Wrong ProxyMode!", eMeta->methodName(slotId).constData());
         return;
     }
 
-    QVariant returnValue((QVariant::Type)eMeta->returnType(slotId));
-    if (!invokeSlot(receiver, slotId, params, returnValue)) {
+    // We can no longer construct a QVariant from QMetaType::Void
+    QVariant returnValue;
+    int returnType = eMeta->returnType(slotId);
+    if (returnType != QMetaType::Void)
+        returnValue = QVariant(static_cast<QVariant::Type>(returnType));
+
+    if (!invokeSlot(receiver, slotId, syncMessage.params, returnValue, peer)) {
         qWarning("SignalProxy::handleSync(): invokeMethod for \"%s\" failed ", eMeta->methodName(slotId).constData());
         return;
     }
@@ -761,14 +579,12 @@ void SignalProxy::handleSync(AbstractPeer *sender, QVariantList params)
     if (returnValue.type() != QVariant::Invalid && eMeta->receiveMap().contains(slotId)) {
         int receiverId = eMeta->receiveMap()[slotId];
         QVariantList returnParams;
-        returnParams << className
-                     << objectName
-                     << eMeta->methodName(receiverId);
-        //QByteArray(receiver->metaObject()->method(receiverId).signature());
         if (eMeta->argTypes(receiverId).count() > 1)
-            returnParams << params;
+            returnParams << syncMessage.params;
         returnParams << returnValue;
-        sender->dispatchSignal(Sync, returnParams);
+        _targetPeer = peer;
+        peer->dispatch(SyncMessage(syncMessage.className, syncMessage.objectName, eMeta->methodName(receiverId), returnParams));
+        _targetPeer = nullptr;
     }
 
     // send emit update signal
@@ -776,92 +592,66 @@ void SignalProxy::handleSync(AbstractPeer *sender, QVariantList params)
 }
 
 
-void SignalProxy::handleInitRequest(AbstractPeer *sender, const QVariantList &params)
+void SignalProxy::handle(Peer *peer, const InitRequest &initRequest)
 {
-    if (params.count() != 2) {
-        qWarning() << "SignalProxy::handleInitRequest() received initRequest with invalid param Count:"
-                   << params;
-        return;
-    }
-
-    QByteArray className(params[0].toByteArray());
-    QString objectName(params[1].toString());
-
-    if (!_syncSlave.contains(className)) {
+   if (!_syncSlave.contains(initRequest.className)) {
         qWarning() << "SignalProxy::handleInitRequest() received initRequest for unregistered Class:"
-                   << className;
+                   << initRequest.className;
         return;
     }
 
-    if (!_syncSlave[className].contains(objectName)) {
+    if (!_syncSlave[initRequest.className].contains(initRequest.objectName)) {
         qWarning() << "SignalProxy::handleInitRequest() received initRequest for unregistered Object:"
-                   << className << objectName;
+                   << initRequest.className << initRequest.objectName;
         return;
     }
 
-    SyncableObject *obj = _syncSlave[className][objectName];
-
-    QVariantList params_;
-    params_ << className
-            << objectName
-            << initData(obj);
-
-    sender->dispatchSignal(InitData, params_);
+    SyncableObject *obj = _syncSlave[initRequest.className][initRequest.objectName];
+    _targetPeer = peer;
+    peer->dispatch(InitData(initRequest.className, initRequest.objectName, initData(obj)));
+    _targetPeer = nullptr;
 }
 
 
-void SignalProxy::handleInitData(AbstractPeer *sender, const QVariantList &params)
+void SignalProxy::handle(Peer *peer, const InitData &initData)
 {
-    Q_UNUSED(sender)
-    if (params.count() != 3) {
-        qWarning() << "SignalProxy::handleInitData() received initData with invalid param Count:"
-                   << params;
-        return;
-    }
+    Q_UNUSED(peer)
 
-    QByteArray className(params[0].toByteArray());
-    QString objectName(params[1].toString());
-    QVariantMap propertyMap(params[2].toMap());
-
-    if (!_syncSlave.contains(className)) {
+    if (!_syncSlave.contains(initData.className)) {
         qWarning() << "SignalProxy::handleInitData() received initData for unregistered Class:"
-                   << className;
+                   << initData.className;
         return;
     }
 
-    if (!_syncSlave[className].contains(objectName)) {
+    if (!_syncSlave[initData.className].contains(initData.objectName)) {
         qWarning() << "SignalProxy::handleInitData() received initData for unregistered Object:"
-                   << className << objectName;
+                   << initData.className << initData.objectName;
         return;
     }
 
-    SyncableObject *obj = _syncSlave[className][objectName];
-    setInitData(obj, propertyMap);
+    SyncableObject *obj = _syncSlave[initData.className][initData.objectName];
+    setInitData(obj, initData.initData);
 }
 
 
-//void SignalProxy::handleSignal(const QByteArray &funcName, const QVariantList &params) {
-void SignalProxy::handleSignal(const QVariantList &data)
+void SignalProxy::handle(Peer *peer, const RpcCall &rpcCall)
 {
-    QVariantList params = data;
-    QByteArray funcName = params.takeFirst().toByteArray();
-
     QObject *receiver;
     int methodId;
-    SlotHash::const_iterator slot = _attachedSlots.constFind(funcName);
-    while (slot != _attachedSlots.constEnd() && slot.key() == funcName) {
+    SlotHash::const_iterator slot = _attachedSlots.constFind(rpcCall.slotName);
+    while (slot != _attachedSlots.constEnd() && slot.key() == rpcCall.slotName) {
         receiver = (*slot).first;
         methodId = (*slot).second;
-        if (!invokeSlot(receiver, methodId, params)) {
+        if (!invokeSlot(receiver, methodId, rpcCall.params, peer)) {
             ExtendedMetaObject *eMeta = extendedMetaObject(receiver);
             qWarning("SignalProxy::handleSignal(): invokeMethod for \"%s\" failed ", eMeta->methodName(methodId).constData());
         }
-        slot++;
+        ++slot;
     }
 }
 
 
-bool SignalProxy::invokeSlot(QObject *receiver, int methodId, const QVariantList &params, QVariant &returnValue)
+bool SignalProxy::invokeSlot(QObject *receiver, int methodId, const QVariantList &params, QVariant &returnValue, Peer *peer)
 {
     ExtendedMetaObject *eMeta = extendedMetaObject(receiver);
     const QList<int> args = eMeta->argTypes(methodId);
@@ -874,14 +664,14 @@ bool SignalProxy::invokeSlot(QObject *receiver, int methodId, const QVariantList
         return false;
     }
 
-    void *_a[] = { 0,           // return type...
-                   0, 0, 0, 0, 0, // and 10 args - that's the max size qt can handle with signals and slots
-                   0, 0, 0, 0, 0 };
+    void *_a[] = { nullptr,           // return type...
+                   nullptr, nullptr, nullptr, nullptr, nullptr, // and 10 args - that's the max size qt can handle with signals and slots
+                   nullptr, nullptr, nullptr, nullptr, nullptr };
 
     // check for argument compatibility and build params array
     for (int i = 0; i < numArgs; i++) {
         if (!params[i].isValid()) {
-            qWarning() << "SignalProxy::invokeSlot(): received invalid data for argument number" << i << "of method" << QString("%1::%2()").arg(receiver->metaObject()->className()).arg(receiver->metaObject()->method(methodId).signature());
+            qWarning() << "SignalProxy::invokeSlot(): received invalid data for argument number" << i << "of method" << QString("%1::%2()").arg(receiver->metaObject()->className()).arg(receiver->metaObject()->method(methodId).methodSignature().constData());
             qWarning() << "                            - make sure all your data types are known by the Qt MetaSystem";
             return false;
         }
@@ -889,6 +679,7 @@ bool SignalProxy::invokeSlot(QObject *receiver, int methodId, const QVariantList
             qWarning() << "SignalProxy::invokeSlot(): incompatible param types to invoke" << eMeta->methodName(methodId);
             return false;
         }
+
         _a[i+1] = const_cast<void *>(params[i].constData());
     }
 
@@ -900,9 +691,11 @@ bool SignalProxy::invokeSlot(QObject *receiver, int methodId, const QVariantList
                               : Qt::QueuedConnection;
 
     if (type == Qt::DirectConnection) {
-        return receiver->qt_metacall(QMetaObject::InvokeMetaMethod, methodId, _a) < 0;
-    }
-    else {
+        _sourcePeer = peer;
+        auto result = receiver->qt_metacall(QMetaObject::InvokeMetaMethod, methodId, _a) < 0;
+        _sourcePeer = nullptr;
+        return result;
+    } else {
         qWarning() << "Queued Connections are not implemented yet";
         // note to self: qmetaobject.cpp:990 ff
         return false;
@@ -910,117 +703,10 @@ bool SignalProxy::invokeSlot(QObject *receiver, int methodId, const QVariantList
 }
 
 
-bool SignalProxy::invokeSlot(QObject *receiver, int methodId, const QVariantList &params)
+bool SignalProxy::invokeSlot(QObject *receiver, int methodId, const QVariantList &params, Peer *peer)
 {
     QVariant ret;
-    return invokeSlot(receiver, methodId, params, ret);
-}
-
-
-void SignalProxy::dataAvailable()
-{
-    // yet again. it's a private slot. no need for checks.
-    QIODevice *ioDev = qobject_cast<QIODevice *>(sender());
-    Q_ASSERT(_peers.contains(ioDev) && _peers[ioDev]->type() == AbstractPeer::IODevicePeer);
-    IODevicePeer *peer = static_cast<IODevicePeer *>(_peers[ioDev]);
-    QVariant var;
-    while (peer->readData(var))
-        receivePackedFunc(peer, var);
-}
-
-
-void SignalProxy::writeDataToDevice(QIODevice *dev, const QVariant &item, bool compressed)
-{
-    QAbstractSocket *sock  = qobject_cast<QAbstractSocket *>(dev);
-    if (!dev->isOpen() || (sock && sock->state() != QAbstractSocket::ConnectedState)) {
-        qWarning("SignalProxy: Can't call write on a closed device");
-        return;
-    }
-
-    QByteArray block;
-    QDataStream out(&block, QIODevice::WriteOnly);
-    out.setVersion(QDataStream::Qt_4_2);
-    out << (quint32)0;
-
-    if (compressed) {
-        QByteArray rawItem;
-        QDataStream itemStream(&rawItem, QIODevice::WriteOnly);
-
-        itemStream.setVersion(QDataStream::Qt_4_2);
-        itemStream << item;
-
-        rawItem = qCompress(rawItem);
-
-        out << rawItem;
-    }
-    else {
-        out << item;
-    }
-
-    out.device()->seek(0);
-    out << (quint32)(block.size() - sizeof(quint32));
-
-    dev->write(block);
-}
-
-
-bool SignalProxy::readDataFromDevice(QIODevice *dev, quint32 &blockSize, QVariant &item, bool compressed)
-{
-    if (!dev)
-        return false;
-
-    QDataStream in(dev);
-    in.setVersion(QDataStream::Qt_4_2);
-
-    if (blockSize == 0) {
-        if (dev->bytesAvailable() < (int)sizeof(quint32)) return false;
-        in >> blockSize;
-    }
-
-    if (blockSize > 1 << 22) {
-        disconnectDevice(dev, tr("Peer tried to send package larger than max package size!"));
-        return false;
-    }
-
-    if (blockSize == 0) {
-        disconnectDevice(dev, tr("Peer tried to send 0 byte package!"));
-        return false;
-    }
-
-    if (dev->bytesAvailable() < blockSize)
-        return false;
-
-    blockSize = 0;
-
-    if (compressed) {
-        QByteArray rawItem;
-        in >> rawItem;
-
-        int nbytes = rawItem.size();
-        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("Peer sent corrupted compressed data!"));
-                return false;
-            }
-        }
-
-        rawItem = qUncompress(rawItem);
-
-        QDataStream itemStream(&rawItem, QIODevice::ReadOnly);
-        itemStream.setVersion(QDataStream::Qt_4_2);
-        itemStream >> item;
-    }
-    else {
-        in >> item;
-    }
-
-    if (!item.isValid()) {
-        disconnectDevice(dev, tr("Peer sent corrupt data: unable to load QVariant!"));
-        return false;
-    }
-
-    return true;
+    return invokeSlot(receiver, methodId, params, ret, peer);
 }
 
 
@@ -1029,10 +715,7 @@ void SignalProxy::requestInit(SyncableObject *obj)
     if (proxyMode() == Server || obj->isInitialized())
         return;
 
-    QVariantList params;
-    params << obj->syncMetaObject()->className()
-           << obj->objectName();
-    dispatchSignal(InitRequest, params);
+    dispatch(InitRequest(obj->syncMetaObject()->className(), obj->objectName()));
 }
 
 
@@ -1053,79 +736,18 @@ void SignalProxy::setInitData(SyncableObject *obj, const QVariantMap &properties
 }
 
 
-void SignalProxy::sendHeartBeat()
-{
-    QVariantList heartBeatParams;
-    heartBeatParams << QTime::currentTime();
-    QList<IODevicePeer *> toClose;
-
-    PeerHash::iterator peer = _peers.begin();
-    while (peer != _peers.end()) {
-        if ((*peer)->type() == AbstractPeer::IODevicePeer) {
-            IODevicePeer *ioPeer = static_cast<IODevicePeer *>(*peer);
-            ioPeer->dispatchSignal(SignalProxy::HeartBeat, heartBeatParams);
-            if (ioPeer->sentHeartBeats > 0) {
-                updateLag(ioPeer, ioPeer->sentHeartBeats * _heartBeatTimer.interval());
-            }
-            if (maxHeartBeatCount() >= 0 && ioPeer->sentHeartBeats >= maxHeartBeatCount())
-                toClose.append(ioPeer);
-            else
-                ioPeer->sentHeartBeats++;
-        }
-        ++peer;
-    }
-
-    foreach(IODevicePeer *ioPeer, toClose) {
-        qWarning() << "SignalProxy: Disconnecting peer:" << ioPeer->address()
-                   << "(didn't receive a heartbeat for over" << ioPeer->sentHeartBeats *_heartBeatTimer.interval() / 1000 << "seconds)";
-        ioPeer->close();
-    }
-}
-
-
-void SignalProxy::receiveHeartBeat(AbstractPeer *peer, const QVariantList &params)
-{
-    peer->dispatchSignal(SignalProxy::HeartBeatReply, params);
-}
-
-
-void SignalProxy::receiveHeartBeatReply(AbstractPeer *peer, const QVariantList &params)
-{
-    if (peer->type() != AbstractPeer::IODevicePeer) {
-        qWarning() << "SignalProxy::receiveHeartBeatReply: received heart beat from a non IODevicePeer!";
-        return;
-    }
-
-    IODevicePeer *ioPeer = static_cast<IODevicePeer *>(peer);
-    ioPeer->sentHeartBeats = 0;
-
-    if (params.isEmpty()) {
-        qWarning() << "SignalProxy: received heart beat reply with less params then sent from:" << ioPeer->address();
-        return;
-    }
-
-    QTime sendTime = params[0].value<QTime>();
-    updateLag(ioPeer, sendTime.msecsTo(QTime::currentTime()) / 2);
-}
-
-
 void SignalProxy::customEvent(QEvent *event)
 {
-    switch (+event->type()) {
-    case PeerSignal:
-    {
-        PeerSignalEvent *e = static_cast<PeerSignalEvent *>(event);
-        receivePeerSignal(e->sender, e->requestType, e->params);
-    }
+    switch ((int)event->type()) {
+    case RemovePeerEvent: {
+        auto *e = static_cast< ::RemovePeerEvent *>(event);
+        removePeer(e->peer);
         event->accept();
         break;
-    case RemovePeer:
-    {
-        RemovePeerEvent *e = static_cast<RemovePeerEvent *>(event);
-        removePeer(e->peer);
     }
-        event->accept();
+
     default:
+        qWarning() << Q_FUNC_INFO << "Received unknown custom event:" << event->type();
         return;
     }
 }
@@ -1140,9 +762,6 @@ void SignalProxy::sync_call__(const SyncableObject *obj, SignalProxy::ProxyMode
     ExtendedMetaObject *eMeta = extendedMetaObject(obj);
 
     QVariantList params;
-    params << eMeta->metaObject()->className()
-           << obj->objectName()
-           << QByteArray(funcname);
 
     const QList<int> &argTypes = eMeta->argTypes(eMeta->methodId(QByteArray(funcname)));
 
@@ -1155,7 +774,13 @@ void SignalProxy::sync_call__(const SyncableObject *obj, SignalProxy::ProxyMode
         params << QVariant(argTypes[i], va_arg(ap, void *));
     }
 
-    dispatchSignal(Sync, params);
+    if (_restrictMessageTarget) {
+        for (auto peer : _restrictedTargets) {
+            if (peer != nullptr)
+                dispatch(peer, SyncMessage(eMeta->metaObject()->className(), obj->objectName(), QByteArray(funcname), params));
+        }
+    } else
+        dispatch(SyncMessage(eMeta->metaObject()->className(), obj->objectName(), QByteArray(funcname), params));
 }
 
 
@@ -1163,22 +788,13 @@ void SignalProxy::disconnectDevice(QIODevice *dev, const QString &reason)
 {
     if (!reason.isEmpty())
         qWarning() << qPrintable(reason);
-    QAbstractSocket *sock  = qobject_cast<QAbstractSocket *>(dev);
+    auto *sock  = qobject_cast<QAbstractSocket *>(dev);
     if (sock)
         qWarning() << qPrintable(tr("Disconnecting")) << qPrintable(sock->peerAddress().toString());
     dev->close();
 }
 
 
-void SignalProxy::updateLag(IODevicePeer *peer, int lag)
-{
-    peer->lag = lag;
-    if (proxyMode() == Client) {
-        emit lagUpdated(lag);
-    }
-}
-
-
 void SignalProxy::dumpProxyStats()
 {
     QString mode;
@@ -1203,16 +819,69 @@ void SignalProxy::updateSecureState()
 {
     bool wasSecure = _secure;
 
-    _secure = !_peers.isEmpty();
-    PeerHash::const_iterator peerIter;
-    for (peerIter = _peers.constBegin(); peerIter != _peers.constEnd(); peerIter++) {
-        _secure &= (*peerIter)->isSecure();
+    _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) {
+    // We use ::value() here instead of the [] operator because the latter has the side-effect
+    // of automatically inserting a null value with the passed key into the map.  See
+    // https://doc.qt.io/qt-5/qhash.html#operator-5b-5d and https://doc.qt.io/qt-5/qhash.html#value.
+    return _peerMap.value(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
@@ -1225,7 +894,7 @@ SignalProxy::ExtendedMetaObject::ExtendedMetaObject(const QMetaObject *meta, boo
         if (_meta->method(i).methodType() != QMetaMethod::Slot)
             continue;
 
-        if (QByteArray(_meta->method(i).signature()).contains('*'))
+        if (_meta->method(i).methodSignature().contains('*'))
             continue;  // skip methods with ptr params
 
         QByteArray method = methodName(_meta->method(i));
@@ -1254,7 +923,7 @@ SignalProxy::ExtendedMetaObject::ExtendedMetaObject(const QMetaObject *meta, boo
             }
             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();
+                qWarning() << " - " << _meta->method(i).methodSignature() << "conflicts with" << _meta->method(_methodIds[method]).methodSignature();
             }
             continue;
         }
@@ -1294,7 +963,7 @@ const QHash<int, int> &SignalProxy::ExtendedMetaObject::receiveMap()
             if (QMetaType::Void == (QMetaType::Type)returnType(i))
                 continue;
 
-            signature = QByteArray(requestSlot.signature());
+            signature = requestSlot.methodSignature();
             if (!signature.startsWith("request"))
                 continue;
 
@@ -1328,14 +997,14 @@ const QHash<int, int> &SignalProxy::ExtendedMetaObject::receiveMap()
 
 QByteArray SignalProxy::ExtendedMetaObject::methodName(const QMetaMethod &method)
 {
-    QByteArray sig(method.signature());
+    QByteArray sig(method.methodSignature());
     return sig.left(sig.indexOf("("));
 }
 
 
 QString SignalProxy::ExtendedMetaObject::methodBaseName(const QMetaMethod &method)
 {
-    QString methodname = QString(method.signature()).section("(", 0, 0);
+    QString methodname = QString(method.methodSignature()).section("(", 0, 0);
 
     // determine where we have to chop:
     int upperCharPos;
@@ -1373,7 +1042,7 @@ SignalProxy::ExtendedMetaObject::MethodDescriptor::MethodDescriptor(const QMetaM
     _argTypes = argTypes;
 
     // determine minArgCount
-    QString signature(method.signature());
+    QString signature(method.methodSignature());
     _minArgCount = method.parameterTypes().count() - signature.count("=");
 
     _receiverMode = (_methodName.startsWith("request"))