X-Git-Url: https://git.quassel-irc.org/?p=quassel.git;a=blobdiff_plain;f=src%2Fcommon%2Fsignalproxy.h;h=3b8497c299eb1105a19261df6b79f1e02f43146f;hp=f2490ba52c275c1e31eabd2d7a68372c079dd44b;hb=6e1a8aa6b42f63d50b9b2e6419dccfae0429fa62;hpb=5c35ac3ee6f951d39cc052925aa224debfa148a8

diff --git a/src/common/signalproxy.h b/src/common/signalproxy.h
index f2490ba5..3b8497c2 100644
--- a/src/common/signalproxy.h
+++ b/src/common/signalproxy.h
@@ -1,5 +1,5 @@
 /***************************************************************************
- *   Copyright (C) 2005-08 by the Quassel Project                          *
+ *   Copyright (C) 2005-09 by the Quassel Project                          *
  *   devel@quassel-irc.org                                                 *
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
@@ -21,6 +21,7 @@
 #ifndef SIGNALPROXY_H
 #define SIGNALPROXY_H
 
+#include <QEvent>
 #include <QList>
 #include <QHash>
 #include <QVariant>
@@ -30,7 +31,6 @@
 #include <QByteArray>
 #include <QTimer>
 
-class SignalRelay;
 class SyncableObject;
 struct QMetaObject;
 
@@ -39,6 +39,9 @@ class SignalProxy : public QObject {
 
   class AbstractPeer;
   class IODevicePeer;
+  class SignalProxyPeer;
+
+  class SignalRelay;
 
 public:
   enum ProxyMode {
@@ -55,6 +58,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);
@@ -67,20 +80,12 @@ public:
   bool addPeer(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);
 
   void synchronize(SyncableObject *obj);
-
-//   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);
-  void stopSync(SyncableObject *obj);
+  void stopSynchronize(SyncableObject *obj);
 
   //! Writes a QVariant to a device.
   /** The data item is prefixed with the resulting blocksize,
@@ -95,69 +100,57 @@ public:
    */
   static bool readDataFromDevice(QIODevice *dev, quint32 &blockSize, QVariant &item, bool compressed = false);
 
-  static QString methodBaseName(const QMetaMethod &method);
-
-  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);
-
-  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;
-  };
+  class ExtendedMetaObject;
+  ExtendedMetaObject *extendedMetaObject(const QMetaObject *meta) const;
+  ExtendedMetaObject *createExtendedMetaObject(const QMetaObject *meta, bool checkConflicts = false);
+  inline ExtendedMetaObject *extendedMetaObject(const QObject *obj) const { return extendedMetaObject(metaObject(obj)); }
+  inline ExtendedMetaObject *createExtendedMetaObject(const QObject *obj, bool checkConflicts = false) { return createExtendedMetaObject(metaObject(obj), checkConflicts); }
 
+  bool isSecure() const { return _secure; }
   void dumpProxyStats();
-  
+
+public slots:
+  void detachObject(QObject *obj);
+  void detachSignals(QObject *sender);
+  void detachSlots(QObject *receiver);
+
+protected:
+  void customEvent(QEvent *event);
+  void sync_call__(const SyncableObject *obj, ProxyMode modeType, const char *funcname, va_list ap);
+  void renameObject(const SyncableObject *obj, const QString &newname, const QString &oldname);
+
 private slots:
   void dataAvailable();
-  void detachSender();
   void removePeerBySender();
-  void objectRenamed(const QString &newname, const QString &oldname);
   void objectRenamed(const QByteArray &classname, const QString &newname, const QString &oldname);
   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);
@@ -166,6 +159,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);
 
@@ -174,69 +168,20 @@ 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;
+  // SignalRelay for all manually attached signals
+  SignalRelay *_signalRelay;
 
   // RPC function -> (object, slot ID)
   typedef QPair<QObject*, int> MethodId;
@@ -250,8 +195,117 @@ private:
 
   ProxyMode _proxyMode;
   QTimer _heartBeatTimer;
-  
+
+  bool _secure; // determines if all connections are in a secured state (using ssl or internal connections)
+
   friend class SignalRelay;
+  friend class SyncableObject;
+};
+
+
+// ==================================================
+//  ExtendedMetaObject
+// ==================================================
+class SignalProxy::ExtendedMetaObject {
+  class MethodDescriptor {
+  public:
+    MethodDescriptor(const QMetaMethod &method);
+    MethodDescriptor() : _returnType(-1), _minArgCount(-1), _receiverMode(SignalProxy::Client) {}
+
+    inline const QByteArray &methodName() const { return _methodName; }
+    inline const QList<int> &argTypes() const { return _argTypes; }
+    inline int returnType() const { return _returnType; }
+    inline int minArgCount() const { return _minArgCount; }
+    inline SignalProxy::ProxyMode receiverMode() const { return _receiverMode; }
+
+  private:
+    QByteArray _methodName;
+    QList<int> _argTypes;
+    int _returnType;
+    int _minArgCount;
+    SignalProxy::ProxyMode _receiverMode; // Only acceptable as a Sync Call if the receiving SignalProxy is in this mode.
+  };
+
+public:
+  ExtendedMetaObject(const QMetaObject *meta, bool checkConflicts);
+
+  inline const QByteArray &methodName(int methodId) { return methodDescriptor(methodId).methodName(); }
+  inline const QList<int> &argTypes(int methodId) { return methodDescriptor(methodId).argTypes(); }
+  inline int returnType(int methodId) { return methodDescriptor(methodId).returnType(); }
+  inline int minArgCount(int methodId) { return methodDescriptor(methodId).minArgCount(); }
+  inline SignalProxy::ProxyMode receiverMode(int methodId) { return methodDescriptor(methodId).receiverMode(); }
+
+  inline int methodId(const QByteArray &methodName) { return _methodIds.contains(methodName) ? _methodIds[methodName] : -1; }
+
+  inline int updatedRemotelyId() { return _updatedRemotelyId; }
+  
+  inline const QHash<QByteArray, int> &slotMap() { return _methodIds; }
+  const QHash<int, int> &receiveMap();
+
+  const QMetaObject *metaObject() const { return _meta; }
+
+  static QByteArray methodName(const QMetaMethod &method);
+  static QString methodBaseName(const QMetaMethod &method);
+
+private:
+  const MethodDescriptor &methodDescriptor(int methodId);
+
+  const QMetaObject *_meta;
+  int _updatedRemotelyId; // id of the updatedRemotely() signal - makes things faster
+
+  QHash<int, MethodDescriptor> _methods;
+  QHash<QByteArray, int> _methodIds;
+  QHash<int, int> _receiveMap; // if slot x is called then hand over the result to slot y
+};
+
+
+// ==================================================
+//  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