// Copyright (C) 2016 The Qt Company Ltd.

// Copyright (C) 2016 Intel Corporation.

// 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:default

#include "qdbusmetaobject_p.h"

#include <QtCore/qbytearray.h>

#include <QtCore/qhash.h>

#include <QtCore/qstring.h>

#include <QtCore/qvarlengtharray.h>

#include "qdbusutil_p.h"

#include "qdbuserror.h"

#include "qdbusmetatype.h"

#include "qdbusargument.h"

#include "qdbusintrospection_p.h"

#include "qdbusabstractinterface_p.h"

#include <private/qmetaobject_p.h>

#include <private/qmetaobjectbuilder_p.h>

#ifndef QT_NO_DBUS

QT_BEGIN_NAMESPACE

using namespace Qt::StringLiterals;

class QDBusMetaObjectGenerator

{

public:

    QDBusMetaObjectGenerator(const QString &interface,

                             const QDBusIntrospection::Interface *parsedData);

    void write(QDBusMetaObject *obj);

    void writeWithoutXml(QDBusMetaObject *obj);

private:

    struct Method {

        QList<QByteArray> parameterNames;

        QByteArray tag;

        QByteArray name;

        QVarLengthArray<int, 4> inputTypes;

        QVarLengthArray<int, 4> outputTypes;

        QByteArray rawReturnType;

        quint32 flags;

    };

    struct Property {

        QByteArray typeName;

        QByteArray signature;

        int type;

        quint32 flags;

    };

    struct Type {

        int id;

        QByteArray name;

    };

    using MethodMap = QMap<QByteArray, Method>;

    MethodMap signals_;

    MethodMap methods;

    QMap<QByteArray, Property> properties;

    const QDBusIntrospection::Interface *data;

    QString interface;

    Type findType(const QByteArray &signature,

                  const QDBusIntrospection::Annotations &annotations,

                  const char *direction = "Out", int id = -1);

    void parseMethods();

    void parseSignals();

    void parseProperties();

    static qsizetype aggregateParameterCount(const MethodMap &map);

};

static const qsizetype intsPerProperty = 2;

static const qsizetype intsPerMethod = 2;

struct QDBusMetaObjectPrivate : public QMetaObjectPrivate

{

    int propertyDBusData;

    int methodDBusData;

};

QDBusMetaObjectGenerator::QDBusMetaObjectGenerator(const QString &interfaceName,

                                                   const QDBusIntrospection::Interface *parsedData)

    : data(parsedData), interface(interfaceName)

{

    if (data) {

        parseProperties();

        parseSignals();             // call parseSignals first so that slots override signals

        parseMethods();

    }

}

static int registerComplexDBusType(const QByteArray &typeName)

{

    struct QDBusRawTypeHandler : QtPrivate::QMetaTypeInterface

    {

        const QByteArray name;

        QDBusRawTypeHandler(const QByteArray &name)

            : QtPrivate::QMetaTypeInterface {

                0, sizeof(void *), sizeof(void *), QMetaType::RelocatableType, 0, nullptr,

                name.constData(),

                nullptr, nullptr, nullptr, nullptr,

                nullptr, nullptr, nullptr,

                nullptr, nullptr, nullptr

            },

            name(name)

        {}

    };

    Q_CONSTINIT static QBasicMutex mutex;

    Q_CONSTINIT static struct Hash : QHash<QByteArray, QMetaType>

    {

        ~Hash()

        {

            for (QMetaType entry : std::as_const(*this)) {

                QMetaType::unregisterMetaType(entry);

                delete static_cast<const QDBusRawTypeHandler *>(entry.iface());

            }

        }

    } hash;

    QMutexLocker lock(&mutex);

    QMetaType &metatype = hash[typeName];

    if (!metatype.isValid())

        metatype = QMetaType(new QDBusRawTypeHandler(typeName));

    return metatype.id();

}

Q_DBUS_EXPORT bool qt_dbus_metaobject_skip_annotations = false;

QDBusMetaObjectGenerator::Type

