X-Git-Url: https://git.quassel-irc.org/?p=quassel.git;a=blobdiff_plain;f=src%2Fcommon%2Fsignalproxy.h;h=584626e0ff4089e1eb136373ea77ee1a957faf60;hp=0dc33325c124785abda22df9ea8282cbed7a78c8;hb=d5095471627f6399b277d7c6d06b6bbcb915c57f;hpb=f24b79010368ac773923d29187c15c33aea69bc9

diff --git a/src/common/signalproxy.h b/src/common/signalproxy.h
index 0dc33325..584626e0 100644
--- 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>
@@ -39,6 +40,7 @@ class SignalProxy : public QObject {
 
   class AbstractPeer;
   class IODevicePeer;
+  class SignalProxyPeer;
 
 public:
   enum ProxyMode {
@@ -55,6 +57,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);
@@ -64,11 +76,10 @@ public:
   inline ProxyMode proxyMode() const { return _proxyMode; }
 
   bool addPeer(QIODevice *iodev);
-  void removePeer(QIODevice *iodev);
   bool addPeer(SignalProxy *proxy);
-  void removePeer(SignalProxy *proxy);
+  void removePeer(QObject *peer);
   void removeAllPeers();
-  
+
   bool attachSignal(QObject *sender, const char *signal, const QByteArray& sigName = QByteArray());
   bool attachSlot(const QByteArray& sigName, QObject *recv, const char *slot);
 
@@ -76,8 +87,6 @@ public:
 
 //   void setInitialized(SyncableObject *obj);
 //   bool isInitialized(SyncableObject *obj) const;
-  void requestInit(SyncableObject *obj);
-
   void detachObject(QObject *obj);
   void detachSignals(QObject *sender);
   void detachSlots(QObject *receiver);
@@ -96,30 +105,16 @@ public:
    */
   static bool readDataFromDevice(QIODevice *dev, quint32 &blockSize, QVariant &item, bool compressed = false);
 
-  static QString methodBaseName(const QMetaMethod &method);
+  class ExtendedMetaObject;
+  ExtendedMetaObject *extendedMetaObject(const QObject *obj) const;
+  void createExtendedMetaObject(const QObject *obj);
 
-  const QList<int> &argTypes(QObject *obj, int methodId);
-  const int &returnType(QObject *obj, int methodId);
-  const int &minArgCount(QObject *obj, int methodId);
-  const QByteArray &methodName(QObject *obj, int methodId);
-  const QHash<QByteArray, int> &syncMap(SyncableObject *obj);
-  const QHash<int, int> &receiveMap(SyncableObject *obj);
-  int updatedRemotelyId(SyncableObject *obj);
+  bool isSecure() const { return _secure; }
+  void dumpProxyStats();
 
-  typedef QHash<int, QList<int> > ArgHash;
-  typedef QHash<int, QByteArray> MethodNameHash;
-  struct ClassInfo {
-    ArgHash argTypes;
-    QHash<int, int> returnType;
-    QHash<int, int> minArgCount;
-    MethodNameHash methodNames;
-    int updatedRemotelyId; // id of the updatedRemotely() signal - makes things faster
-    QHash<QByteArray, int> syncMap;
-    QHash<int, int> receiveMap;
-  };
+protected:
+  void customEvent(QEvent *event);
 
-  void dumpProxyStats();
-  
 private slots:
   void dataAvailable();
   void detachSender();
@@ -129,36 +124,31 @@ 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();
   void initClient();
-  
-  const QMetaObject *metaObject(QObject *obj);
-  void createClassInfo(QObject *obj);
-  void setArgTypes(QObject *obj, int methodId);
-  void setReturnType(QObject *obj, int methodId);
-  void setMinArgCount(QObject *obj, int methodId);
-  void setMethodName(QObject *obj, int methodId);
-  void setSyncMap(SyncableObject *obj);
-  void setReceiveMap(SyncableObject *obj);
-  void setUpdatedRemotelyId(SyncableObject *obj);
-
-  bool methodsMatch(const QMetaMethod &signal, const QMetaMethod &slot) const;
+
+  static const QMetaObject *metaObject(const QObject *obj);
 
   void dispatchSignal(QIODevice *receiver, const RequestType &requestType, const QVariantList &params);
   void dispatchSignal(const RequestType &requestType, const QVariantList &params);
 
   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);
@@ -167,6 +157,7 @@ private:
   bool invokeSlot(QObject *receiver, int methodId, const QVariantList &params, QVariant &returnValue);
   bool invokeSlot(QObject *receiver, int methodId, const QVariantList &params = QVariantList());
 
