qt/qtremoteobjects/src/remoteobjects/qremoteobjectpacket.cpp

Revision control

Copy as Markdown

// 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:critical reason:data-parser
#include <QtCore/qabstractitemmodel.h>
#include <QtCore/qbytearrayview.h>
#include "qremoteobjectcontainers_p.h"
#include "qremoteobjectpendingcall.h"
#include "qremoteobjectsource.h"
#include "qremoteobjectsource_p.h"
#include "qremoteobjectpacket_p.h"
#include "qconnectionfactories.h"
#include "qconnectionfactories_p.h"
#include <cstring>
//#define QTRO_VERBOSE_PROTOCOL
QT_BEGIN_NAMESPACE
// Add methods so we can use QMetaEnum in a set
// Note for both functions we are skipping string comparisons/hashes. Since the
// metaObjects are the same, we can just use the address of the string.
inline bool operator==(const QMetaEnum e1, const QMetaEnum e2)
{
return e1.enclosingMetaObject() == e2.enclosingMetaObject()
&& e1.name() == e2.name()
&& e1.enumName() == e2.enumName()
&& e1.scope() == e2.scope();
}
inline size_t qHash(const QMetaEnum &key, size_t seed=0) Q_DECL_NOTHROW
{
return qHash(key.enclosingMetaObject(), seed) ^ qHash(static_cast<const void *>(key.name()), seed)
^ qHash(static_cast<const void *>(key.enumName()), seed) ^ qHash(static_cast<const void *>(key.scope()), seed);
}
static bool isSequentialGadgetType(QMetaType metaType)
{
if (QMetaType::canConvert(metaType, QMetaType::fromType<QMetaSequence::Iterable>())) {
static QHash<int, bool> lookup;
if (!lookup.contains(metaType.id())) {
auto stubVariant = QVariant(metaType, nullptr);
auto asIterable = stubVariant.value<QMetaSequence::Iterable>();
auto valueMetaType = asIterable.metaContainer().valueMetaType();
lookup[metaType.id()] = valueMetaType.flags().testFlag(QMetaType::IsGadget);
}
return lookup[metaType.id()];
}
return false;
}
static bool isAssociativeGadgetType(QMetaType metaType)
{
if (QMetaType::canConvert(metaType, QMetaType::fromType<QMetaAssociation::Iterable>())) {
static QHash<int, bool> lookup;
if (!lookup.contains(metaType.id())) {
auto stubVariant = QVariant(metaType, nullptr);
auto asIterable = stubVariant.value<QMetaAssociation::Iterable>();
auto valueMetaType = asIterable.metaContainer().mappedMetaType();
lookup[metaType.id()] = valueMetaType.flags().testFlag(QMetaType::IsGadget);
}
return lookup[metaType.id()];
}
return false;
}
using namespace QtRemoteObjects;
namespace QRemoteObjectPackets {
QMetaType transferTypeForEnum(QMetaType enumType)
{
const auto size = enumType.sizeOf();
switch (size) {
case 1: return QMetaType::fromType<qint8>();
case 2: return QMetaType::fromType<qint16>();
case 4: return QMetaType::fromType<qint32>();
// Qt currently only supports enum values of 4 or less bytes (QMetaEnum value(index) returns int)
// case 8: args.push_back(QVariant(QMetaType::Int, argv[i + 1])); break;
default:
qCWarning(QT_REMOTEOBJECT_IO) << "Invalid enum detected (Dynamic Replica)" << enumType.name() << "with size" << size;
return QMetaType::fromType<qint32>();
}
}
// QDataStream sends QVariants of custom types by sending their typename, allowing decode
// on the receiving side. For QtRO and enums, this won't work, as the enums have different
// scopes. E.g., the examples have ParentClassSource::MyEnum and ParentClassReplica::MyEnum.
// Dynamic types will be created as ParentClass::MyEnum. So instead, we change the variants
// to integers (encodeVariant) when sending them. On the receive side, the we know the
// types of properties and the signatures for methods, so we can use that information to
// decode the integer variant into an enum variant (via decodeVariant).
QVariant encodeVariant(const QVariant &value)
{
const auto metaType = value.metaType();
if (metaType.flags().testFlag(QMetaType::IsEnumeration)) {
auto converted = QVariant(value);
auto transferType = transferTypeForEnum(metaType);
converted.convert(transferType);
#ifdef QTRO_VERBOSE_PROTOCOL
qDebug() << "Converting from enum to integer type" << transferType.sizeOf() << converted << value;
#endif
return converted;
}
if (isSequentialGadgetType(metaType)) { // Doesn't include QtROSequentialContainer
// TODO Way to create the QVariant without copying the QSQ_?
QSQ_ sequence(value);
#ifdef QTRO_VERBOSE_PROTOCOL
qDebug() << "Encoding sequential container" << metaType.name() << "to QSQ_ to transmit";
#endif
return QVariant::fromValue<QSQ_>(sequence);
}
if (metaType == QMetaType::fromType<QtROSequentialContainer>()) {
QSQ_ sequence(value);
#ifdef QTRO_VERBOSE_PROTOCOL
qDebug() << "Encoding QtROSequentialContainer container to QSQ_ to transmit";
#endif
return QVariant::fromValue<QSQ_>(sequence);
}
if (isAssociativeGadgetType(metaType)) { // Doesn't include QtROAssociativeContainer
QAS_ map(value);
#ifdef QTRO_VERBOSE_PROTOCOL
qDebug() << "Encoding associative container" << metaType.name() << "to QAS_ to transmit";
#endif
return QVariant::fromValue<QAS_>(map);
}
if (metaType == QMetaType::fromType<QtROAssociativeContainer>()) {
QAS_ map(value);
#ifdef QTRO_VERBOSE_PROTOCOL
qDebug() << "Encoding QtROAssociativeContainer container to QAS_ to transmit";
#endif
return QVariant::fromValue<QAS_>(map);
}
return value;
}
QVariant decodeVariant(QVariant &&value, QMetaType metaType)
{
if (metaType.flags().testFlag(QMetaType::IsEnumeration)) {
#ifdef QTRO_VERBOSE_PROTOCOL
QVariant encoded(value);
#endif
value.convert(metaType);
#ifdef QTRO_VERBOSE_PROTOCOL
qDebug() << "Converting to enum from integer type" << value << encoded;
#endif
} else if (value.metaType() == QMetaType::fromType<QRemoteObjectPackets::QSQ_>()) {
const auto *qsq_ = static_cast<const QRemoteObjectPackets::QSQ_ *>(value.constData());
QDataStream in(qsq_->values);
auto containerType = QMetaType::fromName(qsq_->typeName.constData());
bool isRegistered = containerType.isRegistered();
if (isRegistered) {
QVariant seq{containerType, nullptr};
if (!seq.canView<QMetaSequence::Iterable>()) {
qWarning() << "Unsupported container" << qsq_->typeName.constData()
<< "(not viewable)";
return QVariant();
}
QMetaSequence::Iterable seqIter = seq.view<QMetaSequence::Iterable>();
const QMetaSequence metaSequence = seqIter.metaContainer();
if (!metaSequence.canAddValue()) {
qWarning() << "Unsupported container" << qsq_->typeName.constData()
<< "(Unable to add values)";
return QVariant();
}
QByteArray valueTypeName;
quint32 count;
in >> valueTypeName;
in >> count;
QMetaType valueType = QMetaType::fromName(valueTypeName.constData());
QVariant tmp{valueType, nullptr};
for (quint32 i = 0; i < count; i++) {
if (!valueType.load(in, tmp.data())) {
if (metaSequence.canRemoveValue() || i == 0) {
for (quint32 ii = 0; ii < i; ii++)
metaSequence.removeValue(seqIter.mutableIterable());
qWarning("QSQ_: unable to load type '%s', returning an empty list.", valueTypeName.constData());
} else {
qWarning("QSQ_: unable to load type '%s', returning a partial list.", valueTypeName.constData());
}
break;
}
QtPrivate::QVariantTypeCoercer coercer;
metaSequence.addValue(
seqIter.mutableIterable(),
coercer.coerce(tmp, metaSequence.valueMetaType()));
}
value = seq;
#ifdef QTRO_VERBOSE_PROTOCOL
qDebug() << "Decoding QSQ_ to sequential container" << containerType.name()
<< valueTypeName;
#endif
} else {
QtROSequentialContainer container{};
in >> container;
container.m_typeName = qsq_->typeName;
value = QVariant(QMetaType::fromType<QtROSequentialContainer>(), &container);
#ifdef QTRO_VERBOSE_PROTOCOL
qDebug() << "Decoding QSQ_ to QtROSequentialContainer of"
<< container.m_valueTypeName;
#endif
}
} else if (value.metaType() == QMetaType::fromType<QRemoteObjectPackets::QAS_>()) {
const auto *qas_ = static_cast<const QRemoteObjectPackets::QAS_ *>(value.constData());
QDataStream in(qas_->values);
auto containerType = QMetaType::fromName(qas_->typeName.constData());
bool isRegistered = containerType.isRegistered();
if (isRegistered) {
QVariant map{containerType, nullptr};
if (!map.canView<QMetaAssociation::Iterable>()) {
qWarning() << "Unsupported container" << qas_->typeName.constData()
<< "(not viewable)";
return QVariant();
}
QMetaAssociation::Iterable mapIter = map.view<QMetaAssociation::Iterable>();
if (!mapIter.metaContainer().canSetMappedAtKey()) {
qWarning() << "Unsupported container" << qas_->typeName.constData()
<< "(Unable to insert values)";
return QVariant();
}
QByteArray keyTypeName, valueTypeName;
quint32 count;
in >> keyTypeName;
QMetaType keyType = QMetaType::fromName(keyTypeName.constData());
if (!keyType.isValid()) {
// This happens for class enums, where the passed keyType is <ClassName>::<enum>
// For a compiled replica, the keyType is <ClassName>Replica::<enum>
// Since the full typename is registered, we can pull the keyType from there
keyType = mapIter.metaContainer().keyMetaType();
}
QMetaType transferType = keyType;
if (keyType.flags().testFlag(QMetaType::IsEnumeration))
transferType = transferTypeForEnum(keyType);
QVariant key{transferType, nullptr};
in >> valueTypeName;
QMetaType valueType = QMetaType::fromName(valueTypeName.constData());
QVariant val{valueType, nullptr};
in >> count;
for (quint32 i = 0; i < count; i++) {
if (!transferType.load(in, key.data())) {
map = QVariant{containerType, nullptr};
qWarning("QAS_: unable to load key of type '%s', returning an empty map.",
keyTypeName.constData());
break;
}
if (!valueType.load(in, val.data())) {
map = QVariant{containerType, nullptr};
qWarning("QAS_: unable to load value of type '%s', returning an empty map.",
valueTypeName.constData());
break;
}
if (transferType != keyType) {
QVariant enumKey(key);
enumKey.convert(keyType);
mapIter.setValue(enumKey, val);
} else {
mapIter.setValue(key, val);
}
}
value = map;
#ifdef QTRO_VERBOSE_PROTOCOL
qDebug() << "Decoding QAS_ to associative container" << containerType.name()
<< valueTypeName << keyTypeName << count << mapIter.size() << map;
#endif
} else {
QtROAssociativeContainer container{};
in >> container;
container.m_typeName = qas_->typeName;
value = QVariant(QMetaType::fromType<QtROAssociativeContainer>(), &container);
#ifdef QTRO_VERBOSE_PROTOCOL
qDebug() << "Decoding QAS_ to QtROAssociativeContainer of"
<< container.m_valueTypeName;
#endif
}
} else if (metaType.isValid() && metaType != QMetaType::fromType<QVariant>()
&& value.metaType() != metaType) {
if (!value.canConvert(metaType)) {
qWarning("The provided type %s does not match the expected type %s and is "
"not convertible to it. Returning a default-constructed QVariant "
"holding the type %s.",
value.metaType().name(), metaType.name(), metaType.name());
return QVariant(metaType);
}
value.convert(metaType);
}
return std::move(value);
}
void QDataStreamCodec::serializeProperty(const QRemoteObjectSourceBase *source, int internalIndex)
{
serializeProperty(m_packet, source, internalIndex);
}
void QDataStreamCodec::serializeProperty(QDataStream &ds, const QRemoteObjectSourceBase *source, int internalIndex)
{
const int propertyIndex = source->m_api->sourcePropertyIndex(internalIndex);
Q_ASSERT (propertyIndex >= 0);
const auto target = source->m_api->isAdapterProperty(internalIndex) ? source->m_adapter : source->m_object;
const auto property = target->metaObject()->property(propertyIndex);
const QVariant value = property.read(target);
if (property.metaType().flags().testFlag(QMetaType::PointerToQObject)) {
auto const childSource = source->m_children.value(internalIndex);
auto valueAsPointerToQObject = qvariant_cast<QObject *>(value);
if (childSource->m_object != valueAsPointerToQObject)
childSource->resetObject(valueAsPointerToQObject);
QRO_ qro(childSource);
if (source->d->isDynamic && qro.type == ObjectType::CLASS && childSource->m_object && !source->d->sentTypes.contains(qro.typeName)) {
QDataStream classDef(&qro.classDefinition, QIODevice::WriteOnly);
serializeDefinition(classDef, childSource);
source->d->sentTypes.insert(qro.typeName);
}
ds << QVariant::fromValue<QRO_>(qro);
if (qro.isNull)
return;
const int propertyCount = childSource->m_api->propertyCount();
// Put the properties in a buffer, the receiver may not know how to
// interpret the types until it registers new ones.
QDataStream params(&qro.parameters, QIODevice::WriteOnly);
params << propertyCount;
for (int internalIndex = 0; internalIndex < propertyCount; ++internalIndex)
serializeProperty(params, childSource, internalIndex);
ds << qro.parameters;
return;
}
if (source->d->isDynamic && property.userType() == QMetaType::QVariant
&& value.metaType().flags().testFlag(QMetaType::IsGadget)) {
const auto typeName = QString::fromLatin1(value.metaType().name());
if (!source->d->sentTypes.contains(typeName)) {
QRO_ qro(value);
ds << QVariant::fromValue<QRO_>(qro);
ds << qro.parameters;
source->d->sentTypes.insert(typeName);
return;
}
}
ds << encodeVariant(value);
}
void QDataStreamCodec::serializeHandshakePacket()
{
m_packet.setId(Handshake);
m_packet << QString(protocolVersion);
m_packet.finishPacket();
}
void QDataStreamCodec::serializeInitPacket(const QRemoteObjectRootSource *source)
{
m_packet.setId(InitPacket);
m_packet << source->name();
serializeProperties(source);
m_packet.finishPacket();
}
void QDataStreamCodec::serializeProperties(const QRemoteObjectSourceBase *source)
{
const SourceApiMap *api = source->m_api;
//Now copy the property data
const int numProperties = api->propertyCount();
m_packet << quint32(numProperties); //Number of properties
for (int internalIndex = 0; internalIndex < numProperties; ++internalIndex)
serializeProperty(source, internalIndex);
}
bool deserializeQVariantList(QDataStream &s, QVariantList &l)
{
// note: optimized version of: QDataStream operator>>(QDataStream& s, QList<T>& l)
quint32 c;
s >> c;
const qsizetype count = static_cast<qsizetype>(c);
const qsizetype listSize = l.size();
if (listSize < count)
l.reserve(count);
else if (listSize > count)
l.resize(count);
for (int i = 0; i < l.size(); ++i)
{
if (s.atEnd())
return false;
s >> l[i];
}
for (auto i = l.size(); i < count; ++i)
{
if (s.atEnd())
return false;
s >> l.emplace_back();
}
return true;
}
void QDataStreamCodec::deserializeInitPacket(QDataStream &in, QVariantList &values)
{
const bool success = deserializeQVariantList(in, values);
Q_ASSERT(success);
Q_UNUSED(success)
}
void QDataStreamCodec::serializeInitDynamicPacket(const QRemoteObjectRootSource *source)
{
m_packet.setId(InitDynamicPacket);
m_packet << source->name();
serializeDefinition(m_packet, source);
serializeProperties(source);
m_packet.finishPacket();
}
static ObjectType getObjectType(const QString &typeName)
{
if (typeName == QLatin1String("QAbstractItemModelAdapter"))
return ObjectType::MODEL;
auto tid = QMetaType::fromName(typeName.toUtf8()).id();
if (tid == QMetaType::UnknownType)
return ObjectType::CLASS;
QMetaType type(tid);
auto mo = type.metaObject();
if (mo && mo->inherits(&QAbstractItemModel::staticMetaObject))
return ObjectType::MODEL;
return ObjectType::CLASS;
}
static QByteArrayView resolveEnumName(QMetaType t, bool &isFlag)
{
// Takes types like `MyPOD::Position` or `QFlags<MyPOD::Position>` and returns 'Position`
QByteArrayView enumName(t.name());
isFlag = enumName.startsWith("QFlags<");
auto lastColon = enumName.lastIndexOf(':');
if (lastColon >= 0)
enumName = QByteArrayView(t.name() + lastColon + 1);
if (isFlag)
enumName.chop(1);
return enumName;
}
static QMetaEnum metaEnumFromType(QMetaType t)
{
if (t.flags().testFlag(QMetaType::IsEnumeration)) {
if (const QMetaObject *m = t.metaObject()) {
bool isFlag;
auto enumName = resolveEnumName(t, isFlag);
if (isFlag) {
for (int i = m->enumeratorOffset(); i < m->enumeratorCount(); i++) {
auto testType = m->enumerator(i);
if (testType.isFlag() &&
enumName.compare(QByteArrayView(testType.enumName())) == 0)
return testType;
}
}
return m->enumerator(m->indexOfEnumerator(enumName.data()));
}
}
return QMetaEnum();
}
static bool checkEnum(QMetaType metaType, QSet<QMetaEnum> &enums)
{
if (metaType.flags().testFlag(QMetaType::IsEnumeration)) {
QMetaEnum meta = metaEnumFromType(metaType);
enums.insert(meta);
return true;
}
return false;
}
static void recurseMetaobject(const QMetaObject *mo, QSet<const QMetaObject *> &gadgets, QSet<QMetaEnum> &enums)
{
if (!mo || gadgets.contains(mo))
return;
gadgets.insert(mo);
const int numProperties = mo->propertyCount();
for (int i = 0; i < numProperties; ++i) {
const auto property = mo->property(i);
if (checkEnum(property.metaType(), enums))
continue;
if (property.metaType().flags().testFlag(QMetaType::IsGadget))
recurseMetaobject(property.metaType().metaObject(), gadgets, enums);
}
}
// A Source may only use a subset of the metaobjects properties/signals/slots, so we only search
// the ones in the API. For nested pointer types, we will have another api to limit the search.
// For nested PODs/enums, we search the entire qobject (using the recurseMetaobject call()).
void recurseForGadgets(QSet<const QMetaObject *> &gadgets, QSet<QMetaEnum> &enums, const QRemoteObjectSourceBase *source)
{
const SourceApiMap *api = source->m_api;
const int numSignals = api->signalCount();
const int numMethods = api->methodCount();
const int numProperties = api->propertyCount();
for (int si = 0; si < numSignals; ++si) {
const int params = api->signalParameterCount(si);
for (int pi = 0; pi < params; ++pi) {
const int type = api->signalParameterType(si, pi);
const auto metaType = QMetaType(type);
if (checkEnum(metaType, enums))
continue;
if (!metaType.flags().testFlag(QMetaType::IsGadget))
continue;
const auto mo = metaType.metaObject();
if (source->d->sentTypes.contains(QLatin1String(mo->className())))
continue;
recurseMetaobject(mo, gadgets, enums);
source->d->sentTypes.insert(QLatin1String(mo->className()));
}
}
for (int mi = 0; mi < numMethods; ++mi) {
const int params = api->methodParameterCount(mi);
for (int pi = 0; pi < params; ++pi) {
const int type = api->methodParameterType(mi, pi);
const auto metaType = QMetaType(type);
if (checkEnum(metaType, enums))
continue;
if (!metaType.flags().testFlag(QMetaType::IsGadget))
continue;
const auto mo = metaType.metaObject();
if (source->d->sentTypes.contains(QLatin1String(mo->className())))
continue;
recurseMetaobject(mo, gadgets, enums);
source->d->sentTypes.insert(QLatin1String(mo->className()));
}
}
for (int pi = 0; pi < numProperties; ++pi) {
const int index = api->sourcePropertyIndex(pi);
Q_ASSERT(index >= 0);
const auto target = api->isAdapterProperty(pi) ? source->m_adapter : source->m_object;
const auto metaProperty = target->metaObject()->property(index);
const auto metaType = metaProperty.metaType();
if (checkEnum(metaType, enums))
continue;
if (metaType.flags().testFlag(QMetaType::PointerToQObject)) {
auto const objectType = getObjectType(QString::fromLatin1(metaProperty.typeName()));
if (objectType == ObjectType::CLASS) {
auto const childSource = source->m_children.value(pi);
if (childSource->m_object)
recurseForGadgets(gadgets, enums, childSource);
}
}
if (!metaType.flags().testFlag(QMetaType::IsGadget))
continue;
const auto mo = metaType.metaObject();
if (source->d->sentTypes.contains(QLatin1String(mo->className())))
continue;
recurseMetaobject(mo, gadgets, enums);
source->d->sentTypes.insert(QLatin1String(mo->className()));
}
}
static bool checkForEnumsInSource(const QMetaObject *meta, const QRemoteObjectSourceBase *source)
{
if (source->m_object->inherits(meta->className()))
return true;
for (const auto &child : source->m_children) {
if (child->m_object && checkForEnumsInSource(meta, child))
return true;
}
return false;
}
static void serializeEnum(QDataStream &ds, const QMetaEnum &enumerator)
{
ds << QByteArray::fromRawData(enumerator.name(), qsizetype(qstrlen(enumerator.name())));
ds << enumerator.isFlag();
ds << enumerator.isScoped();
const auto typeName = QByteArray(enumerator.scope()).append("::").append(enumerator.name());
const quint32 size = quint32(QMetaType::fromName(typeName.constData()).sizeOf());
ds << size;
#ifdef QTRO_VERBOSE_PROTOCOL
qDebug(" Enum (name = %s, size = %d, isFlag = %s, isScoped = %s):", enumerator.name(), size, enumerator.isFlag() ? "true" : "false", enumerator.isScoped() ? "true" : "false");
#endif
const int keyCount = enumerator.keyCount();
ds << keyCount;
for (int k = 0; k < keyCount; ++k) {
ds << QByteArray::fromRawData(enumerator.key(k), qsizetype(qstrlen(enumerator.key(k))));
ds << enumerator.value(k);
#ifdef QTRO_VERBOSE_PROTOCOL
qDebug(" Key %d (name = %s, value = %d):", k, enumerator.key(k), enumerator.value(k));
#endif
}
}
static void serializeGadgets(QDataStream &ds, const QSet<const QMetaObject *> &gadgets, const QSet<QMetaEnum> &enums, const QRemoteObjectSourceBase *source=nullptr)
{
// Determine how to handle the enums found
QSet<QMetaEnum> qtEnums;
QSet<const QMetaObject *> dynamicEnumMetaObjects;
for (const auto &metaEnum : enums) {
auto const metaObject = metaEnum.enclosingMetaObject();
if (gadgets.contains(metaObject)) // Part of a gadget will we serialize
continue;
// This checks if the enum is defined in our object heirarchy, in which case it will
// already have been serialized.
if (source && checkForEnumsInSource(metaObject, source->d->root))
continue;
// qtEnums are enumerations already known by Qt, so we only need register them.
// We don't need to send all of the key/value data.
if (metaObject == &Qt::staticMetaObject) // Are the other Qt metaclasses for enums?
qtEnums.insert(metaEnum);
else
dynamicEnumMetaObjects.insert(metaEnum.enclosingMetaObject());
}
ds << quint32(qtEnums.size());
for (const auto &metaEnum : std::as_const(qtEnums)) {
QByteArray enumName(metaEnum.scope());
enumName.append("::", 2).append(metaEnum.name());
ds << enumName;
}
const auto allMetaObjects = gadgets + dynamicEnumMetaObjects;
ds << quint32(allMetaObjects.size());
#ifdef QTRO_VERBOSE_PROTOCOL
qDebug() << " Found" << gadgets.size() << "gadget/pod and" << (allMetaObjects.size() - gadgets.size()) << "enum types";
int i = 0;
#endif
// There isn't an easy way to update a metaobject incrementally, so we
// send all of the metaobject's enums, but no properties, when an external
// enum is requested.
for (auto const meta : allMetaObjects) {
ds << QByteArray::fromRawData(meta->className(), qsizetype(qstrlen(meta->className())));
int propertyCount = gadgets.contains(meta) ? meta->propertyCount() : 0;
ds << quint32(propertyCount);
#ifdef QTRO_VERBOSE_PROTOCOL
qDebug(" Gadget %d (name = %s, # properties = %d, # enums = %d):", i++, meta->className(), propertyCount, meta->enumeratorCount() - meta->enumeratorOffset());
#endif
for (int j = 0; j < propertyCount; j++) {
auto prop = meta->property(j);
#ifdef QTRO_VERBOSE_PROTOCOL
qDebug(" Data member %d (name = %s, type = %s):", j, prop.name(), prop.typeName());
#endif
ds << QByteArray::fromRawData(prop.name(), qsizetype(qstrlen(prop.name())));
ds << QByteArray::fromRawData(prop.typeName(), qsizetype(qstrlen(prop.typeName())));
}
int enumCount = meta->enumeratorCount() - meta->enumeratorOffset();
ds << quint32(enumCount);
for (int j = meta->enumeratorOffset(); j < meta->enumeratorCount(); j++) {
auto const enumMeta = meta->enumerator(j);
serializeEnum(ds, enumMeta);
}
}
}
void QDataStreamCodec::serializeDefinition(QDataStream &ds, const QRemoteObjectSourceBase *source)
{
const SourceApiMap *api = source->m_api;
const QByteArray desiredClassName(api->typeName().toLatin1());
const QByteArray originalClassName = api->className();
// The dynamic class will be called typeName on the receiving side of this definition
// However, there are types like enums that have the QObject's class name. Replace()
// will convert a parameter such as "ParentClassSource::MyEnum" to "ParentClass::MyEnum"
// so the type can be properly resolved and registered.
auto replace = [&originalClassName, &desiredClassName](QByteArray &name) {
name.replace(originalClassName, desiredClassName);
};
ds << source->m_api->typeName();
#ifdef QTRO_VERBOSE_PROTOCOL
qDebug() << "Serializing definition for" << source->m_api->typeName();
#endif
//Now copy the property data
const int numEnums = api->enumCount();
const auto metaObject = source->m_object->metaObject();
ds << quint32(numEnums); //Number of Enums
#ifdef QTRO_VERBOSE_PROTOCOL
qDebug() << " Found" << numEnums << "enumeration types";
#endif
for (int i = 0; i < numEnums; ++i) {
auto enumerator = metaObject->enumerator(api->sourceEnumIndex(i));
Q_ASSERT(enumerator.isValid());
serializeEnum(ds, enumerator);
}
QSet<const QMetaObject *> gadgets;
QSet<QMetaEnum> enums;
recurseForGadgets(gadgets, enums, source);
serializeGadgets(ds, gadgets, enums, source);
const int numSignals = api->signalCount();
ds << quint32(numSignals); //Number of signals
for (int i = 0; i < numSignals; ++i) {
const int index = api->sourceSignalIndex(i);
Q_ASSERT(index >= 0);
auto signature = api->signalSignature(i);
replace(signature);
const int count = api->signalParameterCount(i);
for (int pi = 0; pi < count; ++pi) {
const auto metaType = QMetaType(api->signalParameterType(i, pi));
if (isSequentialGadgetType(metaType))
signature.replace(metaType.name(), "QtROSequentialContainer");
else if (isAssociativeGadgetType(metaType))
signature.replace(metaType.name(), "QtROAssociativeContainer");
}
#ifdef QTRO_VERBOSE_PROTOCOL
qDebug() << " Signal" << i << "(signature =" << signature << "parameter names =" << api->signalParameterNames(i) << ")";
#endif
ds << signature;
ds << api->signalParameterNames(i);
}
const int numMethods = api->methodCount();
ds << quint32(numMethods); //Number of methods
for (int i = 0; i < numMethods; ++i) {
const int index = api->sourceMethodIndex(i);
Q_ASSERT(index >= 0);
auto signature = api->methodSignature(i);
replace(signature);
const int count = api->methodParameterCount(i);
for (int pi = 0; pi < count; ++pi) {
const auto metaType = QMetaType(api->methodParameterType(i, pi));
if (isSequentialGadgetType(metaType))
signature.replace(metaType.name(), "QtROSequentialContainer");
else if (isAssociativeGadgetType(metaType))
signature.replace(metaType.name(), "QtROAssociativeContainer");
}
auto typeName = api->typeName(i);
replace(typeName);
#ifdef QTRO_VERBOSE_PROTOCOL
qDebug() << " Slot" << i << "(signature =" << signature << "parameter names =" << api->methodParameterNames(i) << "return type =" << typeName << ")";
#endif
ds << signature;
ds << typeName;
ds << api->methodParameterNames(i);
}
const int numProperties = api->propertyCount();
ds << quint32(numProperties); //Number of properties
for (int i = 0; i < numProperties; ++i) {
const int index = api->sourcePropertyIndex(i);
Q_ASSERT(index >= 0);
const auto target = api->isAdapterProperty(i) ? source->m_adapter : source->m_object;
const auto metaProperty = target->metaObject()->property(index);
ds << metaProperty.name();
#ifdef QTRO_VERBOSE_PROTOCOL
qDebug() << " Property" << i << "name =" << metaProperty.name();
#endif
if (metaProperty.metaType().flags().testFlag(QMetaType::PointerToQObject)) {
auto objectType = getObjectType(QLatin1String(metaProperty.typeName()));
ds << (objectType == ObjectType::CLASS ? "QObject*" : "QAbstractItemModel*");
#ifdef QTRO_VERBOSE_PROTOCOL
qDebug() << " Type:" << (objectType == ObjectType::CLASS ? "QObject*" : "QAbstractItemModel*");
#endif
} else {
if (isSequentialGadgetType(metaProperty.metaType())) {
ds << "QtROSequentialContainer";
#ifdef QTRO_VERBOSE_PROTOCOL
qDebug() << " Type:" << "QtROSequentialContainer";
#endif
} else if (isAssociativeGadgetType(metaProperty.metaType())) {
ds << "QtROAssociativeContainer";
#ifdef QTRO_VERBOSE_PROTOCOL
qDebug() << " Type:" << "QtROAssociativeContainer";
#endif
} else {
ds << metaProperty.typeName();
#ifdef QTRO_VERBOSE_PROTOCOL
qDebug() << " Type:" << metaProperty.typeName();
#endif
}
}
if (metaProperty.notifySignalIndex() == -1) {
ds << QByteArray();
#ifdef QTRO_VERBOSE_PROTOCOL
qDebug() << " Notification signal: None";
#endif
} else {
auto signature = metaProperty.notifySignal().methodSignature();
replace(signature);
ds << signature;
#ifdef QTRO_VERBOSE_PROTOCOL
qDebug() << " Notification signal:" << signature;
#endif
}
}
}
void QDataStreamCodec::serializeAddObjectPacket(const QString &name, bool isDynamic)
{
m_packet.setId(AddObject);
m_packet << name;
m_packet << isDynamic;
m_packet.finishPacket();
}
void QDataStreamCodec::deserializeAddObjectPacket(QDataStream &ds, bool &isDynamic)
{
ds >> isDynamic;
}
void QDataStreamCodec::serializeRemoveObjectPacket(const QString &name)
{
m_packet.setId(RemoveObject);
m_packet << name;
m_packet.finishPacket();
}
//There is no deserializeRemoveObjectPacket - no parameters other than id and name
void QDataStreamCodec::serializeInvokePacket(const QString &name, int call, int index, const QVariantList &args, int serialId, int propertyIndex)
{
m_packet.setId(InvokePacket);
m_packet << name;
m_packet << call;
m_packet << index;
m_packet << quint32(args.size());
for (const auto &arg : args)
m_packet << encodeVariant(arg);
m_packet << serialId;
m_packet << propertyIndex;
m_packet.finishPacket();
}
void QDataStreamCodec::deserializeInvokePacket(QDataStream& in, int &call, int &index, QVariantList &args, int &serialId, int &propertyIndex)
{
in >> call;
in >> index;
const bool success = deserializeQVariantList(in, args);
Q_ASSERT(success);
Q_UNUSED(success)
in >> serialId;
in >> propertyIndex;
}
void QDataStreamCodec::serializeInvokeReplyPacket(const QString &name, int ackedSerialId, const QVariant &value)
{
m_packet.setId(InvokeReplyPacket);
m_packet << name;
m_packet << ackedSerialId;
m_packet << value;
m_packet.finishPacket();
}
void QDataStreamCodec::deserializeInvokeReplyPacket(QDataStream& in, int &ackedSerialId, QVariant &value){
in >> ackedSerialId;
in >> value;
}
void QDataStreamCodec::serializePropertyChangePacket(QRemoteObjectSourceBase *source, int signalIndex)
{
int internalIndex = source->m_api->propertyRawIndexFromSignal(signalIndex);
m_packet.setId(PropertyChangePacket);
m_packet << source->name();
m_packet << internalIndex;
serializeProperty(source, internalIndex);
m_packet.finishPacket();
}
void QDataStreamCodec::deserializePropertyChangePacket(QDataStream& in, int &index, QVariant &value)
{
in >> index;
in >> value;
}
void QDataStreamCodec::serializeObjectListPacket(const ObjectInfoList &objects)
{
m_packet.setId(ObjectList);
m_packet << objects;
m_packet.finishPacket();
}
void QDataStreamCodec::deserializeObjectListPacket(QDataStream &in, ObjectInfoList &objects)
{
in >> objects;
}
void QDataStreamCodec::serializePingPacket(const QString &name)
{
m_packet.setId(Ping);
m_packet << name;
m_packet.finishPacket();
}
void QDataStreamCodec::serializePongPacket(const QString &name)
{
m_packet.setId(Pong);
m_packet << name;
m_packet.finishPacket();
}
QRO_::QRO_(QRemoteObjectSourceBase *source)
: name(source->name())
, typeName(source->m_api->typeName())
, type(source->m_adapter ? ObjectType::MODEL : getObjectType(typeName))
, isNull(source->m_object == nullptr)
, classDefinition()
, parameters()
{}
QRO_::QRO_(const QVariant &value)
: type(ObjectType::GADGET)
, isNull(false)
{
const auto metaType = value.metaType();
auto meta = metaType.metaObject();
QDataStream out(&classDefinition, QIODevice::WriteOnly);
const int numProperties = meta->propertyCount();
const auto name = metaType.name();
const auto typeName = QByteArray::fromRawData(name, qsizetype(qstrlen(name)));
out << quint32(0) << quint32(1);
out << typeName;
out << numProperties;
#ifdef QTRO_VERBOSE_PROTOCOL
qDebug("Serializing POD definition to QRO_ (name = %s)", typeName.constData());
#endif
for (int i = 0; i < numProperties; ++i) {
const auto property = meta->property(i);
#ifdef QTRO_VERBOSE_PROTOCOL
qDebug(" Data member %d (name = %s, type = %s):", i, property.name(), property.typeName());
#endif
out << QByteArray::fromRawData(property.name(), qsizetype(qstrlen(property.name())));
out << QByteArray::fromRawData(property.typeName(), qsizetype(qstrlen(property.typeName())));
}
int enumCount = meta->enumeratorCount() - meta->enumeratorOffset();
out << quint32(enumCount);
for (int j = meta->enumeratorOffset(); j < meta->enumeratorCount(); j++) {
auto const enumMeta = meta->enumerator(j);
serializeEnum(out, enumMeta);
}
QDataStream ds(&parameters, QIODevice::WriteOnly);
ds << value;
#ifdef QTRO_VERBOSE_PROTOCOL
qDebug() << " Value:" << value;
#endif
}
QDataStream &operator<<(QDataStream &stream, const QRO_ &info)
{
stream << info.name << info.typeName << quint8(info.type) << info.classDefinition << info.isNull;
qCDebug(QT_REMOTEOBJECT) << "Serializing " << info;
// info.parameters will be filled in by serializeProperty
return stream;
}
QDataStream &operator>>(QDataStream &stream, QRO_ &info)
{
quint8 tmpType;
stream >> info.name >> info.typeName >> tmpType >> info.classDefinition >> info.isNull;
info.type = static_cast<ObjectType>(tmpType);
qCDebug(QT_REMOTEOBJECT) << "Deserializing " << info;
if (!info.isNull)
stream >> info.parameters;
return stream;
}
QSQ_::QSQ_(const QVariant &variant)
{
QMetaSequence::Iterable sequence;
QMetaType valueType;
if (variant.metaType() == QMetaType::fromType<QtROSequentialContainer>()) {
auto container = static_cast<const QtROSequentialContainer *>(variant.constData());
typeName = container->m_typeName;
valueType = container->m_valueType;
valueTypeName = container->m_valueTypeName;
sequence = QMetaSequence::Iterable(reinterpret_cast<const QVariantList *>(variant.constData()));
} else {
sequence = variant.value<QMetaSequence::Iterable>();
typeName = QByteArray(variant.metaType().name());
valueType = sequence.metaContainer().valueMetaType();
valueTypeName = QByteArray(valueType.name());
}
#ifdef QTRO_VERBOSE_PROTOCOL
qDebug("Serializing POD sequence to QSQ_ (type = %s, valueType = %s) with size = %lld",
typeName.constData(), valueTypeName.constData(), sequence.size());
#endif
QDataStream ds(&values, QIODevice::WriteOnly);
ds << valueTypeName;
auto pos = ds.device()->pos();
ds << quint32(sequence.size());
for (const auto &v : sequence) {
if (!valueType.save(ds, v.data())) {
ds.device()->seek(pos);
ds.resetStatus();
ds << quint32(0);
values.resize(ds.device()->pos());
qWarning("QSQ_: unable to save type '%s', sending empty list.", valueType.name());
break;
}
}
}
QDataStream &operator<<(QDataStream &stream, const QSQ_ &sequence)
{
stream << sequence.typeName << sequence.valueTypeName << sequence.values;
qCDebug(QT_REMOTEOBJECT) << "Serializing " << sequence;
return stream;
}
QDataStream &operator>>(QDataStream &stream, QSQ_ &sequence)
{
stream >> sequence.typeName >> sequence.valueTypeName >> sequence.values;
qCDebug(QT_REMOTEOBJECT) << "Deserializing " << sequence;
return stream;
}
QAS_::QAS_(const QVariant &variant)
{
QMetaAssociation::Iterable map;
QMetaType keyType, transferType, valueType;
const QtROAssociativeContainer *container = nullptr;
if (variant.metaType() == QMetaType::fromType<QtROAssociativeContainer>()) {
container = static_cast<const QtROAssociativeContainer *>(variant.constData());
typeName = container->m_typeName;
keyType = container->m_keyType;
keyTypeName = container->m_keyTypeName;
valueType = container->m_valueType;
valueTypeName = container->m_valueTypeName;
map = QMetaAssociation::Iterable(reinterpret_cast<const QVariantMap *>(variant.constData()));
} else {
map = variant.value<QMetaAssociation::Iterable>();
typeName = QByteArray(variant.metaType().name());
keyType = map.metaContainer().keyMetaType();
keyTypeName = QByteArray(keyType.name());
valueType = map.metaContainer().mappedMetaType();
valueTypeName = QByteArray(valueType.name());
}
// Special handling for enums...
transferType = keyType;
if (keyType.flags().testFlag(QMetaType::IsEnumeration)) {
transferType = transferTypeForEnum(keyType);
auto meta = keyType.metaObject();
// If we are the source, make sure the typeName is converted for any downstream replicas
// the `meta` variable will be non-null when the enum is a class enum
if (meta && !container) {
const int ind = meta->indexOfClassInfo(QCLASSINFO_REMOTEOBJECT_TYPE);
if (ind >= 0) {
bool isFlag = keyTypeName.startsWith("QFlags<");
if (isFlag || keyTypeName.startsWith(meta->className())) {
#ifdef QTRO_VERBOSE_PROTOCOL
QByteArray orig(keyTypeName);
#endif
if (isFlag) {
// Q_DECLARE_FLAGS(Flags, Enum) -> `typedef QFlags<Enum> Flags;`
// We know we have an enum for `Flags` because we sent the enums
// from the source, so we just need to look up the alias.
keyTypeName = keyTypeName.mid(7);
keyTypeName.chop(1); // Remove trailing '>'
int index = keyTypeName.lastIndexOf(':');
for (int i = meta->enumeratorOffset(); i < meta->enumeratorCount(); i++) {
auto en = meta->enumerator(i);
auto name = keyTypeName.data() + index + 1;
if (en.isFlag() && qstrcmp(en.enumName(), name) == 0)
keyTypeName.replace(index + 1, qstrlen(en.enumName()), en.name());
}
}
keyTypeName.replace(meta->className(), meta->classInfo(ind).value());
QByteArray repName(meta->classInfo(ind).value());
repName.append("Replica");
typeName.replace(meta->className(), repName);
#ifdef QTRO_VERBOSE_PROTOCOL
qDebug() << "Converted map key typename from" << orig << "to" << keyTypeName;
#endif
}
}
}
}
#ifdef QTRO_VERBOSE_PROTOCOL
qDebug("Serializing POD map to QAS_ (type = %s, keyType = %s, valueType = %s), size = %lld",
typeName.constData(), keyTypeName.constData(), valueTypeName.constData(),
map.size());
#endif
QDataStream ds(&values, QIODevice::WriteOnly);
ds << keyTypeName;
ds << valueTypeName;
auto pos = ds.device()->pos();
ds << quint32(map.size());
QMetaAssociation::Iterable::const_iterator iter = map.begin();
for (int i = 0; i < map.size(); i++) {
QVariant key(container ? container->m_keys.at(i) : iter.key());
if (transferType != keyType)
key.convert(transferType);
if (!transferType.save(ds, key.data())) {
ds.device()->seek(pos);
ds.resetStatus();
ds << quint32(0);
values.resize(ds.device()->pos());
qWarning("QAS_: unable to save key '%s', sending empty map.", keyType.name());
break;
}
if (!valueType.save(ds, iter.value().data())) {
ds.device()->seek(pos);
ds.resetStatus();
ds << quint32(0);
values.resize(ds.device()->pos());
qWarning("QAS_: unable to save value '%s', sending empty map.", valueType.name());
break;
}
iter++;
}
}
QDataStream &operator<<(QDataStream &stream, const QAS_ &map)
{
stream << map.typeName << map.keyTypeName << map.valueTypeName << map.values;
qCDebug(QT_REMOTEOBJECT) << "Serializing " << map;
return stream;
}
QDataStream &operator>>(QDataStream &stream, QAS_ &map)
{
stream >> map.typeName >> map.keyTypeName >> map.valueTypeName >> map.values;
qCDebug(QT_REMOTEOBJECT) << "Deserializing " << map;
return stream;
}
DataStreamPacket::DataStreamPacket(quint16 id)
: QDataStream(&array, QIODevice::WriteOnly), baseAddress(0), size(0)
{
this->setVersion(QtRemoteObjects::dataStreamVersion);
this->setByteOrder(QDataStream::LittleEndian);
*this << quint32(0);
*this << id;
}
void CodecBase::send(const QSet<QtROIoDeviceBase *> &connections)
{
const auto bytearray = getPayload();
for (auto conn : connections)
conn->write(bytearray);
reset();
}
void CodecBase::send(const QList<QtROIoDeviceBase *> &connections)
{
const auto bytearray = getPayload();
for (auto conn : connections)
conn->write(bytearray);
reset();
}
void CodecBase::send(QtROIoDeviceBase *connection)
{
const auto bytearray = getPayload();
connection->write(bytearray);
reset();
}
} // namespace QRemoteObjectPackets
QT_IMPL_METATYPE_EXTERN_TAGGED(QRemoteObjectPackets::QRO_, QRemoteObjectPackets__QRO_)
QT_END_NAMESPACE