QDBusMetaObjectGenerator::findType(const QByteArray &signature,

                                   const QDBusIntrospection::Annotations &annotations,

                                   const char *direction, int id)

{

    Type result;

    result.id = QMetaType::UnknownType;

    int type = QDBusMetaType::signatureToMetaType(signature).id();

    if (type == QMetaType::UnknownType && !qt_dbus_metaobject_skip_annotations) {

        // it's not a type normally handled by our meta type system

        // it must contain an annotation

        QString annotationName = QString::fromLatin1("org.qtproject.QtDBus.QtTypeName");

        if (id >= 0)

            annotationName += QString::fromLatin1(".%1%2")

                              .arg(QLatin1StringView(direction))

                              .arg(id);

        // extract from annotations:

        auto annotation = annotations.value(annotationName);

        QByteArray typeName = annotation.value.toLatin1();

        // verify that it's a valid one

        if (typeName.isEmpty()) {

            // try the old annotation from Qt 4

            annotationName = QString::fromLatin1("com.trolltech.QtDBus.QtTypeName");

            if (id >= 0)

                annotationName += QString::fromLatin1(".%1%2")

                                  .arg(QLatin1StringView(direction))

                                  .arg(id);

            annotation = annotations.value(annotationName);

            typeName = annotation.value.toLatin1();

        }

        if (!typeName.isEmpty()) {

            // type name found

            type = QMetaType::fromName(typeName).id();

        }

        if (type == QMetaType::UnknownType || signature != QDBusMetaType::typeToSignature(QMetaType(type))) {

            // type is still unknown or doesn't match back to the signature that it

            // was expected to, so synthesize a fake type

            typeName = "QDBusRawType<0x" + signature.toHex() + ">*";

            Q_ASSERT(typeName == QMetaObject::normalizedType(typeName));

            type = registerComplexDBusType(typeName);

        }

        result.name = typeName;

    } else if (type == QMetaType::UnknownType) {

        // this case is used only by the qdbus command-line tool

        // invalid, let's create an impossible type that contains the signature

        if (signature == "a{sv}") {

            result.name = "QVariantMap";

            type = QMetaType::QVariantMap;

        } else if (signature == "a{ss}") {

            result.name = "QMap<QString,QString>";

            type = qMetaTypeId<QMap<QString, QString> >();

        } else if (signature == "aay") {

            result.name = "QByteArrayList";

            type = qMetaTypeId<QByteArrayList>();

        } else {

            result.name = "{D-Bus type \"" + signature + "\"}";

            result.name = QMetaObject::normalizedType(result.name);

            type = registerComplexDBusType(result.name);

        }

    } else {

        result.name = QMetaType(type).name();

    }

    result.id = type;

    return result;              // success

}

void QDBusMetaObjectGenerator::parseMethods()

{

    //

    // TODO:

    //  Add cloned methods when the remote object has return types

    //

    for (const QDBusIntrospection::Method &m : std::as_const(data->methods)) {

        Method mm;

        mm.name = m.name.toLatin1();

        QByteArray prototype = mm.name;

        prototype += '(';

        bool ok = true;

        // build the input argument list

        for (qsizetype i = 0; i < m.inputArgs.size(); ++i) {

            const QDBusIntrospection::Argument &arg = m.inputArgs.at(i);

            Type type = findType(arg.type.toLatin1(), m.annotations, "In", i);

            if (type.id == QMetaType::UnknownType) {

                ok = false;

                break;

            }

            mm.inputTypes.append(type.id);

            mm.parameterNames.append(arg.name.toLatin1());

            prototype.append(type.name);

            prototype.append(',');

        }

        if (!ok) continue;

        // build the output argument list:

        for (qsizetype i = 0; i < m.outputArgs.size(); ++i) {

            const QDBusIntrospection::Argument &arg = m.outputArgs.at(i);

            Type type = findType(arg.type.toLatin1(), m.annotations, "Out", i);

            if (type.id == QMetaType::UnknownType) {

                ok = false;

                break;

            }

            mm.outputTypes.append(type.id);

            if (i == 0 && type.id == -1) {

                mm.rawReturnType = type.name;

            }

            if (i != 0) {

                // non-const ref parameter

                mm.parameterNames.append(arg.name.toLatin1());

                prototype.append(type.name);

                prototype.append("&,");

            }

        }

        if (!ok) continue;

        // convert the last commas:

        if (!mm.parameterNames.isEmpty())

            prototype[prototype.size() - 1] = ')';

        else

            prototype.append(')');

        // check the async tag

        if (m.annotations.value(ANNOTATION_NO_WAIT ""_L1).value == "true"_L1)

            mm.tag = "Q_NOREPLY";

        // meta method flags

        mm.flags = AccessPublic | MethodSlot | MethodScriptable;

        // add

        methods.insert(QMetaObject::normalizedSignature(prototype), mm);

    }

}

