Source code
Revision control
Copy as Markdown
// Copyright (C) 2024 The Qt Company Ltd.
// 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 <QtProtobuf/qprotobufpropertyordering.h>
#include <QtProtobuf/private/qprotobufpropertyorderingbuilder_p.h>
#include <QtProtobuf/private/qtprotobufdefs_p.h>
#include <QtProtobuf/private/qtprotobuflogging_p.h>
#include <QtProtobuf/qprotobufregistration.h>
#include <QtCore/q20utility.h>
#include <QtCore/qhash.h>
#include <QtCore/qmetatype.h>
#include <QtCore/qreadwritelock.h>
#include <QtCore/qstring.h>
#include <limits>
namespace {
/*!
\internal
The ProtobufOrderingRegistry stores the mapping between
QtProtobufPrivate::QProtobufPropertyOrdering and QMetaType.
*/
struct ProtobufOrderingRegistry
{
using ProtobufOrderingRegistryRecord =
std::pair<QMetaType, QtProtobufPrivate::QProtobufPropertyOrdering>;
void registerOrdering(QMetaType type, QtProtobufPrivate::QProtobufPropertyOrdering ordering)
{
QWriteLocker locker(&m_lock);
m_registry[ordering.messageFullName().toString()] =
ProtobufOrderingRegistryRecord(type, ordering);
}
QtProtobufPrivate::QProtobufPropertyOrdering getOrdering(QMetaType type) const
{
QtProtobufPrivate::QProtobufPropertyOrdering ordering{ nullptr };
QReadLocker locker(&m_lock);
for (auto it = m_registry.constBegin(); it != m_registry.constEnd(); ++it) {
if (type == it.value().first) {
ordering = it.value().second;
break;
}
}
return ordering;
}
ProtobufOrderingRegistryRecord
findMessageByName(const QString &messageName) const
{
ProtobufOrderingRegistryRecord record = {
QMetaType(QMetaType::UnknownType), { nullptr }
};
QReadLocker locker(&m_lock);
auto it = m_registry.constFind(messageName);
if (it != m_registry.constEnd())
record = it.value();
return record;
}
private:
mutable QReadWriteLock m_lock;
QHash<QString, ProtobufOrderingRegistryRecord> m_registry;
};
Q_GLOBAL_STATIC(ProtobufOrderingRegistry, orderingRegistry)
} // namespace
QT_BEGIN_NAMESPACE
namespace QtProtobufPrivate {
static_assert(std::is_trivially_destructible_v<QProtobufPropertyOrdering>);
static_assert(std::is_same_v<std::underlying_type_t<QtProtobufPrivate::FieldFlag>, uint>);
constexpr uint jsonNameOffsetsOffset = 0;
// Use this constant to make the +/- 1 more easily readable
constexpr int NullTerminator = 1;
QUtf8StringView QProtobufPropertyOrdering::messageFullName() const
{
Q_ASSERT(data);
const char *name = char_data();
return { name, qsizetype(data->fullPackageNameSize) };
}
QUtf8StringView QProtobufPropertyOrdering::jsonName(int index) const
{
Q_ASSERT(data);
if (Q_UNLIKELY(index < 0 || index >= fieldCount()))
return {}; // Invalid index (out of bounds)
const uint stringOffset = uint_dataForIndex(index, jsonNameOffsetsOffset);
const char *name = char_data() + stringOffset;
// This is fine because we store an extra offset for end-of-string
const uint nameLength =
uint_dataForIndex(index + 1, jsonNameOffsetsOffset) - NullTerminator - stringOffset;
return { name, qsizetype(nameLength) };
}
int QProtobufPropertyOrdering::fieldNumber(int index) const
{
Q_ASSERT(data);
if (Q_UNLIKELY(index < 0 || index >= fieldCount()))
return -1; // Invalid index (out of bounds)
uint fieldNumber = uint_dataForIndex(index, data->fieldNumberOffset);
if (Q_UNLIKELY(fieldNumber > uint(std::numeric_limits<int>::max())))
return -1;
return int(fieldNumber);
}
int QProtobufPropertyOrdering::propertyIndex(int index) const
{
Q_ASSERT(data);
if (Q_UNLIKELY(index < 0 || index >= fieldCount()))
return -1; // Invalid index (out of bounds)
uint propertyIndex = uint_dataForIndex(index, data->propertyIndexOffset);
if (Q_UNLIKELY(propertyIndex > uint(std::numeric_limits<int>::max())))
return -1;
return int(propertyIndex);
}
int QProtobufPropertyOrdering::indexOfFieldNumber(int fieldNumber) const
{
Q_ASSERT(data);
if (Q_LIKELY(fieldNumber > 0)) {
for (int i = 0; i < fieldCount(); ++i) {
if (uint_dataForIndex(i, data->fieldNumberOffset) == static_cast<uint>(fieldNumber))
return i;
}
}
return -1;
}
FieldFlags QProtobufPropertyOrdering::fieldFlags(int index) const
{
Q_ASSERT(data);
if (Q_UNLIKELY(index < 0 || index >= fieldCount()))
return {}; // Invalid index (out of bounds)
return FieldFlags { int(uint_dataForIndex(index, data->flagsOffset)) };
}
/*!
\internal
Access the generated uint* metadata of message properties.
[ Data, uint_data , char_data ] > Message_metadata
[ . . , ^ x x x x , . . . . . ]
*/
uint *QProtobufPropertyOrdering::uint_data(NonConstTag /*unused*/) const
{
Q_ASSERT(data);
Q_ASSERT(data->version == 0);
quintptr dataPtr = quintptr(data);
dataPtr += sizeof(Data);
#if 0 // if Data is ever not just a bunch of uints, remove the #if 0
if (dataPtr % alignof(uint) != 0)
dataPtr += alignof(uint) - (dataPtr % alignof(uint));
#else
static_assert(alignof(Data) == alignof(uint));
#endif
return reinterpret_cast<uint *>(dataPtr);
}
const uint *QProtobufPropertyOrdering::uint_data() const
{
return uint_data(NonConstTag{});
}
/*!
\internal
Access the generated char* metadata of message properties.
[ Data, uint_data , char_data ] > Message_metadata
[ . . , . . . . . , ^ x x x x ]
*/
char *QProtobufPropertyOrdering::char_data(NonConstTag /*unused*/) const
{
Q_ASSERT(data);
uint* uintDataPtr = uint_data(NonConstTag{});
// char_data starts after the last field flag (flagsOffset + numFields)
uint charDataOffset = data->flagsOffset + data->numFields;
return reinterpret_cast<char *>(uintDataPtr + charDataOffset);
}
const char *QProtobufPropertyOrdering::char_data() const
{
return char_data(NonConstTag{});
}
const uint &QProtobufPropertyOrdering::uint_dataForIndex(int index, uint offset) const
{
Q_ASSERT(data);
Q_ASSERT(index >= 0);
Q_ASSERT(uint(index) < data->numFields
|| (offset == jsonNameOffsetsOffset && uint(index) == data->numFields));
return *(uint_data() + offset + index);
}
void registerOrdering(QMetaType type, QProtobufPropertyOrdering ordering)
{
orderingRegistry->registerOrdering(type, ordering);
}
QProtobufPropertyOrdering getOrderingByMetaType(QMetaType type)
{
return orderingRegistry->getOrdering(type);
}
QProtobufMessagePointer constructMessageByName(const QString &messageType)
{
qRegisterProtobufTypes();
ProtobufOrderingRegistry::ProtobufOrderingRegistryRecord messageOrderingRecord =
orderingRegistry->findMessageByName(messageType);
QMetaType type = messageOrderingRecord.first;
QProtobufMessagePointer pointer;
if (type.id() != QMetaType::UnknownType) {
void *msg = type.create();
pointer.reset(static_cast<QProtobufMessage *>(msg));
return pointer;
}
qProtoWarning() << "Unable to find protobuf message with name" << messageType
<< ". Message is not registered.";
return pointer;
}
class QProtobufPropertyOrderingBuilderPrivate
{
public:
struct FieldDefinition
{
QByteArray jsonName;
uint fieldNumber;
uint propertyIndex;
FieldFlags flags;
};
std::vector<FieldDefinition> fields;
QByteArray packageName;
};
QProtobufPropertyOrderingBuilder::QProtobufPropertyOrderingBuilder(QByteArray packageName)
: d_ptr(new QProtobufPropertyOrderingBuilderPrivate())
{
d_ptr->packageName = std::move(packageName);
}
QProtobufPropertyOrderingBuilder::~QProtobufPropertyOrderingBuilder()
{
delete d_ptr;
}
void QProtobufPropertyOrderingBuilder::addV0Field(QByteArray jsonName, uint fieldNumber,
uint propertyIndex, FieldFlags flags)
{
Q_D(QProtobufPropertyOrderingBuilder);
Q_ASSERT_X(fieldNumber <= ProtobufFieldNumMax && fieldNumber >= ProtobufFieldNumMin,
"QProtobufPropertyOrderingBuilder::addV0Field",
"Field number is out of the valid field number range.");
Q_ASSERT(d->fields.size() < ProtobufFieldMaxCount);
d->fields.push_back({ std::move(jsonName), fieldNumber, propertyIndex, flags });
}
/*!
\internal
Builds the QProtobufPropertyOrdering object from the builder data.
The Data struct must be manually destructed (var->~Data()) and then
free()d by the caller.
*/
QProtobufPropertyOrdering::Data *QProtobufPropertyOrderingBuilder::build() const
{
Q_D(const QProtobufPropertyOrderingBuilder);
if (d->fields.size() > ProtobufFieldMaxCount)
return nullptr;
qsizetype charSpaceNeeded = NullTerminator + d->packageName.size() + NullTerminator;
for (const auto &field : d->fields)
charSpaceNeeded += field.jsonName.size() + NullTerminator;
const size_t uintSpaceNeeded = sizeof(QProtobufPropertyOrdering::Data)
+ d->fields.size() * sizeof(uint) * 4 + sizeof(uint) /* eos marker offset */;
static_assert(sizeof(QProtobufPropertyOrdering::Data) == 24,
"Data size changed, update builder code");
const size_t spaceNeeded = uintSpaceNeeded + charSpaceNeeded;
auto *storage = static_cast<char *>(calloc(1, spaceNeeded));
auto *data = new (storage) QProtobufPropertyOrdering::Data();
auto raii = qScopeGuard([data] { data->~Data(); free(data); });
data->version = 0u;
data->numFields = uint(d->fields.size());
data->fieldNumberOffset = uint(d->fields.size() * 1 + 1);
data->propertyIndexOffset = uint(d->fields.size() * 2 + 1);
data->flagsOffset = uint(d->fields.size() * 3 + 1);
data->fullPackageNameSize = uint(d->packageName.size());
using NonConstTag = QProtobufPropertyOrdering::NonConstTag;
QProtobufPropertyOrdering ordering{data};
uint *uintData = ordering.uint_data(NonConstTag{});
uint jsonArrayOffset = data->fullPackageNameSize + NullTerminator;
for (uint i = 0; i < data->numFields; ++i) {
const auto &field = d->fields[i];
if (field.fieldNumber > ProtobufFieldNumMax || field.fieldNumber < ProtobufFieldNumMin)
return nullptr;
uintData[i] = jsonArrayOffset;
jsonArrayOffset += field.jsonName.size() + NullTerminator;
uintData[i + data->fieldNumberOffset] = field.fieldNumber;
uintData[i + data->propertyIndexOffset] = field.propertyIndex;
uintData[i + data->flagsOffset] = uint(field.flags.toInt());
}
uintData[d->fields.size()] = jsonArrayOffset;
Q_ASSERT(q20::cmp_equal(jsonArrayOffset + NullTerminator, charSpaceNeeded));
char *charData = ordering.char_data(NonConstTag{});
[[maybe_unused]]
char * const charStart = charData;
charData = std::copy_n(d->packageName.constData(), d->packageName.size() + NullTerminator,
charData);
for (auto &field : d->fields) {
charData = std::copy_n(field.jsonName.constData(), field.jsonName.size() + NullTerminator,
charData);
}
charData[0] = '\0'; // Empty string at the end of the char array
++charData; // Trailing null terminator
Q_ASSERT(std::distance(charStart, charData) == charSpaceNeeded);
Q_ASSERT(quintptr(charData) - quintptr(data) == quintptr(spaceNeeded));
raii.dismiss();
return data;
}
} // namespace QtProtobufPrivate
QT_END_NAMESPACE