include/dbus_utility.cpp

#include "dbus_utility.hpp"

#include "dbus_singleton.hpp"
#include "logging.hpp"
#include "mapper/handler.hpp"
#include "mapper/mapper.hpp"
#include "mapper/types.hpp"

#include <boost/system/error_code.hpp> // IWYU pragma: keep
#include <sdbusplus/asio/property.hpp>
#include <sdbusplus/message/native_types.hpp>

#include <array>
#include <cstddef>
#include <cstdint>
#include <filesystem>
#include <functional>
#include <regex>
#include <span>
#include <sstream>
#include <string>
#include <string_view>
#include <tuple>
#include <utility>
#include <variant>
#include <vector>

namespace dbus
{

namespace utility
{

namespace
{
InterfaceMapType interfaceMap;
}

bool getNthStringFromPath(const std::string& path, int index,
                          std::string& result)
{
    if (index < 0)
    {
        return false;
    }

    std::filesystem::path p1(path);
    int count = -1;
    for (auto const& element : p1)
    {
        if (element.has_filename())
        {
            ++count;
            if (count == index)
            {
                result = element.stem().string();
                break;
            }
        }
    }
    return count >= index;
}

namespace dbus_mapper
{

void getSubTree(const std::string& path, int32_t depth,
                std::span<const std::string_view> interfaces,
                std::function<void(const boost::system::error_code&,
                                   const MapperGetSubTreeResponse&)>&& callback)
{
    crow::connections::systemBus->async_method_call(
        [callback{std::move(callback)}](
            const boost::system::error_code& ec,
            const MapperGetSubTreeResponse& subtree) { callback(ec, subtree); },
        "xyz.openbmc_project.ObjectMapper",
        "/xyz/openbmc_project/object_mapper",
        "xyz.openbmc_project.ObjectMapper", "GetSubTree", path, depth,
        interfaces);
}

void getSubTree(const std::string& path, int32_t depth,
                std::span<std::string> interfaces,
                std::function<void(const boost::system::error_code&,
                                   const MapperGetSubTreeResponse&)>&& callback)
{
    crow::connections::systemBus->async_method_call(
        [callback{std::move(callback)}](
            const boost::system::error_code& ec,
            const MapperGetSubTreeResponse& subtree) { callback(ec, subtree); },
        "xyz.openbmc_project.ObjectMapper",
        "/xyz/openbmc_project/object_mapper",
        "xyz.openbmc_project.ObjectMapper", "GetSubTree", path, depth,
        interfaces);
}

void getSubTreePaths(
    const std::string& path, int32_t depth,
    std::span<const std::string_view> interfaces,
    std::function<void(const boost::system::error_code&,
                       const MapperGetSubTreePathsResponse&)>&& callback)
{
    crow::connections::systemBus->async_method_call(
        [callback{std::move(callback)}](
            const boost::system::error_code& ec,
            const MapperGetSubTreePathsResponse& subtreePaths) {
        callback(ec, subtreePaths);
    },
        "xyz.openbmc_project.ObjectMapper",
        "/xyz/openbmc_project/object_mapper",
        "xyz.openbmc_project.ObjectMapper", "GetSubTreePaths", path, depth,
        interfaces);
}

void getAssociatedSubTree(
    const sdbusplus::message::object_path& associatedPath,
    const sdbusplus::message::object_path& path, int32_t depth,
    std::span<const std::string_view> interfaces,
    std::function<void(const boost::system::error_code&,
                       const MapperGetSubTreeResponse&)>&& callback)
{
    crow::connections::systemBus->async_method_call(
        [callback{std::move(callback)}](
            const boost::system::error_code& ec,
            const MapperGetSubTreeResponse& subtree) { callback(ec, subtree); },
        "xyz.openbmc_project.ObjectMapper",
        "/xyz/openbmc_project/object_mapper",
        "xyz.openbmc_project.ObjectMapper", "GetAssociatedSubTree",
        associatedPath, path, depth, interfaces);
}

void getAssociatedSubTreePaths(
    const sdbusplus::message::object_path& associatedPath,
    const sdbusplus::message::object_path& path, int32_t depth,
    std::span<const std::string_view> interfaces,
    std::function<void(const boost::system::error_code&,
                       const MapperGetSubTreePathsResponse&)>&& callback)
{
    crow::connections::systemBus->async_method_call(
        [callback{std::move(callback)}](
            const boost::system::error_code& ec,
            const MapperGetSubTreePathsResponse& subtreePaths) {
        callback(ec, subtreePaths);
    },
        "xyz.openbmc_project.ObjectMapper",
        "/xyz/openbmc_project/object_mapper",
        "xyz.openbmc_project.ObjectMapper", "GetAssociatedSubTreePaths",
        associatedPath, path, depth, interfaces);
}

void getDbusObject(const std::string& path,
                   std::span<const std::string_view> interfaces,
                   std::function<void(const boost::system::error_code&,
                                      const MapperGetObject&)>&& callback)
{
    crow::connections::systemBus->async_method_call(
        [callback{std::move(callback)}](const boost::system::error_code& ec,
                                        const MapperGetObject& object) {
        callback(ec, object);
    },
        "xyz.openbmc_project.ObjectMapper",
        "/xyz/openbmc_project/object_mapper",
        "xyz.openbmc_project.ObjectMapper", "GetObject", path, interfaces);
}

} // namespace dbus_mapper

// Ideally this would be a class variable.
bool isMapperLiteEnabled()
{
    return !interfaceMap.empty();
}

void getSubTree(const std::string& path, int32_t depth,
                std::span<const std::string_view> interfaces,
                std::function<void(const boost::system::error_code&,
                                   const MapperGetSubTreeResponse&)>&& callback)
{
    if (!isMapperLiteEnabled())
    {
        dbus_mapper::getSubTree(path, depth, interfaces, std::move(callback));
        return;
    }
    BMCWEB_LOG_DEBUG << "Mapper lite getSubTree called interfaceMap.size()="
                     << interfaceMap.size();
    std::vector<std::string> interfaces2;
    for (auto& s : interfaces)
    {
        interfaces2.emplace_back(s);
    }
    std::vector<InterfaceMapType::value_type> out =
        ::getSubTree(interfaceMap, path, depth, interfaces2);

    MapperGetSubTreeResponse out2;
    for (const auto& connection : out)
    {
        auto& newConnections = out2.emplace_back(std::make_pair(
            connection.first,
            MapperGetSubTreeResponse::value_type::second_type{}));
        for (const auto& path2 : connection.second)
        {
            auto& newPath = newConnections.second.emplace_back(
                path2.first, MapperGetSubTreeResponse::value_type::second_type::
                                 value_type::second_type{});
            for (const auto& interface2 : path2.second)
            {
                newPath.second.emplace_back(interface2);
            }
        }
    }

    boost::system::error_code ec;

#ifdef BMCWEB_STATEFUL_CHECK_RESPONSE
    dbus_mapper::getSubTree(path, depth, interfaces,
                            [out2](const boost::system::error_code& ec,
                                   const MapperGetSubTreeResponse& out) {
        if (ec)
        {
            BMCWEB_LOG_ERROR << "Mapper returned an error " << ec.message();
            return;
        }
        if (out != out2)
        {
            BMCWEB_LOG_CRITICAL << "Dbus GetSubTree doesn't match mapper lite";
        }
        else
        {
            BMCWEB_LOG_DEBUG << "Dbus GetSubTree matched mapper lite";
        }
    });
#endif

    callback(ec, out2);
}

// Overload to support span of strings for interface names.
void getSubTree(const std::string& path, int32_t depth,
                std::span<std::string> interfaces,
                std::function<void(const boost::system::error_code&,
                                   const MapperGetSubTreeResponse&)>&& callback)
{
    std::vector<std::string_view> interfacesSpan;
    for (const auto& interface : interfaces)
    {
        interfacesSpan.emplace_back(interface);
    }
    getSubTree(path, depth, interfacesSpan, std::move(callback));
}

void getSubTreePaths(
    const std::string& path, int32_t depth,
    std::span<const std::string_view> interfaces,
    std::function<void(const boost::system::error_code&,
                       const MapperGetSubTreePathsResponse&)>&& callback)
{
    if (!isMapperLiteEnabled())
    {
        dbus_mapper::getSubTreePaths(path, depth, interfaces,
                                     std::move(callback));
        return;
    }
    BMCWEB_LOG_DEBUG
        << "Mapper lite getSubTreePaths called interfaceMap.size()="
        << interfaceMap.size();
    std::vector<std::string> interfaces2;
    for (auto& s : interfaces)
    {
        interfaces2.emplace_back(s);
    }
    MapperGetSubTreePathsResponse out2 =
        ::getSubTreePaths(interfaceMap, path, depth, interfaces2);

#ifdef BMCWEB_STATEFUL_CHECK_RESPONSE
    dbus_mapper::getSubTreePaths(
        path, depth, interfaces,
        [out2](const boost::system::error_code& ec,
               const MapperGetSubTreePathsResponse& out) {
        if (ec)
        {
            BMCWEB_LOG_ERROR << "Mapper returned an error " << ec.message();
            return;
        }
        if (out != out2)
        {
            BMCWEB_LOG_CRITICAL
                << "Dbus GetSubTreePaths doesn't match mapper lite";
        }
        else
        {
            BMCWEB_LOG_DEBUG << "Dbus GetSubTreePaths matched mapper lite";
        }
    });
#endif

    boost::system::error_code ec;
    callback(ec, out2);
}

void getAssociatedSubTree(
    const sdbusplus::message::object_path& associatedPath,
    const sdbusplus::message::object_path& path, int32_t depth,
    std::span<const std::string_view> interfaces,
    std::function<void(const boost::system::error_code&,
                       const MapperGetSubTreeResponse&)>&& callback)
{
    if (!isMapperLiteEnabled())
    {
        dbus_mapper::getAssociatedSubTree(associatedPath, path, depth,
                                          interfaces, std::move(callback));
        return;
    }
    BMCWEB_LOG_DEBUG
        << "Mapper lite getSubTreePaths called interfaceMap.size()="
        << interfaceMap.size();
    std::vector<std::string> interfaces2;
    for (auto& s : interfaces)
    {
        interfaces2.emplace_back(s);
    }
    std::vector<InterfaceMapType::value_type> out =
        ::getAssociatedSubTree(interfaceMap, associationMaps, associatedPath,
                               path, depth, interfaces2);
    MapperGetSubTreeResponse out2;
    for (const auto& connection : out)
    {
        auto& newConnections = out2.emplace_back(std::make_pair(
            connection.first,
            MapperGetSubTreeResponse::value_type::second_type{}));
        for (const auto& path2 : connection.second)
        {
            auto& newPath = newConnections.second.emplace_back(
                path2.first, MapperGetSubTreeResponse::value_type::second_type::
                                 value_type::second_type{});
            for (const auto& interface2 : path2.second)
            {
                newPath.second.emplace_back(interface2);
            }
        }
    }
#ifdef BMCWEB_STATEFUL_CHECK_RESPONSE
    dbus_mapper::getAssociatedSubTree(
        associatedPath, path, depth, interfaces,
        [out2](const boost::system::error_code& ec,
               const MapperGetSubTreeResponse& out) {
        if (ec)
        {
            BMCWEB_LOG_ERROR << "Mapper returned an error " << ec.message();
            return;
        }
        if (out != out2)
        {
            BMCWEB_LOG_CRITICAL
                << "Dbus GetAssociatedSubTree doesn't match mapper lite";
        }
        else
        {
            BMCWEB_LOG_DEBUG << "Dbus GetAssociatedSubTree matched mapper lite";
        }
    });
#endif

    boost::system::error_code ec;
    callback(ec, out2);
}

void getAssociatedSubTreePaths(
    const sdbusplus::message::object_path& associatedPath,
    const sdbusplus::message::object_path& path, int32_t depth,
    std::span<const std::string_view> interfaces,
    std::function<void(const boost::system::error_code&,
                       const MapperGetSubTreePathsResponse&)>&& callback)
{
    if (!isMapperLiteEnabled())
    {
        dbus_mapper::getAssociatedSubTreePaths(associatedPath, path, depth,
                                               interfaces, std::move(callback));
        return;
    }
    BMCWEB_LOG_DEBUG
        << "Mapper lite getAssociatedSubTreePaths called interfaceMap.size()="
        << interfaceMap.size();
    std::vector<std::string> interfaces2;
    for (auto& s : interfaces)
    {
        interfaces2.emplace_back(s);
    }
    MapperGetSubTreePathsResponse out2 =
        ::getAssociatedSubTreePaths(interfaceMap, associationMaps,
                                    associatedPath, path, depth, interfaces2);

#ifdef BMCWEB_STATEFUL_CHECK_RESPONSE
    dbus_mapper::getAssociatedSubTreePaths(
        associatedPath, path, depth, interfaces,
        [out2](const boost::system::error_code& ec,
               const MapperGetSubTreePathsResponse& out) {
        if (ec)
        {
            BMCWEB_LOG_ERROR << "Mapper returned an error " << ec.message();
            return;
        }
        if (out != out2)
        {
            BMCWEB_LOG_CRITICAL
                << "Dbus GetAssociatedSubtreePaths doesn't match mapper lite";
        }
        else
        {
            BMCWEB_LOG_DEBUG
                << "Dbus GetAssociatedSubtreePaths matched mapper lite";
        }
    });
#endif

    boost::system::error_code ec;
    callback(ec, out2);
}
void getDbusObject(const std::string& path,
                   std::span<const std::string_view> interfaces,
                   std::function<void(const boost::system::error_code&,
                                      const MapperGetObject&)>&& callback)
{
    if (!isMapperLiteEnabled())
    {
        dbus_mapper::getDbusObject(path, interfaces, std::move(callback));
        return;
    }
    BMCWEB_LOG_DEBUG << "Mapper lite getDbusObject called interfaceMap.size()="
                     << interfaceMap.size();
    std::vector<std::string> interfaces2;
    for (auto& s : interfaces)
    {
        interfaces2.emplace_back(s);
    }
    ConnectionNames out = ::getObject(interfaceMap, path, interfaces2);

    MapperGetObject out2;
    for (const auto& connection : out)
    {
        auto& newConnections = out2.emplace_back(std::make_pair(
            connection.first, MapperGetObject::value_type::second_type{}));
        for (const auto& path2 : connection.second)
        {
            newConnections.second.emplace_back(path2);
        }
    }
#ifdef BMCWEB_STATEFUL_CHECK_RESPONSE
    dbus_mapper::getDbusObject(path, interfaces,
                               [out2](const boost::system::error_code& ec,
                                      const MapperGetObject& out) {
        if (ec)
        {
            BMCWEB_LOG_ERROR << "Mapper returned an error " << ec.message();
            return;
        }
        if (out != out2)
        {
            BMCWEB_LOG_CRITICAL << "Dbus GetObject doesn't match mapper lite";
        }
        else
        {
            BMCWEB_LOG_DEBUG << "Dbus GetObject matched mapper lite";
        }
    });
#endif
    boost::system::error_code ec;
    callback(ec, out2);
}

void getProperty(const std::string& service,
            const sdbusplus::message::object_path& path,
            const std::string& interface, const std::string& property,
            std::function<void(const boost::system::error_code&,
                               const DbusVariantType&)>&& callback)
{
    crow::connections::systemBus->async_method_call(
        [callback{std::move(callback)}](const boost::system::error_code& ec,
                                        const DbusVariantType& propertyValue) {
        callback(ec, propertyValue);
    },
        service, path, "org.freedesktop.DBus.Properties", "Get", interface,
        property);
}

void getAssociationEndPoints(
    const std::string& path,
    std::function<void(const boost::system::error_code&,
                       const MapperEndPoints&)>&& callback)
{
    getProperty<MapperEndPoints>("xyz.openbmc_project.ObjectMapper", {path},
                                 "xyz.openbmc_project.Association", "endpoints",
                                 std::move(callback));
}

void getManagedObjects(const std::string& service,
                       const sdbusplus::message::object_path& path,
                       std::function<void(const boost::system::error_code&,
                                          const ManagedObjectType&)>&& callback)
{
    crow::connections::systemBus->async_method_call(
        [callback{std::move(callback)}](const boost::system::error_code& ec,
                                        const ManagedObjectType& objects) {
        callback(ec, objects);
    },
        service, path, "org.freedesktop.DBus.ObjectManager",
        "GetManagedObjects");
}

} // namespace utility
} // namespace dbus