added SignalProxy::isSecure() to determine if all connections are secure (ssl encrypt...

[quassel.git] / src / common / signalproxy.h

diff --git a/src/common/signalproxy.h b/src/common/signalproxy.h
index f2490ba..129a6a2 100644 (file)
--- a/src/common/signalproxy.h
+++ b/src/common/signalproxy.h
@@ -21,6 +21,7 @@
 #ifndef SIGNALPROXY_H
 #define SIGNALPROXY_H
 
+#include <QEvent>
 #include <QList>
 #include <QHash>
 #include <QVariant>
@@ -55,6 +56,16 @@ public:
     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);
@@ -95,6 +106,8 @@ public:
    */
   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);
@@ -119,6 +132,9 @@ public:
 
   void dumpProxyStats();
   
+protected:
+  void customEvent(QEvent *event);
+
 private slots:
   void dataAvailable();
   void detachSender();
@@ -128,14 +144,18 @@ private slots:
   void sendHeartBeat();
   void receiveHeartBeat(AbstractPeer *peer, const QVariantList &params);
   void receiveHeartBeatReply(AbstractPeer *peer, const QVariantList &params);
-  
+
+  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();
@@ -158,6 +178,7 @@ private:
 
   void receivePackedFunc(AbstractPeer *sender, const QVariant &packedFunc);
   void receivePeerSignal(AbstractPeer *sender, const RequestType &requestType, const QVariantList &params);
+  void receivePeerSignal(SignalProxy *sender, const RequestType &requestType, const QVariantList &params);
   void handleSync(AbstractPeer *sender, QVariantList params);
   void handleInitRequest(AbstractPeer *sender, const QVariantList &params);
   void handleInitData(AbstractPeer *sender, const QVariantList &params);
@@ -176,6 +197,8 @@ public:
   inline int peerCount() const { return _peers.size(); }
   
 private:
+  static void disconnectDevice(QIODevice *dev, const QString &reason = QString());
+
   class AbstractPeer {
   public:
     enum PeerType {
@@ -188,6 +211,7 @@ private:
     virtual ~AbstractPeer() {}
     inline PeerType type() const { return _type; }
     virtual void dispatchSignal(const RequestType &requestType, const QVariantList &params) = 0;
+    virtual bool isSecure() const = 0;
   private:
     PeerType _type;
   };
@@ -196,9 +220,11 @@ private:
   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 &params);
+    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;
@@ -211,26 +237,18 @@ private:
 
   class SignalProxyPeer : public AbstractPeer {
   public:
-    SignalProxyPeer(SignalProxy *proxy) : AbstractPeer(AbstractPeer::SignalProxyPeer), proxy(proxy) {}
+    SignalProxyPeer(SignalProxy *sender, SignalProxy *receiver) : AbstractPeer(AbstractPeer::SignalProxyPeer), sender(sender), receiver(receiver) {}
     virtual void dispatchSignal(const RequestType &requestType, const QVariantList &params);
+    virtual inline bool isSecure() const { return true; }
   private:
-    SignalProxy *proxy;
+    SignalProxy *sender;
+    SignalProxy *receiver;
   };
 
   // a Hash of the actual used communication object to it's corresponding peer
   // 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;
@@ -250,6 +268,8 @@ private:
 
   ProxyMode _proxyMode;
   QTimer _heartBeatTimer;
+
+  bool _secure; // determines if all connections are in a secured state (using ssl or internal connections)
   
   friend class SignalRelay;
 };