/* * Copyright (C) 2019 Aetf * Copyright 2010, Michael Leupold * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 2 or (at your option) * version 3 of the License. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see . */ #include "fdosecrets/objects/Collection.h" #include "fdosecrets/objects/Item.h" #include "fdosecrets/objects/Prompt.h" #include "fdosecrets/objects/Service.h" #include "fdosecrets/objects/Session.h" #include namespace FdoSecrets { bool inherits(const QMetaObject* derived, const QMetaObject* base) { for (auto super = derived; super; super = super->superClass()) { if (super == base) { return true; } } return false; } template void registerConverter(const QWeakPointer& weak) { // from parameter type to on-the-wire type QMetaType::registerConverter([](const T* obj) { return DBusMgr::objectPathSafe(obj); }); QMetaType::registerConverter, QList>( [](const QList objs) { return DBusMgr::objectsToPath(objs); }); // the opposite QMetaType::registerConverter([weak](const QDBusObjectPath& path) -> T* { if (auto dbus = weak.lock()) { return dbus->pathToObject(path); } qDebug() << "No DBusMgr when looking up path" << path.path(); return nullptr; }); QMetaType::registerConverter, QList>([weak](const QList& paths) { if (auto dbus = weak.lock()) { return dbus->pathsToObject(paths); } qDebug() << "No DBusMgr when looking up paths"; return QList{}; }); } void registerDBusTypes(const QSharedPointer& dbus) { // On the wire types: // - various primary types // - QDBusVariant // - wire::Secret // - wire::ObjectPathSecretMap // - QDBusObjectPath // - QList // Parameter types: // - various primary types // - QVariant // - Secret // - ObjectSecretMap // - DBusObject* (and derived classes) // - QList // NOTE: when registering, in additional to the class' fully qualified name, // the partial-namespace/non-namespace name should also be registered as alias // otherwise all those usages in Q_INVOKABLE methods without FQN won't be included // in the meta type system. #define REG_METATYPE(type) \ qRegisterMetaType(); \ qRegisterMetaType(#type) // register on-the-wire types // Qt container types for builtin types don't need registration REG_METATYPE(wire::Secret); REG_METATYPE(wire::StringStringMap); REG_METATYPE(wire::ObjectPathSecretMap); qDBusRegisterMetaType(); qDBusRegisterMetaType(); qDBusRegisterMetaType(); // register parameter types REG_METATYPE(Secret); REG_METATYPE(StringStringMap); REG_METATYPE(ItemSecretMap); REG_METATYPE(DBusResult); REG_METATYPE(DBusClientPtr); #define REG_DBUS_OBJ(name) \ REG_METATYPE(name*); \ REG_METATYPE(QList) REG_DBUS_OBJ(DBusObject); REG_DBUS_OBJ(Service); REG_DBUS_OBJ(Collection); REG_DBUS_OBJ(Item); REG_DBUS_OBJ(Session); REG_DBUS_OBJ(PromptBase); #undef REG_DBUS_OBJ #undef REG_METATYPE QWeakPointer weak = dbus; // register converter between on-the-wire types and parameter types // some pairs are missing because that particular direction isn't used registerConverter(weak); registerConverter(weak); registerConverter(weak); registerConverter(weak); registerConverter(weak); registerConverter(weak); QMetaType::registerConverter( [weak](const wire::Secret& from) { return from.unmarshal(weak); }); QMetaType::registerConverter(&Secret::marshal); QMetaType::registerConverter([](const ItemSecretMap& map) { wire::ObjectPathSecretMap ret; for (auto it = map.constBegin(); it != map.constEnd(); ++it) { ret.insert(it.key()->objectPath(), it.value().marshal()); } return ret; }); QMetaType::registerConverter([](const QDBusVariant& obj) { return obj.variant(); }); QMetaType::registerConverter([](const QVariant& obj) { return QDBusVariant(obj); }); // structural types are received as QDBusArgument, // top level QDBusArgument in method parameters are directly handled // in prepareInputParams. // But in Collection::createItem, we need to convert a inner QDBusArgument to StringStringMap QMetaType::registerConverter([](const QDBusArgument& arg) { if (arg.currentSignature() != "a{ss}") { return StringStringMap{}; } // QDBusArgument is COW and qdbus_cast modifies it by detaching even it is const. // we don't want to modify the instance (arg) stored in the qvariant so we create a copy const auto copy = arg; // NOLINT(performance-unnecessary-copy-initialization) return qdbus_cast(copy); }); } ParamData typeToWireType(int id) { switch (id) { case QMetaType::QString: return {QByteArrayLiteral("s"), QMetaType::QString}; case QMetaType::QVariant: return {QByteArrayLiteral("v"), qMetaTypeId()}; case QMetaType::QVariantMap: return {QByteArrayLiteral("a{sv}"), QMetaType::QVariantMap}; case QMetaType::Bool: return {QByteArrayLiteral("b"), QMetaType::Bool}; case QMetaType::ULongLong: return {QByteArrayLiteral("t"), QMetaType::ULongLong}; default: break; } if (id == qMetaTypeId()) { return {QByteArrayLiteral("a{ss}"), qMetaTypeId()}; } else if (id == qMetaTypeId()) { return {QByteArrayLiteral("a{o(oayays)}"), qMetaTypeId()}; } else if (id == qMetaTypeId()) { return {QByteArrayLiteral("(oayays)"), qMetaTypeId()}; } else if (id == qMetaTypeId()) { return {QByteArrayLiteral("o"), qMetaTypeId()}; } else if (id == qMetaTypeId>()) { return {QByteArrayLiteral("ao"), qMetaTypeId>()}; } QMetaType mt(id); if (!mt.isValid()) { return {}; } if (QByteArray(QMetaType::typeName(id)).startsWith("QList")) { // QList return {QByteArrayLiteral("ao"), qMetaTypeId>()}; } if (!inherits(mt.metaObject(), &DBusObject::staticMetaObject)) { return {}; } // DBusObjects return {QByteArrayLiteral("o"), qMetaTypeId()}; } ::FdoSecrets::Secret wire::Secret::unmarshal(const QWeakPointer& weak) const { if (auto dbus = weak.lock()) { return {dbus->pathToObject(session), parameters, value, contentType}; } qDebug() << "No DBusMgr when converting wire::Secret"; return {nullptr, parameters, value, contentType}; } wire::Secret Secret::marshal() const { return {DBusMgr::objectPathSafe(session), parameters, value, contentType}; } } // namespace FdoSecrets