void QDBusMetaObjectGenerator::parseSignals()

{

    for (const QDBusIntrospection::Signal &s : std::as_const(data->signals_)) {

        Method mm;

        mm.name = s.name.toLatin1();

        QByteArray prototype = mm.name;

        prototype += '(';

        bool ok = true;

        // build the output argument list

        for (qsizetype i = 0; i < s.outputArgs.size(); ++i) {

            const QDBusIntrospection::Argument &arg = s.outputArgs.at(i);

            Type type = findType(arg.type.toLatin1(), s.annotations, "Out", i);

            if (type.id == QMetaType::UnknownType) {

                ok = false;

                break;

            }

            mm.inputTypes.append(type.id);

            mm.parameterNames.append(arg.name.toLatin1());

            prototype.append(type.name);

            prototype.append(',');

        }

        if (!ok) continue;

        // convert the last commas:

        if (!mm.parameterNames.isEmpty())

            prototype[prototype.size() - 1] = ')';

        else

            prototype.append(')');

        // meta method flags

        mm.flags = AccessPublic | MethodSignal | MethodScriptable;

        // add

        signals_.insert(QMetaObject::normalizedSignature(prototype), mm);

    }

}

void QDBusMetaObjectGenerator::parseProperties()

{

    for (const QDBusIntrospection::Property &p : std::as_const(data->properties)) {

        Property mp;

        Type type = findType(p.type.toLatin1(), p.annotations);

        if (type.id == QMetaType::UnknownType)

            continue;

        QByteArray name = p.name.toLatin1();

        mp.signature = p.type.toLatin1();

        mp.type = type.id;

        mp.typeName = type.name;

        // build the flags:

        mp.flags = StdCppSet | Scriptable | Stored | Designable;

        if (p.access != QDBusIntrospection::Property::Write)

            mp.flags |= Readable;

        if (p.access != QDBusIntrospection::Property::Read)

            mp.flags |= Writable;

        // add the property:

        properties.insert(name, mp);

    }

}

// Returns the sum of all parameters (including return type) for the given

// \a map of methods. This is needed for calculating the size of the methods'

// parameter type/name meta-data.

qsizetype QDBusMetaObjectGenerator::aggregateParameterCount(const MethodMap &map)

{

    qsizetype sum = 0;

    for (const Method &m : map)

        sum += m.inputTypes.size() + qMax(qsizetype(1), m.outputTypes.size());

    return sum;

}

void QDBusMetaObjectGenerator::write(QDBusMetaObject *obj)