+  void requestInit(SyncableObject *obj);
   QVariantMap initData(SyncableObject *obj) const;
   void setInitData(SyncableObject *obj, const QVariantMap &properties);
 
@@ -175,66 +166,17 @@ private:
 public:
   void dumpSyncMap(SyncableObject *object);
   inline int peerCount() const { return _peers.size(); }
-  
-private:
-  class AbstractPeer {
-  public:
-    enum PeerType {
-      NotAPeer = 0,
-      IODevicePeer = 1,
-      SignalProxyPeer = 2
-    };
-    AbstractPeer() : _type(NotAPeer) {}
-    AbstractPeer(PeerType type) : _type(type) {}
-    virtual ~AbstractPeer() {}
-    inline PeerType type() const { return _type; }
-    virtual void dispatchSignal(const RequestType &requestType, const QVariantList &params) = 0;
-  private:
-    PeerType _type;
-  };
 
-  class IODevicePeer : public AbstractPeer {
-  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);
-    inline void dispatchPackedFunc(const QVariant &packedFunc) { SignalProxy::writeDataToDevice(_device, packedFunc, usesCompression); }
-    inline QIODevice *device() const { return _device; }
-    inline bool isOpen() const { return _device->isOpen(); }
-    inline bool readData(QVariant &item) { return SignalProxy::readDataFromDevice(_device, byteCount, item, usesCompression); }
-  private:
-    QIODevice *_device;
-    quint32 byteCount;
-    bool usesCompression;
-  public:
-    int sentHeartBeats;
-    int lag;
-  };
-
-  class SignalProxyPeer : public AbstractPeer {
-  public:
-    SignalProxyPeer(SignalProxy *proxy) : AbstractPeer(AbstractPeer::SignalProxyPeer), proxy(proxy) {}
-    virtual void dispatchSignal(const RequestType &requestType, const QVariantList &params);
-  private:
-    SignalProxy *proxy;
-  };
+private:
+  static void disconnectDevice(QIODevice *dev, const QString &reason = QString());
 
   // 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;
+  QHash<const QMetaObject *, ExtendedMetaObject *> _extendedMetaObjects;
 
   // we use one SignalRelay per QObject
   QHash<QObject*, SignalRelay *> _relayHash;
@@ -251,8 +193,94 @@ private:
 
   ProxyMode _proxyMode;
   QTimer _heartBeatTimer;
-  
+
+  bool _secure; // determines if all connections are in a secured state (using ssl or internal connections)
+
   friend class SignalRelay;
 };
 
+
+// ==================================================
+//  ExtendedMetaObject
+// ==================================================
+class SignalProxy::ExtendedMetaObject {
+public:
+  ExtendedMetaObject(const QMetaObject *meta);
+
+  const QList<int> &argTypes(int methodId);
+  const int &returnType(int methodId);
+  const int &minArgCount(int methodId);
+  const QByteArray &methodName(int methodId);
+  const QHash<QByteArray, int> &syncMap();
+  const QHash<int, int> &receiveMap();
+  int updatedRemotelyId();
+
+  static QByteArray methodName(const QMetaMethod &method);
+  static bool methodsMatch(const QMetaMethod &signal, const QMetaMethod &slot);
+  static QString methodBaseName(const QMetaMethod &method);
+
+private:
+  typedef QHash<int, QList<int> > ArgHash;
+  typedef QHash<int, QByteArray> MethodNameHash;
+
+  const QMetaObject *_meta;
+  ArgHash _argTypes;
+  QHash<int, int> _returnType;
+  QHash<int, int> _minArgCount;
+  MethodNameHash _methodNames;
+  int _updatedRemotelyId; // id of the updatedRemotely() signal - makes things faster
+  QHash<QByteArray, int> _syncMap;
+  QHash<int, int> _receiveMap;
+};
+
+
+// ==================================================
+//  Peers
+// ==================================================
+class SignalProxy::AbstractPeer {
+public:
+  enum PeerType {
+    NotAPeer = 0,
+    IODevicePeer = 1,
+    SignalProxyPeer = 2
+  };
+  AbstractPeer() : _type(NotAPeer) {}
+  AbstractPeer(PeerType type) : _type(type) {}
+  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;
+};
+
+class SignalProxy::IODevicePeer : public SignalProxy::AbstractPeer {
+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); }
+  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;
+  quint32 byteCount;
+  bool usesCompression;
+public:
+  int sentHeartBeats;
+  int lag;
+};
+
+class SignalProxy::SignalProxyPeer : public SignalProxy::AbstractPeer {
+public:
+  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 *sender;
+  SignalProxy *receiver;
+};
+
 #endif