#ifndef SIGNALPROXY_H
#define SIGNALPROXY_H
+#include <QEvent>
#include <QList>
#include <QHash>
#include <QVariant>
HeartBeatReply
};
+ enum ClientConnectionType {
+ SignalProxyConnection,
+ IODeviceConnection
+ };
+
+ enum CustomEvents {
+ PeerSignal = QEvent::User,
+ RemovePeer
+ };
+
SignalProxy(QObject *parent);
SignalProxy(ProxyMode mode, QObject *parent);
SignalProxy(ProxyMode mode, QIODevice *device, QObject *parent);
*/
static bool readDataFromDevice(QIODevice *dev, quint32 &blockSize, QVariant &item, bool compressed = false);
+ bool isSecure() const { return _secure; }
+
static QString methodBaseName(const QMetaMethod &method);
const QList<int> &argTypes(QObject *obj, int methodId);
void sendHeartBeat();
void receiveHeartBeat(AbstractPeer *peer, const QVariantList ¶ms);
void receiveHeartBeatReply(AbstractPeer *peer, const QVariantList ¶ms);
-
+
+ void updateSecureState();
+
signals:
void peerRemoved(QIODevice *dev);
void connected();
void disconnected();
void objectInitialized(SyncableObject *);
void lagUpdated(int lag);
-
+ void securityChanged(bool);
+ void secureStateChanged(bool);
+
private:
void init();
void initServer();
inline int peerCount() const { return _peers.size(); }
private:
+ static void disconnectDevice(QIODevice *dev, const QString &reason = QString());
+
class AbstractPeer {
public:
enum PeerType {
virtual ~AbstractPeer() {}
inline PeerType type() const { return _type; }
virtual void dispatchSignal(const RequestType &requestType, const QVariantList ¶ms) = 0;
+ virtual bool isSecure() const = 0;
private:
PeerType _type;
};
public:
IODevicePeer(QIODevice *device, bool compress) : AbstractPeer(AbstractPeer::IODevicePeer), _device(device), byteCount(0), usesCompression(compress), sentHeartBeats(0), lag(0) {}
virtual void dispatchSignal(const RequestType &requestType, const QVariantList ¶ms);
+ virtual bool isSecure() const;
inline void dispatchPackedFunc(const QVariant &packedFunc) { SignalProxy::writeDataToDevice(_device, packedFunc, usesCompression); }
- inline QIODevice *device() const { return _device; }
+ QString address() const;
inline bool isOpen() const { return _device->isOpen(); }
+ inline void close() const { _device->close(); }
inline bool readData(QVariant &item) { return SignalProxy::readDataFromDevice(_device, byteCount, item, usesCompression); }
private:
QIODevice *_device;
public:
SignalProxyPeer(SignalProxy *sender, SignalProxy *receiver) : AbstractPeer(AbstractPeer::SignalProxyPeer), sender(sender), receiver(receiver) {}
virtual void dispatchSignal(const RequestType &requestType, const QVariantList ¶ms);
+ virtual inline bool isSecure() const { return true; }
private:
SignalProxy *sender;
SignalProxy *receiver;
// currently a communication object can either be an arbitrary QIODevice or another SignalProxy
typedef QHash<QObject *, AbstractPeer *> PeerHash;
PeerHash _peers;
-
-// // Hash of used QIODevices
-// struct peerInfo {
-// quint32 byteCount;
-// bool usesCompression;
-// int sentHeartBeats;
-// int lag;
-// peerInfo() : byteCount(0), usesCompression(false), sentHeartBeats(0) {}
-// };
-// QHash<QIODevice*, peerInfo> _peers;
// containg a list of argtypes for fast access
QHash<const QMetaObject *, ClassInfo*> _classInfo;
ProxyMode _proxyMode;
QTimer _heartBeatTimer;
+
+ bool _secure; // determines if all connections are in a secured state (using ssl or internal connections)
friend class SignalRelay;
};