/***************************************************************************
- * Copyright (C) 2005-2015 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 *
}
else {
fn = SIGNAL(fakeMethodSignature());
-#if QT_VERSION >= 0x050000
fn = fn.replace("fakeMethodSignature()", sender->metaObject()->method(signalId).methodSignature());
-#else
- fn = fn.replace("fakeMethodSignature()", sender->metaObject()->method(signalId).signature());
-#endif
}
_slots[slotId] = Signal(sender, signalId, fn);
const QList<int> &argTypes = eMeta->argTypes(signal.signalId);
for (int i = 0; i < argTypes.size(); i++) {
if (argTypes[i] == 0) {
-#if QT_VERSION >= 0x050000
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());
-#else
- 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).signature());
-#endif
qWarning() << " - make sure all your data types are known by the Qt MetaSystem";
return _id;
}
params << QVariant(argTypes[i], _a[i+1]);
}
- if (argTypes.size() >= 1 && argTypes[0] == qMetaTypeId<PeerPtr>() && proxy()->proxyMode() == SignalProxy::Server) {
- Peer *peer = params[0].value<PeerPtr>();
- proxy()->dispatch(peer, RpcCall(signal.signature, 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));
}
// ==================================================
// SignalProxy
// ==================================================
+
+thread_local SignalProxy *SignalProxy::_current{nullptr};
+
SignalProxy::SignalProxy(QObject *parent)
: QObject(parent)
{
_syncSlave.clear();
removeAllPeers();
+
+ _current = nullptr;
}
void SignalProxy::setProxyMode(ProxyMode mode)
{
- if (_peers.count()) {
+ if (!_peerMap.empty()) {
qWarning() << Q_FUNC_INFO << "Cannot change proxy mode while connected";
return;
}
initClient();
}
-
void SignalProxy::init()
{
_heartBeatInterval = 0;
setHeartBeatInterval(30);
setMaxHeartBeatCount(2);
_secure = false;
+ _current = this;
updateSecureState();
}
if (!peer)
return false;
- if (_peers.contains(peer))
+ if (_peerMap.values().contains(peer))
return true;
if (!peer->isOpen()) {
}
if (proxyMode() == Client) {
- if (!_peers.isEmpty()) {
+ if (!_peerMap.isEmpty()) {
qWarning("SignalProxy: only one peer allowed in client mode!");
return false;
}
if (!peer->parent())
peer->setParent(this);
- _peers.insert(peer);
+ if (peer->id() < 0) {
+ peer->setId(nextPeerId());
+ peer->setConnectedSince(QDateTime::currentDateTimeUtc());
+ }
+
+ _peerMap[peer->id()] = peer;
peer->setSignalProxy(this);
- if (_peers.count() == 1)
+ if (peerCount() == 1)
emit connected();
updateSecureState();
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
- QSet<Peer *> peers = _peers;
- foreach(Peer *peer, peers) {
+ QList<Peer *> peers = _peerMap.values();
+ for (auto peer : peers) {
removePeer(peer);
}
}
return;
}
- if (_peers.isEmpty()) {
+ if (_peerMap.isEmpty()) {
qWarning() << "SignalProxy::removePeer(): No peers in use!";
return;
}
- if (!_peers.contains(peer)) {
+ if (!_peerMap.values().contains(peer)) {
qWarning() << "SignalProxy: unknown Peer" << peer;
return;
}
disconnect(peer, 0, this, 0);
peer->setSignalProxy(0);
- _peers.remove(peer);
+ _peerMap.remove(peer->id());
emit peerRemoved(peer);
if (peer->parent() == this)
updateSecureState();
- if (_peers.isEmpty())
+ if (_peerMap.isEmpty())
emit disconnected();
}
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);
+ }
}
template<class T>
void SignalProxy::dispatch(const T &protoMessage)
{
- foreach (Peer *peer, _peers) {
- if (peer->isOpen())
- peer->dispatch(protoMessage);
- else
- QCoreApplication::postEvent(this, new ::RemovePeerEvent(peer));
+ for (auto&& peer : _peerMap.values()) {
+ dispatch(peer, protoMessage);
}
}
template<class T>
void SignalProxy::dispatch(Peer *peer, const T &protoMessage)
{
+ _targetPeer = peer;
+
if (peer && peer->isOpen())
peer->dispatch(protoMessage);
else
QCoreApplication::postEvent(this, new ::RemovePeerEvent(peer));
+
+ _targetPeer = nullptr;
}
if (eMeta->argTypes(receiverId).count() > 1)
returnParams << syncMessage.params;
returnParams << returnValue;
+ _targetPeer = peer;
peer->dispatch(SyncMessage(syncMessage.className, syncMessage.objectName, eMeta->methodName(receiverId), returnParams));
+ _targetPeer = nullptr;
}
// send emit update signal
}
SyncableObject *obj = _syncSlave[initRequest.className][initRequest.objectName];
+ _targetPeer = peer;
peer->dispatch(InitData(initRequest.className, initRequest.objectName, initData(obj)));
+ _targetPeer = nullptr;
}
// check for argument compatibility and build params array
for (int i = 0; i < numArgs; i++) {
if (!params[i].isValid()) {
-#if QT_VERSION >= 0x050000
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());
-#else
- 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());
-#endif
qWarning() << " - make sure all your data types are known by the Qt MetaSystem";
return false;
}
qWarning() << "SignalProxy::invokeSlot(): incompatible param types to invoke" << eMeta->methodName(methodId);
return false;
}
- // if first arg is a PeerPtr, replace it by the address of the peer originally receiving the RpcCall
- if (peer && i == 0 && args[0] == qMetaTypeId<PeerPtr>()) {
- QVariant v = QVariant::fromValue<PeerPtr>(peer);
- _a[1] = const_cast<void*>(v.constData());
- } else
- _a[i+1] = const_cast<void *>(params[i].constData());
+
+ _a[i+1] = const_cast<void *>(params[i].constData());
}
if (returnValue.type() != QVariant::Invalid)
: 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;
params << QVariant(argTypes[i], va_arg(ap, void *));
}
- if (argTypes.size() >= 1 && argTypes[0] == qMetaTypeId<PeerPtr>() && proxyMode() == SignalProxy::Server) {
- Peer *peer = params[0].value<PeerPtr>();
- dispatch(peer, SyncMessage(eMeta->metaObject()->className(), obj->objectName(), QByteArray(funcname), 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));
}
{
bool wasSecure = _secure;
- _secure = !_peers.isEmpty();
- foreach (const Peer *peer, _peers) {
+ _secure = !_peerMap.isEmpty();
+ for (auto peer : _peerMap.values()) {
_secure &= peer->isSecure();
}
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
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 (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;
}
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;
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;
_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"))
projects / quassel.git / blobdiff