{

    // this code here is mostly copied from qaxbase.cpp

    // with a few modifications to make it cleaner

    QString className = interface;

    className.replace(u'.', "::"_L1);

    if (className.isEmpty())

        className = "QDBusInterface"_L1;

    QVarLengthArray<uint> idata;

    idata.resize(sizeof(QDBusMetaObjectPrivate) / sizeof(uint));

    qsizetype methodParametersDataSize =

            ((aggregateParameterCount(signals_)

             + aggregateParameterCount(methods)) * 2) // types and parameter names

            - signals_.size() // return "parameters" don't have names

            - methods.size(); // ditto

    QDBusMetaObjectPrivate *header = reinterpret_cast<QDBusMetaObjectPrivate *>(idata.data());

    static_assert(QMetaObjectPrivate::OutputRevision == 13, "QtDBus meta-object generator should generate the same version as moc");

    header->revision = QMetaObjectPrivate::OutputRevision;

    header->className = 0;

    header->classInfoCount = 0;

    header->classInfoData = 0;

    header->methodCount = int(signals_.size() + methods.size());

    header->methodData = int(idata.size());

    header->propertyCount = int(properties.size());

    header->propertyData = int(header->methodData + header->methodCount *

                               QMetaObjectPrivate::IntsPerMethod + methodParametersDataSize);

    header->enumeratorCount = 0;

    header->enumeratorData = 0;

    header->constructorCount = 0;

    header->constructorData = 0;

    header->flags = RequiresVariantMetaObject | AllocatedMetaObject;

    header->signalCount = signals_.size();

    // These are specific to QDBusMetaObject:

    header->propertyDBusData = int(header->propertyData + header->propertyCount

                                   * QMetaObjectPrivate::IntsPerProperty);

    header->methodDBusData = int(header->propertyDBusData + header->propertyCount * intsPerProperty);

    qsizetype data_size = idata.size() +

                    (header->methodCount * (QMetaObjectPrivate::IntsPerMethod+intsPerMethod)) + methodParametersDataSize +

                    (header->propertyCount * (QMetaObjectPrivate::IntsPerProperty+intsPerProperty));

    // Signals must be added before other methods, to match moc.

    std::array<std::reference_wrapper<const MethodMap>, 2> methodMaps = { signals_, methods };

    for (const auto &methodMap : methodMaps) {

        for (const Method &mm : methodMap.get())

            data_size += 2 + mm.inputTypes.size() + mm.outputTypes.size();

    }

    idata.resize(data_size + 1);

    QMetaStringTable strings(className.toLatin1());

    qsizetype offset = header->methodData;

    qsizetype parametersOffset = offset + header->methodCount * QMetaObjectPrivate::IntsPerMethod;

    qsizetype signatureOffset = header->methodDBusData;

    qsizetype typeidOffset = header->methodDBusData + header->methodCount * intsPerMethod;

    idata[typeidOffset++] = 0;                           // eod

    qsizetype totalMetaTypeCount = properties.size();

    ++totalMetaTypeCount; // + 1 for metatype of dynamic metaobject

    for (const auto &methodMap : methodMaps) {

        for (const Method &mm : methodMap.get()) {

            qsizetype argc = mm.inputTypes.size() + qMax(qsizetype(0), mm.outputTypes.size() - 1);

            totalMetaTypeCount += argc + 1;

        }

    }

    QMetaType *metaTypes = new QMetaType[totalMetaTypeCount];

    int propertyId = 0;

    // add each method:

    qsizetype currentMethodMetaTypeOffset = properties.size() + 1;

    for (const auto &methodMap : methodMaps) {

        for (const Method &mm : methodMap.get()) {

            qsizetype argc = mm.inputTypes.size() + qMax(qsizetype(0), mm.outputTypes.size() - 1);

            idata[offset++] = strings.enter(mm.name);

            idata[offset++] = argc;

            idata[offset++] = parametersOffset;

            idata[offset++] = strings.enter(mm.tag);

            idata[offset++] = mm.flags;

            idata[offset++] = currentMethodMetaTypeOffset;

            // Parameter types

            for (qsizetype i = -1; i < argc; ++i) {

                int type;

                QByteArray typeName;

                if (i < 0) { // Return type

                    if (!mm.outputTypes.isEmpty()) {

                        type = mm.outputTypes.first();

                        if (type == -1) {

                            type = IsUnresolvedType | strings.enter(mm.rawReturnType);

                        }

                    } else {

                        type = QMetaType::Void;

                    }

                } else if (i < mm.inputTypes.size()) {

                    type = mm.inputTypes.at(i);

                } else {

                    Q_ASSERT(mm.outputTypes.size() > 1);

                    type = mm.outputTypes.at(i - mm.inputTypes.size() + 1);

                    // Output parameters are references; type id not available

                    typeName = QMetaType(type).name();

                    typeName.append('&');

                    type = QMetaType::UnknownType;

                }

                int typeInfo;

                if (!typeName.isEmpty())

                    typeInfo = IsUnresolvedType | strings.enter(typeName);

                else

                    typeInfo = type;

                metaTypes[currentMethodMetaTypeOffset++] = QMetaType(type);

                idata[parametersOffset++] = typeInfo;

            }

            // Parameter names

            for (qsizetype i = 0; i < argc; ++i)

                idata[parametersOffset++] = strings.enter(mm.parameterNames.at(i));

            idata[signatureOffset++] = typeidOffset;

            idata[typeidOffset++] = mm.inputTypes.size();

            memcpy(idata.data() + typeidOffset, mm.inputTypes.data(), mm.inputTypes.size() * sizeof(uint));

            typeidOffset += mm.inputTypes.size();

            idata[signatureOffset++] = typeidOffset;

            idata[typeidOffset++] = mm.outputTypes.size();

            memcpy(idata.data() + typeidOffset, mm.outputTypes.data(), mm.outputTypes.size() * sizeof(uint));

            typeidOffset += mm.outputTypes.size();

        }

    }

    Q_ASSERT(offset == header->methodData + header->methodCount * QMetaObjectPrivate::IntsPerMethod);

    Q_ASSERT(parametersOffset == header->propertyData);

    Q_ASSERT(signatureOffset == header->methodDBusData + header->methodCount * intsPerMethod);

    Q_ASSERT(typeidOffset == idata.size());

    offset += methodParametersDataSize;

    Q_ASSERT(offset == header->propertyData);

    // add each property

    signatureOffset = header->propertyDBusData;

    for (const auto &[name, mp] : std::as_const(properties).asKeyValueRange()) {

        // form is name, typeinfo, flags

        idata[offset++] = strings.enter(name);

        Q_ASSERT(mp.type != QMetaType::UnknownType);

        idata[offset++] = mp.type;

        idata[offset++] = mp.flags;

        idata[offset++] = -1; // notify index

        idata[offset++] = 0; // revision

        idata[signatureOffset++] = strings.enter(mp.signature);

        idata[signatureOffset++] = mp.type;

        metaTypes[propertyId++] = QMetaType(mp.type);

    }

    metaTypes[propertyId] = QMetaType(); // we can't know our own metatype

    Q_ASSERT(offset == header->propertyDBusData);

    Q_ASSERT(signatureOffset == header->methodDBusData);

    char *string_data = new char[strings.blobSize()];

    strings.writeBlob(string_data);

    uint *uint_data = new uint[idata.size()];

    memcpy(uint_data, idata.data(), idata.size() * sizeof(uint));

    // put the metaobject together

    obj->d.data = uint_data;

    obj->d.relatedMetaObjects = nullptr;

    obj->d.static_metacall = nullptr;

    obj->d.extradata = nullptr;

    obj->d.stringdata = reinterpret_cast<const uint *>(string_data);

    obj->d.superdata = &QDBusAbstractInterface::staticMetaObject;

    obj->d.metaTypes = reinterpret_cast<QtPrivate::QMetaTypeInterface *const *>(metaTypes);

}

