qremoteobjectnode_p.h

++ // Copyright (C) 2017 Ford Motor Company

++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only

++ // Qt-Security score:significant reason:declarations-only

++

++ #ifndef QREMOTEOBJECTNODE_P_H

++ #define QREMOTEOBJECTNODE_P_H

++

++ //

++ //  W A R N I N G

++ //  -------------

++ //

++ // This file is not part of the Qt API.  It exists purely as an

++ // implementation detail.  This header file may change from version to

++ // version without notice, or even be removed.

++ //

++ // We mean it.

++ //

++

++ #include <QtCore/private/qobject_p.h>

++ #include "qremoteobjectsourceio_p.h"

++ #include "qremoteobjectstructs_p.h"

++ #include "qremoteobjectreplica.h"

++ #include "qremoteobjectnode.h"

++

++ #include <QtCore/qbasictimer.h>

++ #include <QtCore/qmutex.h>

++

++ QT_BEGIN_NAMESPACE

++

++ #define qRODebug(x) qCDebug(QT_REMOTEOBJECT) << qPrintable(QtPrivate::deref_for_methodcall(x).objectName())

++ #define qROWarning(x) qCWarning(QT_REMOTEOBJECT) << qPrintable(QtPrivate::deref_for_methodcall(x).objectName())

++ #define qROCritical(x) qCCritical(QT_REMOTEOBJECT) << qPrintable(QtPrivate::deref_for_methodcall(x).objectName())

++ #define qROFatal(x) qCFatal(QT_REMOTEOBJECT) << qPrintable(QtPrivate::deref_for_methodcall(x).objectName())

++ #define qROPrivDebug() qCDebug(QT_REMOTEOBJECT) << qPrintable(q_ptr->objectName())

++ #define qROPrivWarning() qCWarning(QT_REMOTEOBJECT) << qPrintable(q_ptr->objectName())

++ #define qROPrivCritical() qCCritical(QT_REMOTEOBJECT) << qPrintable(q_ptr->objectName())

++ #define qROPrivFatal() qCFatal(QT_REMOTEOBJECT) << qPrintable(q_ptr->objectName())

++

++ class QRemoteObjectRegistry;

++ class QRegistrySource;

++ class QConnectedReplicaImplementation;

++

++ QMetaObject *registerGadget(QObject *reference, const QRemoteObjectInternalTypes::GadgetData &gadget, QByteArray typeName);

++ QMetaObject *registerAndTrackDefinition(const QRemoteObjectInternalTypes::ClassData &data, QObject *reference);

++ bool trackAdditionalReference(QObject *reference, const QByteArray &typeName);

++

++ class QRemoteObjectAbstractPersistedStorePrivate : public QObjectPrivate

++ {

++ public:

++     QRemoteObjectAbstractPersistedStorePrivate();

++     virtual ~QRemoteObjectAbstractPersistedStorePrivate();

++

++     Q_DECLARE_PUBLIC(QRemoteObjectAbstractPersistedStore)

++ };

++

++ class QRemoteObjectMetaObjectManager

++ {

++ public:

++     QRemoteObjectMetaObjectManager() {}

++     ~QRemoteObjectMetaObjectManager();

++

++     const QMetaObject *metaObjectForType(const QString &type);

++     QMetaObject *addDynamicType(QtROIoDeviceBase* connection, QDataStream &in);

++     void addFromMetaObject(const QMetaObject *);

++

++ private:

++     QHash<QString, QMetaObject*> dynamicTypes;

++     QHash<QString, const QMetaObject*> staticTypes;

++     QHash<QMetaObject *, QList<QMetaType>> enumTypes;

++ };

++

++ struct ProxyReplicaInfo;

++ class ProxyInfo : public QObject

++ {

++     Q_OBJECT

++ public:

++     ProxyInfo(QRemoteObjectNode *node, QRemoteObjectHostBase *parent, QRemoteObjectHostBase::RemoteObjectNameFilter filter);

++     ~ProxyInfo() override;

++     enum class ProxyDirection { Forward, Reverse };

++

++     bool setReverseProxy(QRemoteObjectHostBase::RemoteObjectNameFilter filter);

++     void proxyObject(const QRemoteObjectSourceLocation &entry, ProxyDirection direction = ProxyDirection::Forward);

++     void unproxyObject(const QRemoteObjectSourceLocation &entry);

++

++     QRemoteObjectNode *proxyNode;

++     QRemoteObjectHostBase *parentNode;

++     QRemoteObjectHostBase::RemoteObjectNameFilter proxyFilter;

++     QRemoteObjectHostBase::RemoteObjectNameFilter reverseFilter;

++     QHash<QString, ProxyReplicaInfo*> proxiedReplicas;

++

++ private:

++     void disableAndDeleteObject(ProxyReplicaInfo* info);

++ };

++

++ struct ProxyReplicaInfo

++ {

++     // We need QObject, so we can hold Dynamic Replicas and QAIM Adapters

++     QObject* replica;

++     ProxyInfo::ProxyDirection direction;

++     ~ProxyReplicaInfo() { delete replica; }

++ };

++

++ class QRemoteObjectNodePrivate : public QObjectPrivate

