// Copyright (C) 2016 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:significant reason:default

#include <string.h>

#ifndef QT_BOOTSTRAPPED

#include <QtCore/qcoreapplication.h>

#include <QtCore/qlist.h>

#include <QtCore/qmetaobject.h>

#include <QtCore/qvariant.h>

#include <private/qurl_p.h>

#include "qdbusutil_p.h"

#include "qdbusconnection_p.h"

#include "qdbusabstractadaptor_p.h" // for QCLASSINFO_DBUS_*

#endif

#include "qdbusmetatype_p.h"

#ifndef QT_NO_DBUS

QT_BEGIN_NAMESPACE

using namespace Qt::StringLiterals;

bool qDBusCheckAsyncTag(const char *tag)

{

    static const char noReplyTag[] = "Q_NOREPLY";

    if (!tag || !*tag)

        return false;

    const char *p = strstr(tag, noReplyTag);

    if (p != nullptr &&

        (p == tag || *(p-1) == ' ') &&

        (p[sizeof noReplyTag - 1] == '\0' || p[sizeof noReplyTag - 1] == ' '))

        return true;

    return false;

}

#ifndef QT_BOOTSTRAPPED

QString qDBusInterfaceFromMetaObject(const QMetaObject *mo)

{

    QString interface;

    int idx = mo->indexOfClassInfo(QCLASSINFO_DBUS_INTERFACE);

    if (idx >= mo->classInfoOffset()) {

        interface = QLatin1StringView(mo->classInfo(idx).value());

    } else {

        interface = QLatin1StringView(mo->className());

        interface.replace("::"_L1, "."_L1);

        if (interface.startsWith("QDBus"_L1)) {

            interface.prepend("org.qtproject.QtDBus."_L1);

        } else if (interface.startsWith(u'Q') &&

                   interface.size() >= 2 && interface.at(1).isUpper()) {

            // assume it's Qt

            interface.prepend("org.qtproject.Qt."_L1);

        } else if (!QCoreApplication::instance()||

                   QCoreApplication::instance()->applicationName().isEmpty()) {

            interface.prepend("local."_L1);

        } else {

            QString domainName = QCoreApplication::instance()->applicationName();

            const QString organizationDomain = QCoreApplication::instance()->organizationDomain();

            if (organizationDomain.isEmpty())

                domainName.append(".local"_L1);

            else

                domainName.append(u'.').append(organizationDomain);

            // Domain names used to produce interface names should be IDN-encoded.

            QString encodedDomainName = qt_ACE_do(domainName, ToAceOnly, ForbidLeadingDot);

            if (encodedDomainName.isEmpty()) {

                interface.prepend("local."_L1);

                return interface;

            }

            // Hyphens are not allowed in interface names and should be replaced

            // by underscores.

            encodedDomainName.replace(u'-', u'_');

            auto nameParts = QStringView{ encodedDomainName }.split(u'.', Qt::SkipEmptyParts);

            QString composedDomain;

            // + 1 for additional dot, e.g. domainName equals "App.example.com",

            // then composedDomain will be equal "com.example.App."

            composedDomain.reserve(encodedDomainName.size() + nameParts.size() + 1);

            for (auto it = nameParts.rbegin(), end = nameParts.rend(); it != end; ++it) {

                // An interface name cannot start with a digit, and cannot

                // contain digits immediately following a period. Prefix such

                // digits with underscores.

                if (it->first().isDigit())

                    composedDomain += u'_';

                composedDomain += *it + u'.';

            }

            interface.prepend(composedDomain);

        }

     }

    return interface;

}

bool qDBusInterfaceInObject(QObject *obj, const QString &interface_name)

{

    const QMetaObject *mo = obj->metaObject();

    for ( ; mo != &QObject::staticMetaObject; mo = mo->superClass())

        if (interface_name == qDBusInterfaceFromMetaObject(mo))

            return true;

    return false;

}

// calculates the metatypes for the method

// the slot must have the parameters in the following form:

//  - zero or more value or const-ref parameters of any kind

//  - zero or one const ref of QDBusMessage

//  - zero or more non-const ref parameters

// No parameter may be a template.

// this function returns -1 if the parameters don't match the above form

// this function returns the number of *input* parameters, including the QDBusMessage one if any

// this function does not check the return type, so metaTypes[0] is always 0 and always present

// metaTypes.count() >= retval + 1 in all cases

//

// sig must be the normalised signature for the method

int qDBusParametersForMethod(const QMetaMethod &mm, QList<QMetaType> &metaTypes, QString &errorMsg)

{

    QList<QByteArray> parameterTypes;

    parameterTypes.reserve(mm.parameterCount());

    // Not using QMetaMethod::parameterTypes() since we call QMetaType::fromName below

    // where we need any typedefs resolved already.

    for (int i = 0; i < mm.parameterCount(); ++i) {

        QByteArray typeName = mm.parameterMetaType(i).name();

        if (typeName.isEmpty())

            typeName = mm.parameterTypeName(i);

        parameterTypes.append(typeName);

    }

    return qDBusParametersForMethod(parameterTypes, metaTypes, errorMsg);

}

#endif // QT_BOOTSTRAPPED

int qDBusParametersForMethod(const QList<QByteArray> &parameterTypes, QList<QMetaType> &metaTypes,

                             QString &errorMsg)

{

    QDBusMetaTypeId::init();

    metaTypes.clear();

    metaTypes.append(QMetaType());        // return type

    int inputCount = 0;

    bool seenMessage = false;

    for (QByteArray type : parameterTypes) {

        if (type.endsWith('*')) {

            errorMsg = "Pointers are not supported: "_L1 + QLatin1StringView(type);

            return -1;

        }

        if (type.endsWith('&')) {

            QByteArray basictype = type;

            basictype.truncate(type.size() - 1);

            QMetaType id = QMetaType::fromName(basictype);

            if (!id.isValid()) {

                errorMsg = "Unregistered output type in parameter list: "_L1 + QLatin1StringView(type);

                return -1;

            } else if (QDBusMetaType::typeToSignature(id) == nullptr)

                return -1;

            metaTypes.append(id);

            seenMessage = true; // it cannot appear anymore anyways

            continue;

        }

        if (seenMessage) {      // && !type.endsWith('&')

            errorMsg = "Invalid method, non-output parameters after message or after output parameters: "_L1 + QLatin1StringView(type);

            return -1;          // not allowed

        }

        if (type.startsWith("QVector<"))

            type = "QList<" + type.mid(sizeof("QVector<") - 1);

        QMetaType id = QMetaType::fromName(type);

#ifdef QT_BOOTSTRAPPED

        // in bootstrap mode QDBusMessage isn't included, thus we need to resolve it manually here

        if (type == "QDBusMessage") {

            id = QDBusMetaTypeId::message();

        }

#endif

        if (!id.isValid()) {

            errorMsg = "Unregistered input type in parameter list: "_L1 + QLatin1StringView(type);

            return -1;

        }

        if (id == QDBusMetaTypeId::message())

            seenMessage = true;

        else if (QDBusMetaType::typeToSignature(id) == nullptr) {

            errorMsg = "Type not registered with QtDBus in parameter list: "_L1 + QLatin1StringView(type);

            return -1;

        }

        metaTypes.append(id);

        ++inputCount;

    }

    return inputCount;

}

QT_END_NAMESPACE

#endif // QT_NO_DBUS