#if 0

void QDBusMetaObjectGenerator::writeWithoutXml(const QString &interface)

{

    // no XML definition

    QString tmp(interface);

    tmp.replace(u'.', "::"_L1);

    QByteArray name(tmp.toLatin1());

    QDBusMetaObjectPrivate *header = new QDBusMetaObjectPrivate;

    memset(header, 0, sizeof *header);

    header->revision = 1;

    // leave the rest with 0

    char *stringdata = new char[name.length() + 1];

    stringdata[name.length()] = '\0';

    d.data = reinterpret_cast<uint*>(header);

    d.relatedMetaObjects = 0;

    d.static_metacall = 0;

    d.extradata = 0;

    d.stringdata = stringdata;

    d.superdata = &QDBusAbstractInterface::staticMetaObject;

    cached = false;

}

#endif

/////////

// class QDBusMetaObject

QDBusMetaObject *QDBusMetaObject::createMetaObject(const QString &interface, const QString &xml,

                                                   QHash<QString, QDBusMetaObject *> &cache,

                                                   QDBusError &error)

{

    error = QDBusError();

    QDBusIntrospection::Interfaces parsed = QDBusIntrospection::parseInterfaces(xml);

    QDBusMetaObject *we = nullptr;

    QDBusIntrospection::Interfaces::ConstIterator it = parsed.constBegin();

    QDBusIntrospection::Interfaces::ConstIterator end = parsed.constEnd();

    for ( ; it != end; ++it) {

        // check if it's in the cache

        bool us = it.key() == interface;

        QDBusMetaObject *obj = cache.value(it.key(), 0);

        if (!obj && (us || !interface.startsWith("local."_L1 ))) {

            // not in cache; create

            obj = new QDBusMetaObject;

            QDBusMetaObjectGenerator generator(it.key(), it.value().constData());

            generator.write(obj);

            if ((obj->cached = !it.key().startsWith("local."_L1)))

                // cache it

                cache.insert(it.key(), obj);

            else if (!us)

                delete obj;

        }

        if (us)

            // it's us

            we = obj;

    }

    if (we)

        return we;

    // still nothing?

    if (parsed.isEmpty()) {

        // object didn't return introspection

        we = new QDBusMetaObject;

        QDBusMetaObjectGenerator generator(interface, nullptr);

        generator.write(we);

        we->cached = false;

        return we;

    } else if (interface.isEmpty()) {

        // merge all interfaces

        it = parsed.constBegin();

        QDBusIntrospection::Interface merged = *it.value().constData();

        for (++it; it != end; ++it) {

            merged.annotations.insert(it.value()->annotations);

            merged.methods.unite(it.value()->methods);

            merged.signals_.unite(it.value()->signals_);

            merged.properties.insert(it.value()->properties);

        }

        merged.name = "local.Merged"_L1;

        merged.introspection.clear();

        we = new QDBusMetaObject;

        QDBusMetaObjectGenerator generator(merged.name, &merged);

        generator.write(we);

        we->cached = false;

        return we;

    }

    // mark as an error

    error = QDBusError(QDBusError::UnknownInterface,

                       "Interface '%1' was not found"_L1.arg(interface));

    return nullptr;

}