++ {

++ public:

++     QRemoteObjectNodePrivate();

++     ~QRemoteObjectNodePrivate() override;

++

++     virtual QRemoteObjectSourceLocations remoteObjectAddresses() const;

++

++     void setReplicaImplementation(const QMetaObject *, QRemoteObjectReplica *, const QString &);

++

++     void setLastError(QRemoteObjectNode::ErrorCode errorCode);

++

++     void connectReplica(QObject *object, QRemoteObjectReplica *instance);

++     void openConnectionIfNeeded(const QString &name);

++

++     bool initConnection(const QUrl &address);

++     bool hasInstance(const QString &name);

++     void setRegistry(QRemoteObjectRegistry *);

++     QVariant handlePointerToQObjectProperty(QConnectedReplicaImplementation *rep, int index, const QVariant &property);

++     void handlePointerToQObjectProperties(QConnectedReplicaImplementation *rep, QVariantList &properties);

++     bool checkPropertyCount(QConnectedReplicaImplementation *rep, qsizetype expected, qsizetype received);

++

++     void onClientRead(QObject *obj);

++     void onRemoteObjectSourceAdded(const QRemoteObjectSourceLocation &entry);

++     void onRemoteObjectSourceRemoved(const QRemoteObjectSourceLocation &entry);

++     void onRegistryInitialized();

++     void onShouldReconnect(QtROClientIoDevice *ioDevice);

++

++     virtual QReplicaImplementationInterface *handleNewAcquire(const QMetaObject *meta, QRemoteObjectReplica *instance, const QString &name);

++     void handleReplicaConnection(const QString &name);

++     void handleReplicaConnection(const QByteArray &sourceSignature, QConnectedReplicaImplementation *rep, QtROIoDeviceBase *connection);

++     void initialize();

++     bool setRegistryUrlNodeImpl(const QUrl &registryAddr);

++

++ private:

++     bool checkSignatures(const QByteArray &a, const QByteArray &b);

++

++ public:

++     struct SourceInfo

++     {

++         QtROIoDeviceBase* device;

++         QString typeName;

++         QByteArray objectSignature;

++     };

++

++     QMutex mutex;

++     QUrl registryAddress;

++     QHash<QString, QWeakPointer<QReplicaImplementationInterface> > replicas;

++     QMap<QString, SourceInfo> connectedSources;

++     QMap<QString, QRemoteObjectNode::RemoteObjectSchemaHandler> schemaHandlers;

++     QSet<QtROClientIoDevice*> pendingReconnect;

++     QSet<QUrl> requestedUrls;

++     QRemoteObjectRegistry *registry;

++     int retryInterval;

++     QBasicTimer reconnectTimer;

++     QRemoteObjectNode::ErrorCode lastError;

++     QString rxName;

++     QRemoteObjectPackets::ObjectInfoList rxObjects;

++     QVariantList rxArgs;

++     QVariant rxValue;

++     QRemoteObjectAbstractPersistedStore *persistedStore;

++     int m_heartbeatInterval = 0;

++     QRemoteObjectMetaObjectManager dynamicTypeManager;

++     Q_DECLARE_PUBLIC(QRemoteObjectNode)

++ };

++

++ class QRemoteObjectHostBasePrivate : public QRemoteObjectNodePrivate

++ {

++ public:

++     QRemoteObjectHostBasePrivate();

++     ~QRemoteObjectHostBasePrivate() override;

++     QReplicaImplementationInterface *handleNewAcquire(const QMetaObject *meta, QRemoteObjectReplica *instance, const QString &name) override;

++

++     bool setHostUrlBaseImpl(const QUrl &hostAddress,

++                             QRemoteObjectHostBase::AllowedSchemas allowedSchemas =

++                                     QRemoteObjectHostBase::BuiltInSchemasOnly);

++

++ public:

++     QRemoteObjectSourceIo *remoteObjectIo;

++     ProxyInfo *proxyInfo = nullptr;

++     Q_DECLARE_PUBLIC(QRemoteObjectHostBase);

++ };

++

++ class QRemoteObjectHostPrivate : public QRemoteObjectHostBasePrivate

++ {

++ public:

++     QRemoteObjectHostPrivate();

++     ~QRemoteObjectHostPrivate() override;

++

++     bool setHostUrlHostImpl(const QUrl &hostAddress,

++                             QRemoteObjectHostBase::AllowedSchemas allowedSchemas =

++                                     QRemoteObjectHostBase::BuiltInSchemasOnly);

++

++     Q_DECLARE_PUBLIC(QRemoteObjectHost);

++ };

++

++ class QRemoteObjectRegistryHostPrivate : public QRemoteObjectHostBasePrivate

++ {

++ public:

++     QRemoteObjectRegistryHostPrivate();

++     ~QRemoteObjectRegistryHostPrivate() override;

++     QRemoteObjectSourceLocations remoteObjectAddresses() const override;

++     QRegistrySource *registrySource;

++

++     bool setRegistryUrlRegistryHostImpl(const QUrl &registryUrl);

++

++     Q_DECLARE_PUBLIC(QRemoteObjectRegistryHost);

++ };

++

++ QT_END_NAMESPACE

++

++ #endif

Revision control