QDBusMetaObject::QDBusMetaObject()

{

}

static inline const QDBusMetaObjectPrivate *priv(const uint* data)

{

    return reinterpret_cast<const QDBusMetaObjectPrivate *>(data);

}

const int *QDBusMetaObject::inputTypesForMethod(int id) const

{

    //id -= methodOffset();

    if (id >= 0 && id < priv(d.data)->methodCount) {

        int handle = priv(d.data)->methodDBusData + id*intsPerMethod;

        return reinterpret_cast<const int*>(d.data + d.data[handle]);

    }

    return nullptr;

}

const int *QDBusMetaObject::outputTypesForMethod(int id) const

{

    //id -= methodOffset();

    if (id >= 0 && id < priv(d.data)->methodCount) {

        int handle = priv(d.data)->methodDBusData + id*intsPerMethod;

        return reinterpret_cast<const int*>(d.data + d.data[handle + 1]);

    }

    return nullptr;

}

int QDBusMetaObject::propertyMetaType(int id) const

{

    //id -= propertyOffset();

    if (id >= 0 && id < priv(d.data)->propertyCount) {

        int handle = priv(d.data)->propertyDBusData + id*intsPerProperty;

        return d.data[handle + 1];

    }

    return 0;

}

QT_END_NAMESPACE

#endif // QT_NO_DBUS