Dont use deprecated api

Fix out of memory access in parser
Add boost asio integration
2025-02-12 17:23:42 +01:00 · 2023-07-04 19:09:53 +02:00 · 2022-10-30 18:35:47 +01:00 · 2022-10-30 18:17:51 +01:00 · 2022-09-04 23:26:14 +02:00 · 2022-09-03 22:54:06 +02:00
73 changed files with 758 additions and 273 deletions
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -4,7 +4,7 @@

 cmake_minimum_required(VERSION 3.13)

-project(sdbus-c++ VERSION 1.1.0 LANGUAGES C CXX)
+project(sdbus-c++ VERSION 1.2.0 LANGUAGES C CXX)

 include(GNUInstallDirs) # Installation directories for `install` command and pkgconfig file

@ -81,6 +81,7 @@ set(SDBUSCPP_PUBLIC_HDRS
    ${SDBUSCPP_INCLUDE_DIR}/Types.h
    ${SDBUSCPP_INCLUDE_DIR}/TypeTraits.h
    ${SDBUSCPP_INCLUDE_DIR}/Flags.h
+    ${SDBUSCPP_INCLUDE_DIR}/SdbusAsio.h
    ${SDBUSCPP_INCLUDE_DIR}/sdbus-c++.h)

 set(SDBUSCPP_SRCS ${SDBUSCPP_CPP_SRCS} ${SDBUSCPP_HDR_SRCS} ${SDBUSCPP_PUBLIC_HDRS})
@ -210,6 +211,11 @@ install(FILES ${CMAKE_CURRENT_BINARY_DIR}/cmake/sdbus-c++-config.cmake
        DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/sdbus-c++
        COMPONENT dev)

+if(BUILD_SHARED_LIBS AND (BUILD_LIBSYSTEMD OR Systemd_LINK_LIBRARIES MATCHES "/libsystemd\.a(;|$)"))
+    set(PKGCONFIG_REQS ".private")
+else()
+    set(PKGCONFIG_REQS "")
+endif()
 configure_file(pkgconfig/sdbus-c++.pc.in pkgconfig/sdbus-c++.pc @ONLY)
 install(FILES ${CMAKE_CURRENT_BINARY_DIR}/pkgconfig/sdbus-c++.pc
        DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig COMPONENT dev)
--- a/15
+++ b/15
@ -201,3 +201,18 @@ v1.1.0
 - Add support for unregistering signal handler
 - Add support for chrono literals in sdbus-c++-xml2cpp generator
 - Additional little fixes and improvements in code, build system, and documentation
+
+v1.2.0
+- Add support for match rules
+- Add support for session bus connection at custom address
+- Add CMake variable for extra libsystemd config options
+- Use pseudo D-Bus connection for plain messages
+- Rename dont_request_slot tag to floating_slot
+- Add validity checks for names and paths
+- Remove executable flag from source files
+- Detect missing type after array declaration
+- Fix invalid assert on event fd
+- Enable move for ObjectPath and Signature
+- Add printer for std::chrono in googletest v1.11.0
+- Fix potential undefined behavior in creation of sdbus::Error
+- Additional little fixes and improvements in code, build system, and documentation
--- a/README.md
+++ b/README.md
@ -62,6 +62,10 @@ $ sudo cmake --build . --target install

      Defines version of systemd to be downloaded, built and integrated into sdbus-c++. Default value: `242`.

+    * `LIBSYSTEMD_EXTRA_CONFIG_OPTS` [string]
+
+      Additional options to be passed as-is to the libsystemd build system (meson for systemd v242) in its configure step. Can be used for passing e.g. toolchain file path in case of cross builds. Default value: empty.
+
 * `CMAKE_BUILD_TYPE` [string]

  This is a CMake-builtin option. Set to `Release` to build sdbus-c++ for production use. Set to `Debug` if you want to help further develop (and debug) the library :)
--- a/cmake/LibsystemdExternalProject.cmake
+++ b/cmake/LibsystemdExternalProject.cmake
@ -6,6 +6,10 @@ if((NOT MESON) OR (NOT NINJA))
    message(FATAL_ERROR "Meson and Ninja are required to build libsystemd")
 endif()

+if(NOT GPERF)
+    message(WARNING "gperf was not found, libsystemd configuration may fail")
+endif()
+
 find_library(GLIBC_RT_LIBRARY rt)
 find_package(PkgConfig REQUIRED)
 pkg_check_modules(MOUNT mount)
@ -15,6 +19,7 @@ if (NOT CAP_FOUND)
 endif()

 set(LIBSYSTEMD_VERSION "242" CACHE STRING "libsystemd version (>=239) to build and incorporate into libsdbus-c++")
+set(LIBSYSTEMD_EXTRA_CONFIG_OPTS "" CACHE STRING "Additional configuration options to be passed as-is to libsystemd build system")

 if(NOT CMAKE_BUILD_TYPE)
    set(LIBSYSTEMD_BUILD_TYPE "plain")
@ -41,7 +46,7 @@ ExternalProject_Add(LibsystemdBuildProject
                    GIT_SHALLOW       1
                    UPDATE_COMMAND    ""
                    CONFIGURE_COMMAND ${CMAKE_COMMAND} -E remove <BINARY_DIR>/*
-                              COMMAND ${MESON} --prefix=<INSTALL_DIR> --buildtype=${LIBSYSTEMD_BUILD_TYPE} -Dstatic-libsystemd=pic -Dselinux=false <SOURCE_DIR> <BINARY_DIR>
+                              COMMAND ${MESON} --prefix=<INSTALL_DIR> --buildtype=${LIBSYSTEMD_BUILD_TYPE} -Dstatic-libsystemd=pic -Dselinux=false <SOURCE_DIR> <BINARY_DIR> ${LIBSYSTEMD_EXTRA_CONFIG_OPTS}
                    BUILD_COMMAND     ${BUILD_VERSION_H}
                          COMMAND     ${NINJA} -C <BINARY_DIR> libsystemd.a
                    BUILD_ALWAYS      0
--- a/docs/systemd-dbus-config.md
+++ b/docs/systemd-dbus-config.md
@ -1,4 +1,4 @@
-Systemd and dbus configuration
+Systemd and D-Bus configuration
 =======================

 **Table of contents**
@ -10,15 +10,13 @@ Systemd and dbus configuration
 Introduction
 ------------

-To run executable as a systemd service you may need some additional setup. For example, you may need explicitly allow 
-the usage of your service. Following chapters contain template configurations.
+To run executable as a systemd service you may need some additional setup. For example, you may need explicitly allow the usage of your service. Following chapters contain template configurations.


 Systemd configuration
 ---------------------------------------

-Filename should use `.service` extension. It also must be placed in configuration directory (/etc/systemd/system in
-Ubuntu 18.04.1 LTS) 
+Filename should use `.service` extension. It also must be placed in configuration directory (/etc/systemd/system in Ubuntu 18.04.1 LTS)

 ```
 [Unit]
@ -31,12 +29,10 @@ ExecStart=/path/to/executable
 WantedBy=multi-user.target
 ```

-Dbus configuration
+D-Bus configuration
 ------------------

-Typical default D-Bus configuration does not allow to register services except explicitly allowed. Filename should 
-contain name of your service, e.g `/etc/dbus-1/system.d/org.sdbuscpp.concatenator.conf`. So, here is template
-configuration to use dbus interface under root:
+Typical default D-Bus configuration does not allow to register services except explicitly allowed. To allow a service to register its D-Bus API, we must place an appropriate conf file in `/etc/dbus-1/system.d/` directory. The conf file name must be `<service-name>.conf`. I.e., full file path for Concatenator example from sdbus-c++ tutorial would be `/etc/dbus-1/system.d/org.sdbuscpp.concatenator.conf`. And here is template configuration to use its D-Bus interface under root:

 ```
 <!DOCTYPE busconfig PUBLIC
@ -45,10 +41,10 @@ configuration to use dbus interface under root:
 <busconfig>
  <policy user="root">
    <allow own="org.sdbuscpp.concatenator"/>
-    <allow send_destination="org.sdbuscpp"/>
+    <allow send_destination="org.sdbuscpp.concatenator"/>
    <allow send_interface="org.sdbuscpp.concatenator"/>
  </policy>
 </busconfig>
 ```

-If you need access from other user `root` should be substituted by desired username. For more refer to `man dbus-daemon`.
+If you need access from other user then `root` should be substituted by desired username. Or you can simply use policy `<policy context="default">` like [conf file](/tests/integrationtests/files/org.sdbuscpp.integrationtests.conf) for sdbus-c++ integration tests is doing it. For more information refer to `man dbus-daemon`.
--- a/docs/using-sdbus-c++.md
+++ b/docs/using-sdbus-c++.md
@ -19,7 +19,8 @@ Using sdbus-c++ library
 14. [Asynchronous client-side methods](#asynchronous-client-side-methods)
 15. [Using D-Bus properties](#using-d-bus-properties)
 16. [Standard D-Bus interfaces](#standard-d-bus-interfaces)
-17. [Conclusion](#conclusion)
+17. [Support for match rules](#support-for-match-rules)
+18. [Conclusion](#conclusion)

 Introduction
 ------------
@ -118,6 +119,10 @@ There are Yocto recipes for sdbus-c++ available in the [`meta-oe`](https://githu

 sdbus-c++ recipe is available in ConanCenter repository as [`sdbus-cpp`](https://conan.io/center/sdbus-cpp).

+### Buildroot
+
+There is the Buildroot package [`sdbus-cpp`](https://git.buildroot.net/buildroot/tree/package/sdbus-cpp?h=2022.02) to build sdbus-c++ library itself without a code generation tool.
+
 Contributors willing to help with bringing sdbus-c++ to other popular package systems are welcome.

 Verifying sdbus-c++
@ -221,7 +226,7 @@ Let's have an object `/org/sdbuscpp/concatenator` that implements the `org.sdbus

 In the following sections, we will elaborate on the ways of implementing such an object on both the server and the client side.

-> **_Note_:** In order to be able to call methods of your system bus-based D-Bus service, a D-Bus security policy file has to be put in place for that service. See [dbus-daemon documentation](https://dbus.freedesktop.org/doc/dbus-daemon.1.html), sections *INTEGRATING SYSTEM SERVICES* and *CONFIGURATION FILE*. As an example, you may look at the [policy file for sdbus-c++ integration tests](/tests/integrationtests/files/org.sdbuscpp.integrationtests.conf).
+> **Before running Concatenator example in your system:** In order for your service to be allowed to provide a D-Bus API on system bus, a D-Bus security policy file has to be put in place for that service. Otherwise the service will fail to start (you'll get `[org.freedesktop.DBus.Error.AccessDenied] Failed to request bus name (Permission denied)`, for example). To make the Concatenator example work in your system, [look in this section of systemd configuration](systemd-dbus-config.md#dbus-configuration) for how to name the file, where to place it, how to populate it. For further information, consult [dbus-daemon documentation](https://dbus.freedesktop.org/doc/dbus-daemon.1.html), sections *INTEGRATING SYSTEM SERVICES* and *CONFIGURATION FILE*. As an example used for sdbus-c++ integration tests, you may look at the [policy file for sdbus-c++ integration tests](/tests/integrationtests/files/org.sdbuscpp.integrationtests.conf).

 Implementing the Concatenator example using basic sdbus-c++ API layer
 ---------------------------------------------------------------------
@ -1275,6 +1280,11 @@ Note that signals of afore-mentioned standard D-Bus interfaces are not emitted b

 Working examples of using standard D-Bus interfaces can be found in [sdbus-c++ integration tests](/tests/integrationtests/DBusStandardInterfacesTests.cpp) or the [examples](/examples) directory.

+Support for match rules
+-----------------------
+
+`IConnection` class provides `addMatch` method that you can use to install match rules. An associated callback handler will be called upon an incoming message matching given match rule. There is support for both client-owned and floating (library-owned) match rules. Consult `IConnection` header or sdbus-c++ doxygen documentation for more information.
+
 Conclusion
 ----------

--- a/include/sdbus-c++/AdaptorInterfaces.h
+++ b/include/sdbus-c++/AdaptorInterfaces.h
@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
 *
 * @file AdaptorInterfaces.h
 *
--- a/include/sdbus-c++/ConvenienceApiClasses.h
+++ b/include/sdbus-c++/ConvenienceApiClasses.h
@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
 *
 * @file ConvenienceApiClasses.h
 *
--- a/include/sdbus-c++/ConvenienceApiClasses.inl
+++ b/include/sdbus-c++/ConvenienceApiClasses.inl
@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
 *
 * @file ConvenienceApiClasses.inl
 *
--- a/include/sdbus-c++/Error.h
+++ b/include/sdbus-c++/Error.h
@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
 *
 * @file Error.h
 *
--- a/include/sdbus-c++/Flags.h
+++ b/include/sdbus-c++/Flags.h
@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
 *
 * @file Flags.h
 *
--- a/include/sdbus-c++/IConnection.h
+++ b/include/sdbus-c++/IConnection.h
@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
 *
 * @file IConnection.h
 *
@ -27,6 +27,7 @@
 #ifndef SDBUS_CXX_ICONNECTION_H_
 #define SDBUS_CXX_ICONNECTION_H_

+#include <sdbus-c++/TypeTraits.h>
 #include <string>
 #include <memory>
 #include <chrono>
@ -77,6 +78,11 @@ namespace sdbus {
             */
            uint64_t timeout_usec;

+            /*!
+             * The read fd to be monitored by the event loop.
+             */
+            int event_fd;
+
            /*!
             * Get the event poll timeout.
             *
@ -166,9 +172,15 @@ namespace sdbus {
         * the connection. This is a convenient way to interrogate a connection
         * to see what objects it has.
         *
+         * This call creates a floating registration. The ObjectManager will
+         * be there for the object path until the connection is destroyed.
+         *
+         * Another, recommended way to add object managers is directly through
+         * IObject API.
+         *
         * @throws sdbus::Error in case of failure
         */
-        virtual void addObjectManager(const std::string& objectPath) = 0;
+        [[deprecated("Use one of other addObjectManager overloads")]] virtual void addObjectManager(const std::string& objectPath) = 0;

        /*!
         * @brief Returns fd, I/O events and timeout data you can pass to poll
@ -241,6 +253,64 @@ namespace sdbus {
         */
        virtual uint64_t getMethodCallTimeout() const = 0;

+        /*!
+         * @brief Adds an ObjectManager at the specified D-Bus object path
+         *
+         * Creates an ObjectManager interface at the specified object path on
+         * the connection. This is a convenient way to interrogate a connection
+         * to see what objects it has.
+         *
+         * This call creates a floating registration. The ObjectManager will
+         * be there for the object path until the connection is destroyed.
+         *
+         * Another, recommended way to add object managers is directly through
+         * IObject API.
+         *
+         * @throws sdbus::Error in case of failure
+         */
+        virtual void addObjectManager(const std::string& objectPath, floating_slot_t) = 0;
+
+        /*!
+         * @brief Adds a match rule for incoming message dispatching
+         *
+         * @param[in] match Match expression to filter incoming D-Bus message
+         * @param[in] callback Callback handler to be called upon incoming D-Bus message matching the rule
+         * @return RAII-style slot handle representing the ownership of the subscription
+         *
+         * The method installs a match rule for messages received on the specified bus connection.
+         * The syntax of the match rule expression passed in match is described in the D-Bus specification.
+         * The specified handler function callback is called for each incoming message matching the specified
+         * expression. The match is installed synchronously when connected to a bus broker, i.e. the call
+         * sends a control message requested the match to be added to the broker and waits until the broker
+         * confirms the match has been installed successfully.
+         *
+         * Simply let go of the slot instance to uninstall the match rule from the bus connection. The slot
+         * must not outlive the connection for the slot is associated with it.
+         *
+         * For more information, consult `man sd_bus_add_match`.
+         *
+         * @throws sdbus::Error in case of failure
+         */
+        [[nodiscard]] virtual Slot addMatch(const std::string& match, message_handler callback) = 0;
+
+        /*!
+         * @brief Adds a floating match rule for incoming message dispatching
+         *
+         * @param[in] match Match expression to filter incoming D-Bus message
+         * @param[in] callback Callback handler to be called upon incoming D-Bus message matching the rule
+         * @param[in] Floating slot tag
+         *
+         * The method installs a floating match rule for messages received on the specified bus connection.
+         * Floating means that the bus connection object owns the match rule, i.e. lifetime of the match rule
+         * is bound to the lifetime of the bus connection.
+         *
+         * Refer to the @c addMatch(const std::string& match, message_handler callback) documentation for more
+         * information.
+         *
+         * @throws sdbus::Error in case of failure
+         */
+        virtual void addMatch(const std::string& match, message_handler callback, floating_slot_t) = 0;
+
        /*!
         * @copydoc IConnection::enterEventLoop()
         *
@ -298,7 +368,7 @@ namespace sdbus {
    }

    /*!
-     * @brief Creates/opens D-Bus system connection
+     * @brief Creates/opens D-Bus system bus connection
     *
     * @return Connection instance
     *
@ -307,7 +377,7 @@ namespace sdbus {
    [[nodiscard]] std::unique_ptr<sdbus::IConnection> createConnection();

    /*!
-     * @brief Creates/opens D-Bus system connection with a name
+     * @brief Creates/opens D-Bus system bus connection with a name
     *
     * @param[in] name Name to request on the connection after its opening
     * @return Connection instance
@ -317,8 +387,7 @@ namespace sdbus {
    [[nodiscard]] std::unique_ptr<sdbus::IConnection> createConnection(const std::string& name);

    /*!
-     * @brief Creates/opens D-Bus user connection when in a user context,
-     * and a system connection, otherwise.
+     * @brief Creates/opens D-Bus session bus connection when in a user context, and a system bus connection, otherwise.
     *
     * @return Connection instance
     *
@ -327,8 +396,7 @@ namespace sdbus {
    [[nodiscard]] std::unique_ptr<sdbus::IConnection> createDefaultBusConnection();

    /*!
-     * @brief Creates/opens D-Bus user connection with a name when in a user
-     * context, and a system connection with a name, otherwise.
+     * @brief Creates/opens D-Bus session bus connection with a name when in a user context, and a system bus connection with a name, otherwise.
     *
     * @param[in] name Name to request on the connection after its opening
     * @return Connection instance
@ -338,7 +406,7 @@ namespace sdbus {
    [[nodiscard]] std::unique_ptr<sdbus::IConnection> createDefaultBusConnection(const std::string& name);

    /*!
-     * @brief Creates/opens D-Bus system connection
+     * @brief Creates/opens D-Bus system bus connection
     *
     * @return Connection instance
     *
@ -347,7 +415,7 @@ namespace sdbus {
    [[nodiscard]] std::unique_ptr<sdbus::IConnection> createSystemBusConnection();

    /*!
-     * @brief Creates/opens D-Bus system connection with a name
+     * @brief Creates/opens D-Bus system bus connection with a name
     *
     * @param[in] name Name to request on the connection after its opening
     * @return Connection instance
@ -357,7 +425,7 @@ namespace sdbus {
    [[nodiscard]] std::unique_ptr<sdbus::IConnection> createSystemBusConnection(const std::string& name);

    /*!
-     * @brief Creates/opens D-Bus session connection
+     * @brief Creates/opens D-Bus session bus connection
     *
     * @return Connection instance
     *
@ -366,7 +434,7 @@ namespace sdbus {
    [[nodiscard]] std::unique_ptr<sdbus::IConnection> createSessionBusConnection();

    /*!
-     * @brief Creates/opens D-Bus session connection with a name
+     * @brief Creates/opens D-Bus session bus connection with a name
     *
     * @param[in] name Name to request on the connection after its opening
     * @return Connection instance
@ -375,6 +443,18 @@ namespace sdbus {
     */
    [[nodiscard]] std::unique_ptr<sdbus::IConnection> createSessionBusConnection(const std::string& name);

+    /*!
+     * @brief Creates/opens D-Bus session bus connection at a custom address
+     *
+     * @param[in] address ";"-separated list of addresses of bus brokers to try to connect
+     * @return Connection instance
+     *
+     * @throws sdbus::Error in case of failure
+     *
+     * Consult manual pages for `sd_bus_set_address` of the underlying sd-bus library for more information.
+     */
+    [[nodiscard]] std::unique_ptr<sdbus::IConnection> createSessionBusConnectionWithAddress(const std::string& address);
+
    /*!
     * @brief Creates/opens D-Bus system connection on a remote host using ssh
     *
--- a/include/sdbus-c++/IObject.h
+++ b/include/sdbus-c++/IObject.h
@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
 *
 * @file IObject.h
 *
--- a/include/sdbus-c++/IProxy.h
+++ b/include/sdbus-c++/IProxy.h
@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
 *
 * @file IProxy.h
 *
--- a/include/sdbus-c++/Message.h
+++ b/include/sdbus-c++/Message.h
@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
 *
 * @file Message.h
 *
@ -32,7 +32,6 @@
 #include <string>
 #include <vector>
 #include <map>
-#include <memory>
 #include <utility>
 #include <cstdint>
 #include <cassert>
@ -55,16 +54,11 @@ namespace sdbus {

 namespace sdbus {

-    // Assume the caller has already obtained message ownership
-    struct adopt_message_t { explicit adopt_message_t() = default; };
-    inline constexpr adopt_message_t adopt_message{};
-
    /********************************************//**
     * @class Message
     *
     * Message represents a D-Bus message, which can be either method call message,
-     * method reply message, signal message, or a plain message serving as a storage
-     * for serialized data.
+     * method reply message, signal message, or a plain message.
     *
     * Serialization and deserialization functions are provided for types supported
     * by D-Bus.
@ -173,21 +167,17 @@ namespace sdbus {
        mutable bool ok_{true};
    };

-    struct dont_request_slot_t { explicit dont_request_slot_t() = default; };
-    inline constexpr dont_request_slot_t dont_request_slot{};
-
    class MethodCall : public Message
    {
        using Message::Message;
        friend Factory;

    public:
-        using Slot = std::unique_ptr<void, std::function<void(void*)>>;
-
        MethodCall() = default;

        MethodReply send(uint64_t timeout) const;
-        void send(void* callback, void* userData, uint64_t timeout, dont_request_slot_t) const;
+        [[deprecated("Use send overload with floating_slot instead")]] void send(void* callback, void* userData, uint64_t timeout, dont_request_slot_t) const;
+        void send(void* callback, void* userData, uint64_t timeout, floating_slot_t) const;
        [[nodiscard]] Slot send(void* callback, void* userData, uint64_t timeout) const;

        MethodReply createReply() const;
@ -244,6 +234,7 @@ namespace sdbus {
        PropertyGetReply() = default;
    };

+    // Represents any of the above message types, or just a message that serves as a container for data
    class PlainMessage : public Message
    {
        using Message::Message;
--- a/include/sdbus-c++/MethodResult.h
+++ b/include/sdbus-c++/MethodResult.h
@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
 *
 * @file MethodResult.h
 *
--- a/include/sdbus-c++/ProxyInterfaces.h
+++ b/include/sdbus-c++/ProxyInterfaces.h
@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
 *
 * @file ProxyInterfaces.h
 *
--- a/include/sdbus-c++/SdbusAsio.h
+++ b/include/sdbus-c++/SdbusAsio.h
@ -0,0 +1,67 @@
+#pragma once
+
+#include <boost/asio.hpp>
+#include <boost/noncopyable.hpp>
+#include <memory>
+#include <sdbus-c++/sdbus-c++.h>
+
+class SdbusAsio final : boost::noncopyable {
+public:
+    explicit SdbusAsio(boost::asio::io_context& io_context,
+        std::unique_ptr<sdbus::IConnection> conn = sdbus::createDefaultBusConnection())
+        : conn_ { std::move(conn) }
+        , timer_ { io_context }
+        , dbus_desc_ { io_context }
+        , event_desc_ { io_context }
+
+    {
+        auto poll_data = conn_->getEventLoopPollData();
+        dbus_desc_.async_wait(boost::asio::posix::stream_descriptor::wait_read,
+            [this](const boost::system::error_code&) { processRead(); });
+        dbus_desc_.assign(poll_data.fd);
+
+        event_desc_.async_read_some(boost::asio::null_buffers(), [this](auto&, auto) { processEvent(); });
+        event_desc_.assign(poll_data.event_fd);
+
+        if (poll_data.timeout_usec != UINT64_MAX) {
+            timer_.async_wait([this](boost::system::error_code const&) { processTimeout(); });
+            timer_.expires_after(boost::posix_time::microsec(poll_data.timeout_usec));
+        }
+    }
+
+    std::shared_ptr<sdbus::IConnection> getConnection() { return conn_; }
+
+private:
+    void process()
+    {
+        for (auto i = 0; i < DBUS_PROCESS_MAX; i++) {
+            if (!conn_->processPendingRequest()) {
+                break;
+            }
+        }
+    }
+    void processRead()
+    {
+        process();
+        dbus_desc_.async_wait(boost::asio::posix::stream_descriptor::wait_read,
+            [this](const boost::system::error_code&) { processRead(); });
+    }
+
+    void processEvent()
+    {
+        process();
+        event_desc_.async_read_some(boost::asio::null_buffers(), [this](auto, auto) { processEvent(); });
+    }
+
+    void processTimeout()
+    {
+        process();
+        timer_.async_wait([this](boost::system::error_code const&) { processTimeout(); });
+    }
+
+    static constexpr auto DBUS_PROCESS_MAX = 32;
+    std::shared_ptr<sdbus::IConnection> conn_;
+    boost::asio::deadline_timer timer_;
+    boost::asio::posix::stream_descriptor dbus_desc_;
+    boost::asio::posix::stream_descriptor event_desc_;
+};
--- a/include/sdbus-c++/StandardInterfaces.h
+++ b/include/sdbus-c++/StandardInterfaces.h
@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
 *
 * @file StandardInterfaces.h
 *
--- a/include/sdbus-c++/TypeTraits.h
+++ b/include/sdbus-c++/TypeTraits.h
@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
 *
 * @file TypeTraits.h
 *
@ -33,6 +33,7 @@
 #include <map>
 #include <cstdint>
 #include <functional>
+#include <memory>
 #include <tuple>

 // Forward declarations
@ -45,6 +46,7 @@ namespace sdbus {
    class MethodCall;
    class MethodReply;
    class Signal;
+    class Message;
    class PropertySetCall;
    class PropertyGetReply;
    template <typename... _Results> class Result;
@ -53,12 +55,34 @@ namespace sdbus {

 namespace sdbus {

+    // Callbacks from sdbus-c++
    using method_callback = std::function<void(MethodCall msg)>;
    using async_reply_handler = std::function<void(MethodReply& reply, const Error* error)>;
    using signal_handler = std::function<void(Signal& signal)>;
+    using message_handler = std::function<void(Message& msg)>;
    using property_set_callback = std::function<void(PropertySetCall& msg)>;
    using property_get_callback = std::function<void(PropertyGetReply& reply)>;

+    // Type-erased RAII-style handle to callbacks/subscriptions registered to sdbus-c++
+    using Slot = std::unique_ptr<void, std::function<void(void*)>>;
+
+    // Tag specifying that an owning slot handle shall be returned from the function
+    struct request_slot_t { explicit request_slot_t() = default; };
+    inline constexpr request_slot_t request_slot{};
+    // Tag specifying that the library shall own the slot resulting from the call of the function (so-called floating slot)
+    struct floating_slot_t { explicit floating_slot_t() = default; };
+    inline constexpr floating_slot_t floating_slot{};
+    // Deprecated name for the above -- a floating slot
+    struct dont_request_slot_t { explicit dont_request_slot_t() = default; };
+    [[deprecated("Replaced by floating_slot")]] inline constexpr dont_request_slot_t dont_request_slot{};
+    // Tag denoting the assumption that the caller has already obtained message ownership
+    struct adopt_message_t { explicit adopt_message_t() = default; };
+    inline constexpr adopt_message_t adopt_message{};
+    // Tag denoting the assumption that the caller has already obtained fd ownership
+    struct adopt_fd_t { explicit adopt_fd_t() = default; };
+    inline constexpr adopt_fd_t adopt_fd{};
+
+    // Template specializations for getting D-Bus signatures from C++ types
    template <typename _T>
    struct signature_of
    {
--- a/include/sdbus-c++/Types.h
+++ b/include/sdbus-c++/Types.h
@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
 *
 * @file Types.h
 *
@ -185,9 +185,6 @@ namespace sdbus {
        using std::string::operator=;
    };

-    struct adopt_fd_t { explicit adopt_fd_t() = default; };
-    inline constexpr adopt_fd_t adopt_fd{};
-
    /********************************************//**
     * @struct UnixFd
     *
--- a/include/sdbus-c++/sdbus-c++.h
+++ b/include/sdbus-c++/sdbus-c++.h
@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
 *
 * @file sdbus-c++.h
 *
--- a/pkgconfig/sdbus-c++.pc.in
+++ b/pkgconfig/sdbus-c++.pc.in
@ -5,7 +5,7 @@ includedir=@CMAKE_INSTALL_FULL_INCLUDEDIR@

 Name: @PROJECT_NAME@
 Description: C++ library on top of sd-bus, a systemd D-Bus library
-Requires: libsystemd
+Requires@PKGCONFIG_REQS@: libsystemd
 Version: @SDBUSCPP_VERSION@
 Libs: -L${libdir} -l@PROJECT_NAME@
 Cflags: -I${includedir}
--- a/src/Connection.cpp
+++ b/src/Connection.cpp
@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
 *
 * @file Connection.cpp
 *
@ -60,14 +60,31 @@ Connection::Connection(std::unique_ptr<ISdBus>&& interface, session_bus_t)
 {
 }

+Connection::Connection(std::unique_ptr<ISdBus>&& interface, custom_session_bus_t, const std::string& address)
+        : Connection(std::move(interface), [&](sd_bus** bus) { return iface_->sd_bus_open_user_with_address(bus, address.c_str()); })
+{
+}
+
 Connection::Connection(std::unique_ptr<ISdBus>&& interface, remote_system_bus_t, const std::string& host)
    : Connection(std::move(interface), [this, &host](sd_bus** bus){ return iface_->sd_bus_open_system_remote(bus, host.c_str()); })
 {
 }

+Connection::Connection(std::unique_ptr<ISdBus>&& interface, pseudo_bus_t)
+    : iface_(std::move(interface))
+    , bus_(openPseudoBus())
+{
+    assert(iface_ != nullptr);
+    eventFd_.fd = eventfd(0, 0);
+    assert(eventFd_.fd >= 0);
+}
+
 Connection::~Connection()
 {
    Connection::leaveEventLoop();
+    if (0 <= eventFd_.fd) {
+        close(eventFd_.fd);
+    }
 }

 void Connection::requestName(const std::string& name)
@ -129,7 +146,7 @@ Connection::PollData Connection::getEventLoopPollData() const
    auto r = iface_->sd_bus_get_poll_data(bus_.get(), &pollData);
    SDBUS_THROW_ERROR_IF(r < 0, "Failed to get bus poll data", -r);

-    return {pollData.fd, pollData.events, pollData.timeout_usec};
+    return {pollData.fd, pollData.events, pollData.timeout_usec, eventFd_.fd};
 }

 const ISdBus& Connection::getSdBusInterface() const
@ -144,16 +161,21 @@ ISdBus& Connection::getSdBusInterface()

 void Connection::addObjectManager(const std::string& objectPath)
 {
-    Connection::addObjectManager(objectPath, nullptr);
+    Connection::addObjectManager(objectPath, floating_slot);
 }

-SlotPtr Connection::addObjectManager(const std::string& objectPath, void* /*dummy*/)
+void Connection::addObjectManager(const std::string& objectPath, floating_slot_t)
+{
+    auto r = iface_->sd_bus_add_object_manager(bus_.get(), nullptr, objectPath.c_str());
+
+    SDBUS_THROW_ERROR_IF(r < 0, "Failed to add object manager", -r);
+}
+
+Slot Connection::addObjectManager(const std::string& objectPath, request_slot_t)
 {
    sd_bus_slot *slot{};

-    auto r = iface_->sd_bus_add_object_manager( bus_.get()
-                                              , &slot
-                                              , objectPath.c_str() );
+    auto r = iface_->sd_bus_add_object_manager(bus_.get(), &slot, objectPath.c_str());

    SDBUS_THROW_ERROR_IF(r < 0, "Failed to add object manager", -r);

@ -178,10 +200,38 @@ uint64_t Connection::getMethodCallTimeout() const
    return timeout;
 }

-SlotPtr Connection::addObjectVTable( const std::string& objectPath
-                                   , const std::string& interfaceName
-                                   , const sd_bus_vtable* vtable
-                                   , void* userData )
+Slot Connection::addMatch(const std::string& match, message_handler callback)
+{
+    auto matchInfo = std::make_unique<MatchInfo>(MatchInfo{std::move(callback), *this, {}});
+
+    auto messageHandler = [](sd_bus_message *sdbusMessage, void *userData, sd_bus_error */*retError*/) -> int
+    {
+        auto* matchInfo = static_cast<MatchInfo*>(userData);
+        auto message = Message::Factory::create<PlainMessage>(sdbusMessage, &matchInfo->connection.getSdBusInterface());
+        matchInfo->callback(message);
+        return 0;
+    };
+
+    auto r = iface_->sd_bus_add_match(bus_.get(), &matchInfo->slot, match.c_str(), std::move(messageHandler), matchInfo.get());
+    SDBUS_THROW_ERROR_IF(r < 0, "Failed to add match", -r);
+
+    return {matchInfo.release(), [this](void *ptr)
+    {
+        auto* matchInfo = static_cast<MatchInfo*>(ptr);
+        iface_->sd_bus_slot_unref(matchInfo->slot);
+        std::default_delete<MatchInfo>{}(matchInfo);
+    }};
+}
+
+void Connection::addMatch(const std::string& match, message_handler callback, floating_slot_t)
+{
+    floatingMatchRules_.push_back(addMatch(match, std::move(callback)));
+}
+
+Slot Connection::addObjectVTable( const std::string& objectPath
+                                , const std::string& interfaceName
+                                , const sd_bus_vtable* vtable
+                                , void* userData )
 {
    sd_bus_slot *slot{};

@ -296,12 +346,12 @@ void Connection::emitInterfacesRemovedSignal( const std::string& objectPath
    SDBUS_THROW_ERROR_IF(r < 0, "Failed to emit InterfacesRemoved signal", -r);
 }

-SlotPtr Connection::registerSignalHandler( const std::string& sender
-                                         , const std::string& objectPath
-                                         , const std::string& interfaceName
-                                         , const std::string& signalName
-                                         , sd_bus_message_handler_t callback
-                                         , void* userData )
+Slot Connection::registerSignalHandler( const std::string& sender
+                                      , const std::string& objectPath
+                                      , const std::string& interfaceName
+                                      , const std::string& signalName
+                                      , sd_bus_message_handler_t callback
+                                      , void* userData )
 {
    sd_bus_slot *slot{};

@ -356,6 +406,23 @@ Connection::BusPtr Connection::openBus(const BusFactory& busFactory)
    return busPtr;
 }

+Connection::BusPtr Connection::openPseudoBus()
+{
+    sd_bus* bus{};
+
+    int r = iface_->sd_bus_new(&bus);
+    SDBUS_THROW_ERROR_IF(r < 0, "Failed to open pseudo bus", -r);
+
+    (void)iface_->sd_bus_start(bus);
+    // It is expected that sd_bus_start has failed here, returning -EINVAL, due to having
+    // not set a bus address, but it will leave the bus in an OPENING state, which enables
+    // us to create plain D-Bus messages as a local data storage (for Variant, for example),
+    // without dependency on real IPC communication with the D-Bus broker daemon.
+    SDBUS_THROW_ERROR_IF(r < 0 && r != -EINVAL, "Failed to start pseudo bus", -r);
+
+    return {bus, [this](sd_bus* bus){ return iface_->sd_bus_close_unref(bus); }};
+}
+
 void Connection::finishHandshake(sd_bus* bus)
 {
    // Process all requests that are part of the initial handshake,
@ -383,6 +450,11 @@ void Connection::notifyEventLoopToExit() const
    notifyEventLoop(loopExitFd_.fd);
 }

+void Connection::notifyEventLoop() const
+{
+    notifyEventLoop(eventFd_.fd);
+}
+
 void Connection::notifyEventLoopNewTimeout() const
 {
    // The extra notifications for new timeouts are only needed if calls are made asynchronously to the event loop.
@ -457,10 +529,10 @@ bool Connection::waitForNextRequest()
    return true;
 }

-    std::string Connection::composeSignalMatchFilter(const std::string &sender,
-                                                     const std::string &objectPath,
-                                                     const std::string &interfaceName,
-                                                     const std::string &signalName)
+std::string Connection::composeSignalMatchFilter( const std::string &sender
+                                                , const std::string &objectPath
+                                                , const std::string &interfaceName
+                                                , const std::string &signalName )
 {
    std::string filter;

@ -535,10 +607,18 @@ std::unique_ptr<sdbus::internal::IConnection> createConnection()
    return std::unique_ptr<sdbus::internal::IConnection>(connectionInternal);
 }

+std::unique_ptr<sdbus::internal::IConnection> createPseudoConnection()
+{
+    auto interface = std::make_unique<sdbus::internal::SdBus>();
+    return std::make_unique<sdbus::internal::Connection>(std::move(interface), Connection::pseudo_bus);
+}
+
 } // namespace sdbus::internal

 namespace sdbus {

+using internal::Connection;
+
 std::unique_ptr<sdbus::IConnection> createConnection()
 {
    return createSystemBusConnection();
@ -552,8 +632,7 @@ std::unique_ptr<sdbus::IConnection> createConnection(const std::string& name)
 std::unique_ptr<sdbus::IConnection> createDefaultBusConnection()
 {
    auto interface = std::make_unique<sdbus::internal::SdBus>();
-    constexpr sdbus::internal::Connection::default_bus_t default_bus;
-    return std::make_unique<sdbus::internal::Connection>(std::move(interface), default_bus);
+    return std::make_unique<sdbus::internal::Connection>(std::move(interface), Connection::default_bus);
 }

 std::unique_ptr<sdbus::IConnection> createDefaultBusConnection(const std::string& name)
@ -566,8 +645,7 @@ std::unique_ptr<sdbus::IConnection> createDefaultBusConnection(const std::string
 std::unique_ptr<sdbus::IConnection> createSystemBusConnection()
 {
    auto interface = std::make_unique<sdbus::internal::SdBus>();
-    constexpr sdbus::internal::Connection::system_bus_t system_bus;
-    return std::make_unique<sdbus::internal::Connection>(std::move(interface), system_bus);
+    return std::make_unique<sdbus::internal::Connection>(std::move(interface), Connection::system_bus);
 }

 std::unique_ptr<sdbus::IConnection> createSystemBusConnection(const std::string& name)
@ -580,8 +658,7 @@ std::unique_ptr<sdbus::IConnection> createSystemBusConnection(const std::string&
 std::unique_ptr<sdbus::IConnection> createSessionBusConnection()
 {
    auto interface = std::make_unique<sdbus::internal::SdBus>();
-    constexpr sdbus::internal::Connection::session_bus_t session_bus;
-    return std::make_unique<sdbus::internal::Connection>(std::move(interface), session_bus);
+    return std::make_unique<sdbus::internal::Connection>(std::move(interface), Connection::session_bus);
 }

 std::unique_ptr<sdbus::IConnection> createSessionBusConnection(const std::string& name)
@ -591,11 +668,17 @@ std::unique_ptr<sdbus::IConnection> createSessionBusConnection(const std::string
    return conn;
 }

+std::unique_ptr<sdbus::IConnection> createSessionBusConnectionWithAddress(const std::string &address)
+{
+    auto interface = std::make_unique<sdbus::internal::SdBus>();
+    assert(interface != nullptr);
+    return std::make_unique<sdbus::internal::Connection>(std::move(interface), Connection::custom_session_bus, address);
+}
+
 std::unique_ptr<sdbus::IConnection> createRemoteSystemBusConnection(const std::string& host)
 {
    auto interface = std::make_unique<sdbus::internal::SdBus>();
-    constexpr sdbus::internal::Connection::remote_system_bus_t remote_system_bus;
-    return std::make_unique<sdbus::internal::Connection>(std::move(interface), remote_system_bus, host);
+    return std::make_unique<sdbus::internal::Connection>(std::move(interface), Connection::remote_system_bus, host);
 }

 } // namespace sdbus
--- a/src/Connection.h
+++ b/src/Connection.h
@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
 *
 * @file Connection.h
 *
@ -43,20 +43,29 @@
 namespace sdbus::internal {

    class Connection final
-        : public sdbus::IConnection           // External, public interface
-        , public sdbus::internal::IConnection // Internal, private interface
+        : public sdbus::internal::IConnection
    {
    public:
        // Bus type tags
        struct default_bus_t{};
+        inline static constexpr default_bus_t default_bus{};
        struct system_bus_t{};
+        inline static constexpr system_bus_t system_bus{};
        struct session_bus_t{};
+        inline static constexpr session_bus_t session_bus{};
+        struct custom_session_bus_t{};
+        inline static constexpr custom_session_bus_t custom_session_bus{};
        struct remote_system_bus_t{};
+        inline static constexpr remote_system_bus_t remote_system_bus{};
+        struct pseudo_bus_t{}; // A bus connection that is not really established with D-Bus daemon
+        inline static constexpr pseudo_bus_t pseudo_bus{};

        Connection(std::unique_ptr<ISdBus>&& interface, default_bus_t);
        Connection(std::unique_ptr<ISdBus>&& interface, system_bus_t);
        Connection(std::unique_ptr<ISdBus>&& interface, session_bus_t);
+        Connection(std::unique_ptr<ISdBus>&& interface, custom_session_bus_t, const std::string& address);
        Connection(std::unique_ptr<ISdBus>&& interface, remote_system_bus_t, const std::string& host);
+        Connection(std::unique_ptr<ISdBus>&& interface, pseudo_bus_t);
        ~Connection() override;

        void requestName(const std::string& name) override;
@ -69,18 +78,22 @@ namespace sdbus::internal {
        bool processPendingRequest() override;

        void addObjectManager(const std::string& objectPath) override;
-        SlotPtr addObjectManager(const std::string& objectPath, void* /*dummy*/) override;
+        void addObjectManager(const std::string& objectPath, floating_slot_t) override;
+        Slot addObjectManager(const std::string& objectPath, request_slot_t) override;

        void setMethodCallTimeout(uint64_t timeout) override;
        uint64_t getMethodCallTimeout() const override;

+        [[nodiscard]] Slot addMatch(const std::string& match, message_handler callback) override;
+        void addMatch(const std::string& match, message_handler callback, floating_slot_t) override;
+
        const ISdBus& getSdBusInterface() const override;
        ISdBus& getSdBusInterface() override;

-        SlotPtr addObjectVTable( const std::string& objectPath
-                               , const std::string& interfaceName
-                               , const sd_bus_vtable* vtable
-                               , void* userData ) override;
+        Slot addObjectVTable( const std::string& objectPath
+                            , const std::string& interfaceName
+                            , const sd_bus_vtable* vtable
+                            , void* userData ) override;

        PlainMessage createPlainMessage() const override;
        MethodCall createMethodCall( const std::string& destination
@ -101,12 +114,12 @@ namespace sdbus::internal {
        void emitInterfacesRemovedSignal( const std::string& objectPath
                                        , const std::vector<std::string>& interfaces ) override;

-        SlotPtr registerSignalHandler( const std::string& sender
-                                     , const std::string& objectPath
-                                     , const std::string& interfaceName
-                                     , const std::string& signalName
-                                     , sd_bus_message_handler_t callback
-                                     , void* userData ) override;
+        Slot registerSignalHandler( const std::string& sender
+                                  , const std::string& objectPath
+                                  , const std::string& interfaceName
+                                  , const std::string& signalName
+                                  , sd_bus_message_handler_t callback
+                                  , void* userData ) override;

        MethodReply tryCallMethodSynchronously(const MethodCall& message, uint64_t timeout) override;

@ -116,14 +129,17 @@ namespace sdbus::internal {
        Connection(std::unique_ptr<ISdBus>&& interface, const BusFactory& busFactory);

        BusPtr openBus(const std::function<int(sd_bus**)>& busFactory);
+        BusPtr openPseudoBus();
        void finishHandshake(sd_bus* bus);
        bool waitForNextRequest();
-        static std::string composeSignalMatchFilter(const std::string &sender, const std::string &objectPath,
-                                                    const std::string &interfaceName,
-                                                    const std::string &signalName);
+        static std::string composeSignalMatchFilter( const std::string &sender
+                                                   , const std::string &objectPath
+                                                   , const std::string &interfaceName
+                                                   , const std::string &signalName);
        void notifyEventLoop(int fd) const;
        void notifyEventLoopToExit() const;
        void clearEventLoopNotification(int fd) const;
+        void notifyEventLoop() const override;
        void notifyEventLoopNewTimeout() const override;

    private:
@ -137,6 +153,13 @@ namespace sdbus::internal {
            int fd{-1};
        };

+        struct MatchInfo
+        {
+            message_handler callback;
+            Connection& connection;
+            sd_bus_slot *slot;
+        };
+
    private:
        std::unique_ptr<ISdBus> iface_;
        BusPtr bus_;
@ -146,6 +169,7 @@ namespace sdbus::internal {
        EventFd loopExitFd_;
        EventFd eventFd_;
        std::atomic<uint64_t> activeTimeout_{};
+        std::vector<Slot> floatingMatchRules_;
    };

 }
--- a/src/Error.cpp
+++ b/src/Error.cpp
@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
 *
 * @file Error.cpp
 *
--- a/src/Flags.cpp
+++ b/src/Flags.cpp
@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
 *
 * @file Flags.cpp
 *
--- a/src/IConnection.h
+++ b/src/IConnection.h
@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
 *
 * @file IConnection.h
 *
@ -27,6 +27,7 @@
 #ifndef SDBUS_CXX_INTERNAL_ICONNECTION_H_
 #define SDBUS_CXX_INTERNAL_ICONNECTION_H_

+#include <sdbus-c++/IConnection.h>
 #include <systemd/sd-bus.h>
 #include <string>
 #include <memory>
@ -46,20 +47,19 @@ namespace sdbus {

 namespace sdbus::internal {

-    using SlotPtr = std::unique_ptr<void, std::function<void(void*)>>;
-
    class IConnection
+        : public ::sdbus::IConnection
    {
    public:
-        virtual ~IConnection() = default;
+        ~IConnection() override = default;

        virtual const ISdBus& getSdBusInterface() const = 0;
        virtual ISdBus& getSdBusInterface() = 0;

-        [[nodiscard]] virtual SlotPtr addObjectVTable( const std::string& objectPath
-                                                     , const std::string& interfaceName
-                                                     , const sd_bus_vtable* vtable
-                                                     , void* userData ) = 0;
+        [[nodiscard]] virtual Slot addObjectVTable( const std::string& objectPath
+                                                  , const std::string& interfaceName
+                                                  , const sd_bus_vtable* vtable
+                                                  , void* userData ) = 0;

        virtual PlainMessage createPlainMessage() const = 0;
        virtual MethodCall createMethodCall( const std::string& destination
@ -80,22 +80,23 @@ namespace sdbus::internal {
        virtual void emitInterfacesRemovedSignal( const std::string& objectPath
                                                , const std::vector<std::string>& interfaces ) = 0;

-        [[nodiscard]] virtual SlotPtr addObjectManager(const std::string& objectPath, void* /*dummy*/ = nullptr) = 0;
+        using sdbus::IConnection::addObjectManager;
+        [[nodiscard]] virtual Slot addObjectManager(const std::string& objectPath, request_slot_t) = 0;

-        [[nodiscard]] virtual SlotPtr registerSignalHandler( const std::string& sender
-                                                           , const std::string& objectPath
-                                                           , const std::string& interfaceName
-                                                           , const std::string& signalName
-                                                           , sd_bus_message_handler_t callback
-                                                           , void* userData ) = 0;
+        [[nodiscard]] virtual Slot registerSignalHandler( const std::string& sender
+                                                        , const std::string& objectPath
+                                                        , const std::string& interfaceName
+                                                        , const std::string& signalName
+                                                        , sd_bus_message_handler_t callback
+                                                        , void* userData ) = 0;

-        virtual void enterEventLoopAsync() = 0;
-        virtual void leaveEventLoop() = 0;
+        virtual void notifyEventLoop() const = 0;
        virtual void notifyEventLoopNewTimeout() const = 0;
        virtual MethodReply tryCallMethodSynchronously(const MethodCall& message, uint64_t timeout) = 0;
    };

    [[nodiscard]] std::unique_ptr<sdbus::internal::IConnection> createConnection();
+    [[nodiscard]] std::unique_ptr<sdbus::internal::IConnection> createPseudoConnection();

 }

--- a/src/ISdBus.h
+++ b/src/ISdBus.h
@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
 *
 * @file ISdBus.h
 * @author Ardazishvili Roman (ardazishvili.roman@yandex.ru)
@ -67,8 +67,9 @@ namespace sdbus::internal {
        virtual int sd_bus_emit_interfaces_removed_strv(sd_bus *bus, const char *path, char **interfaces) = 0;

        virtual int sd_bus_open(sd_bus **ret) = 0;
-        virtual int sd_bus_open_user(sd_bus **ret) = 0;
        virtual int sd_bus_open_system(sd_bus **ret) = 0;
+        virtual int sd_bus_open_user(sd_bus **ret) = 0;
+        virtual int sd_bus_open_user_with_address(sd_bus **ret, const char* address) = 0;
        virtual int sd_bus_open_system_remote(sd_bus **ret, const char* host) = 0;
        virtual int sd_bus_request_name(sd_bus *bus, const char *name, uint64_t flags) = 0;
        virtual int sd_bus_release_name(sd_bus *bus, const char *name) = 0;
@ -78,11 +79,15 @@ namespace sdbus::internal {
        virtual int sd_bus_add_match(sd_bus *bus, sd_bus_slot **slot, const char *match, sd_bus_message_handler_t callback, void *userdata) = 0;
        virtual sd_bus_slot* sd_bus_slot_unref(sd_bus_slot *slot) = 0;

+        virtual int sd_bus_new(sd_bus **ret) = 0;
+        virtual int sd_bus_start(sd_bus *bus) = 0;
+
        virtual int sd_bus_process(sd_bus *bus, sd_bus_message **r) = 0;
        virtual int sd_bus_get_poll_data(sd_bus *bus, PollData* data) = 0;

        virtual int sd_bus_flush(sd_bus *bus) = 0;
        virtual sd_bus *sd_bus_flush_close_unref(sd_bus *bus) = 0;
+        virtual sd_bus *sd_bus_close_unref(sd_bus *bus) = 0;

        virtual int sd_bus_message_set_destination(sd_bus_message *m, const char *destination) = 0;

--- a/src/Message.cpp
+++ b/src/Message.cpp
@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
 *
 * @file Message.cpp
 *
@ -782,6 +782,10 @@ MethodReply MethodCall::sendWithReply(uint64_t timeout) const

    SDBUS_THROW_ERROR_IF(r < 0, "Failed to call method", -r);

+    // Force event loop to re-enter processing to handle queued messages
+    SDBUS_THROW_ERROR_IF(connection_ == nullptr, "Invalid use of MethodCall API", ENOTSUP);
+    connection_->notifyEventLoop();
+
    return Factory::create<MethodReply>(sdbusReply, sdbus_, adopt_message);
 }

@ -790,10 +794,19 @@ MethodReply MethodCall::sendWithNoReply() const
    auto r = sdbus_->sd_bus_send(nullptr, (sd_bus_message*)msg_, nullptr);
    SDBUS_THROW_ERROR_IF(r < 0, "Failed to call method with no reply", -r);

+    // Force event loop to re-enter processing to handle queued messages
+    SDBUS_THROW_ERROR_IF(connection_ == nullptr, "Invalid use of MethodCall API", ENOTSUP);
+    connection_->notifyEventLoop();
+
    return Factory::create<MethodReply>(); // No reply
 }

 void MethodCall::send(void* callback, void* userData, uint64_t timeout, dont_request_slot_t) const
+{
+    MethodCall::send(callback, userData, timeout, floating_slot);
+}
+
+void MethodCall::send(void* callback, void* userData, uint64_t timeout, floating_slot_t) const
 {
    auto r = sdbus_->sd_bus_call_async(nullptr, nullptr, (sd_bus_message*)msg_, (sd_bus_message_handler_t)callback, userData, timeout);
    SDBUS_THROW_ERROR_IF(r < 0, "Failed to call method", -r);
@ -803,7 +816,7 @@ void MethodCall::send(void* callback, void* userData, uint64_t timeout, dont_req
    connection_->notifyEventLoopNewTimeout();
 }

-MethodCall::Slot MethodCall::send(void* callback, void* userData, uint64_t timeout) const
+Slot MethodCall::send(void* callback, void* userData, uint64_t timeout) const
 {
    sd_bus_slot* slot;

@ -814,7 +827,7 @@ MethodCall::Slot MethodCall::send(void* callback, void* userData, uint64_t timeo
    SDBUS_THROW_ERROR_IF(connection_ == nullptr, "Invalid use of MethodCall API", ENOTSUP);
    connection_->notifyEventLoopNewTimeout();

-    return Slot{slot, [sdbus_ = sdbus_](void *slot){ sdbus_->sd_bus_slot_unref((sd_bus_slot*)slot); }};
+    return {slot, [sdbus_ = sdbus_](void *slot){ sdbus_->sd_bus_slot_unref((sd_bus_slot*)slot); }};
 }

 MethodReply MethodCall::createReply() const
@ -859,9 +872,13 @@ void Signal::setDestination(const std::string& destination)

 PlainMessage createPlainMessage()
 {
-    static auto connection = internal::createConnection();
+    //static auto connection = internal::createConnection();
+    // Let's create a pseudo connection -- one that does not really connect to the real bus.
+    // This is a bit of a hack, but it enables use to work with D-Bus message locally without
+    // the need of D-Bus daemon. This is especially useful in unit tests of both sdbus-c++ and client code.
+    // Additionally, it's light-weight and fast solution.
+    static auto connection = internal::createPseudoConnection();
    return connection->createPlainMessage();
 }

-
 }
--- a/src/MessageUtils.h
+++ b/src/MessageUtils.h
@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
 *
 * @file MessageUtils.h
 *
--- a/src/Object.cpp
+++ b/src/Object.cpp
@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
 *
 * @file Object.cpp
 *
@ -217,7 +217,7 @@ void Object::emitInterfacesRemovedSignal(const std::vector<std::string>& interfa

 void Object::addObjectManager()
 {
-    objectManagerSlot_ = connection_.addObjectManager(objectPath_);
+    objectManagerSlot_ = connection_.addObjectManager(objectPath_, request_slot);
 }

 void Object::removeObjectManager()
@ -232,7 +232,7 @@ bool Object::hasObjectManager() const

 sdbus::IConnection& Object::getConnection() const
 {
-    return dynamic_cast<sdbus::IConnection&>(connection_);
+    return connection_;
 }

 const std::string& Object::getObjectPath() const
--- a/src/Object.h
+++ b/src/Object.h
@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
 *
 * @file Object.h
 *
@ -144,7 +144,7 @@ namespace sdbus::internal {

            // This is intentionally the last member, because it must be destructed first,
            // releasing callbacks above before the callbacks themselves are destructed.
-            SlotPtr slot;
+            Slot slot;
        };

        InterfaceData& getInterface(const std::string& interfaceName);
@ -177,7 +177,7 @@ namespace sdbus::internal {
        sdbus::internal::IConnection& connection_;
        std::string objectPath_;
        std::map<InterfaceName, InterfaceData> interfaces_;
-        SlotPtr objectManagerSlot_;
+        Slot objectManagerSlot_;
        std::atomic<const Message*> m_CurrentlyProcessedMessage{nullptr};
    };

--- a/src/Proxy.cpp
+++ b/src/Proxy.cpp
@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
 *
 * @file Proxy.cpp
 *
@ -127,7 +127,7 @@ MethodReply Proxy::sendMethodCallMessageAndWaitForReply(const MethodCall& messag
    auto callback = (void*)&Proxy::sdbus_async_reply_handler;
    AsyncCalls::CallData callData{*this, std::move(asyncReplyCallback), {}};

-    message.send(callback, &callData, timeout, dont_request_slot);
+    message.send(callback, &callData, timeout, floating_slot);

    return syncCallReplyData.waitForMethodReply();
 }
@ -219,7 +219,7 @@ void Proxy::unregister()

 sdbus::IConnection& Proxy::getConnection() const
 {
-    return dynamic_cast<sdbus::IConnection&>(*connection_);
+    return *connection_;
 }

 const std::string& Proxy::getObjectPath() const
@ -276,7 +276,7 @@ int Proxy::sdbus_async_reply_handler(sd_bus_message *sdbusMessage, void *userDat
        // Intentionally left blank -- sdbus-c++ exceptions shall not bubble up to the underlying C sd-bus library
    }

-    return 1;
+    return 0;
 }

 int Proxy::sdbus_signal_handler(sd_bus_message *sdbusMessage, void *userData, sd_bus_error */*retError*/)
--- a/src/Proxy.h
+++ b/src/Proxy.h
@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
 *
 * @file Proxy.h
 *
@ -103,18 +103,18 @@ namespace sdbus::internal {
            using SignalName = std::string;
            struct SignalData
            {
-                SignalData(Proxy& proxy, signal_handler callback, SlotPtr slot)
+                SignalData(Proxy& proxy, signal_handler callback, Slot slot)
                    : proxy(proxy)
                    , callback(std::move(callback))
                    , slot(std::move(slot))
                {}
                Proxy& proxy;
                signal_handler callback;
-                // slot_ must be listed after callback_ to ensure that slot_ is destructed first.
-                // Destructing the slot_ will sd_bus_slot_unref() the callback.
+                // slot must be listed after callback to ensure that slot is destructed first.
+                // Destructing the slot will sd_bus_slot_unref() the callback.
                // Only after sd_bus_slot_unref(), we can safely delete the callback. The bus mutex (SdBus::sdbusMutex_)
                // ensures that sd_bus_slot_unref() and the callback execute sequentially.
-                SlotPtr slot;
+                Slot slot;
            };
            std::map<SignalName, std::unique_ptr<SignalData>> signals_;
        };
@ -131,7 +131,7 @@ namespace sdbus::internal {
            {
                Proxy& proxy;
                async_reply_handler callback;
-                MethodCall::Slot slot;
+                Slot slot;
            };

            ~AsyncCalls()
--- a/src/ScopeGuard.h
+++ b/src/ScopeGuard.h
@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
 *
 * @file ScopeGuard.h
 *
--- a/src/SdBus.cpp
+++ b/src/SdBus.cpp
@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
 *
 * @file SdBus.cpp
 * @author Ardazishvili Roman (ardazishvili.roman@yandex.ru)
@ -166,14 +166,46 @@ int SdBus::sd_bus_open(sd_bus **ret)
    return ::sd_bus_open(ret);
 }

+int SdBus::sd_bus_open_system(sd_bus **ret)
+{
+    return ::sd_bus_open_system(ret);
+}
+
 int SdBus::sd_bus_open_user(sd_bus **ret)
 {
    return ::sd_bus_open_user(ret);
 }

-int SdBus::sd_bus_open_system(sd_bus **ret)
+int SdBus::sd_bus_open_user_with_address(sd_bus **ret, const char* address)
 {
-    return ::sd_bus_open_system(ret);
+    sd_bus* bus = nullptr;
+
+    int r = sd_bus_new(&bus);
+    if (r < 0)
+        return r;
+
+    r = sd_bus_set_address(bus, address);
+    if (r < 0)
+        return r;
+
+    r = sd_bus_set_bus_client(bus, true);
+    if (r < 0)
+        return r;
+
+    // Copying behavior from
+    // https://github.com/systemd/systemd/blob/fee6441601c979165ebcbb35472036439f8dad5f/src/libsystemd/sd-bus/sd-bus.c#L1381
+    // Here, we make the bus as trusted
+    r = sd_bus_set_trusted(bus, true);
+    if (r < 0)
+        return r;
+
+    r = sd_bus_start(bus);
+    if (r < 0)
+        return r;
+
+    *ret = bus;
+
+    return 0;
 }

 int SdBus::sd_bus_open_system_remote(sd_bus **ret, const char *host)
@ -229,6 +261,16 @@ sd_bus_slot* SdBus::sd_bus_slot_unref(sd_bus_slot *slot)
    return ::sd_bus_slot_unref(slot);
 }

+int SdBus::sd_bus_new(sd_bus **ret)
+{
+    return ::sd_bus_new(ret);
+}
+
+int SdBus::sd_bus_start(sd_bus *bus)
+{
+    return ::sd_bus_start(bus);
+}
+
 int SdBus::sd_bus_process(sd_bus *bus, sd_bus_message **r)
 {
    std::lock_guard lock(sdbusMutex_);
@ -265,6 +307,16 @@ sd_bus* SdBus::sd_bus_flush_close_unref(sd_bus *bus)
    return ::sd_bus_flush_close_unref(bus);
 }

+sd_bus* SdBus::sd_bus_close_unref(sd_bus *bus)
+{
+#if LIBSYSTEMD_VERSION>=241
+    return ::sd_bus_close_unref(bus);
+#else
+    ::sd_bus_close(bus);
+    return ::sd_bus_unref(bus);
+#endif
+}
+
 int SdBus::sd_bus_message_set_destination(sd_bus_message *m, const char *destination)
 {
    std::lock_guard lock(sdbusMutex_);
--- a/src/SdBus.h
+++ b/src/SdBus.h
@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
 *
 * @file SdBus.h
 * @author Ardazishvili Roman (ardazishvili.roman@yandex.ru)
@ -59,8 +59,9 @@ public:
    virtual int sd_bus_emit_interfaces_removed_strv(sd_bus *bus, const char *path, char **interfaces) override;

    virtual int sd_bus_open(sd_bus **ret) override;
-    virtual int sd_bus_open_user(sd_bus **ret) override;
    virtual int sd_bus_open_system(sd_bus **ret) override;
+    virtual int sd_bus_open_user(sd_bus **ret) override;
+    virtual int sd_bus_open_user_with_address(sd_bus **ret, const char* address) override;
    virtual int sd_bus_open_system_remote(sd_bus **ret, const char* hsot) override;
    virtual int sd_bus_request_name(sd_bus *bus, const char *name, uint64_t flags) override;
    virtual int sd_bus_release_name(sd_bus *bus, const char *name) override;
@ -70,11 +71,15 @@ public:
    virtual int sd_bus_add_match(sd_bus *bus, sd_bus_slot **slot, const char *match, sd_bus_message_handler_t callback, void *userdata) override;
    virtual sd_bus_slot* sd_bus_slot_unref(sd_bus_slot *slot) override;

+    virtual int sd_bus_new(sd_bus **ret) override;
+    virtual int sd_bus_start(sd_bus *bus) override;
+
    virtual int sd_bus_process(sd_bus *bus, sd_bus_message **r) override;
    virtual int sd_bus_get_poll_data(sd_bus *bus, PollData* data) override;

    virtual int sd_bus_flush(sd_bus *bus) override;
    virtual sd_bus *sd_bus_flush_close_unref(sd_bus *bus) override;
+    virtual sd_bus *sd_bus_close_unref(sd_bus *bus) override;

    virtual int sd_bus_message_set_destination(sd_bus_message *m, const char *destination) override;

--- a/src/Types.cpp
+++ b/src/Types.cpp
@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
 *
 * @file Types.cpp
 *
--- a/src/Utils.h
+++ b/src/Utils.h
@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2022 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
 *
 * @file Utils.h
 *
--- a/src/VTableUtils.c
+++ b/src/VTableUtils.c
@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
 *
 * @file VTableUtils.c
 *
--- a/src/VTableUtils.h
+++ b/src/VTableUtils.h
@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
 *
 * @file VTableUtils.h
 *
--- a/tests/integrationtests/DBusAsyncMethodsTests.cpp
+++ b/tests/integrationtests/DBusAsyncMethodsTests.cpp
@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2020 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
 *
 * @file DBusAsyncMethodsTests.cpp
 *
--- a/tests/integrationtests/DBusConnectionTests.cpp
+++ b/tests/integrationtests/DBusConnectionTests.cpp
@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2020 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
 *
 * @file DBusConnectionTests.cpp
 *
@ -130,4 +130,4 @@ TEST(Connection, PollDataGetRelativeTimeoutInTolerance)
    EXPECT_LE(pd.getRelativeTimeout().value(), TIMEOUT + TOLERANCE);
    EXPECT_GE(pd.getPollTimeout(), 900);
    EXPECT_LE(pd.getPollTimeout(), 1100);
-}
+}
--- a/tests/integrationtests/DBusGeneralTests.cpp
+++ b/tests/integrationtests/DBusGeneralTests.cpp
@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2020 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
 *
 * @file DBusGeneralTests.cpp
 *
@ -26,6 +26,7 @@

 #include "TestAdaptor.h"
 #include "TestProxy.h"
+#include "TestFixture.h"
 #include "sdbus-c++/sdbus-c++.h"

 #include <gtest/gtest.h>
@ -38,8 +39,13 @@
 #include <future>
 #include <unistd.h>

+using ::testing::ElementsAre;
+using ::testing::Eq;
+using namespace std::chrono_literals;
 using namespace sdbus::test;

+using AConnection = TestFixture;
+
 /*-------------------------------------*/
 /* --          TEST CASES           -- */
 /*-------------------------------------*/
@ -52,3 +58,75 @@ TEST(AdaptorAndProxy, CanBeConstructedSuccesfully)
    ASSERT_NO_THROW(TestAdaptor adaptor(*connection, OBJECT_PATH));
    ASSERT_NO_THROW(TestProxy proxy(BUS_NAME, OBJECT_PATH));
 }
+
+TEST_F(AConnection, WillCallCallbackHandlerForIncomingMessageMatchingMatchRule)
+{
+    auto matchRule = "sender='" + BUS_NAME + "',path='" + OBJECT_PATH + "'";
+    std::atomic<bool> matchingMessageReceived{false};
+    auto slot = s_proxyConnection->addMatch(matchRule, [&](sdbus::Message& msg)
+    {
+        if(msg.getPath() == OBJECT_PATH)
+            matchingMessageReceived = true;
+    });
+
+    m_adaptor->emitSimpleSignal();
+
+    ASSERT_TRUE(waitUntil(matchingMessageReceived));
+}
+
+TEST_F(AConnection, WillUnsubscribeMatchRuleWhenClientDestroysTheAssociatedSlot)
+{
+    auto matchRule = "sender='" + BUS_NAME + "',path='" + OBJECT_PATH + "'";
+    std::atomic<bool> matchingMessageReceived{false};
+    auto slot = s_proxyConnection->addMatch(matchRule, [&](sdbus::Message& msg)
+    {
+        if(msg.getPath() == OBJECT_PATH)
+            matchingMessageReceived = true;
+    });
+    slot.reset();
+
+    m_adaptor->emitSimpleSignal();
+
+    ASSERT_FALSE(waitUntil(matchingMessageReceived, 2s));
+}
+
+TEST_F(AConnection, CanAddFloatingMatchRule)
+{
+    auto matchRule = "sender='" + BUS_NAME + "',path='" + OBJECT_PATH + "'";
+    std::atomic<bool> matchingMessageReceived{false};
+    auto con = sdbus::createSystemBusConnection();
+    con->enterEventLoopAsync();
+    auto callback = [&](sdbus::Message& msg)
+    {
+        if(msg.getPath() == OBJECT_PATH)
+            matchingMessageReceived = true;
+    };
+    con->addMatch(matchRule, std::move(callback), sdbus::floating_slot);
+    m_adaptor->emitSimpleSignal();
+    assert(waitUntil(matchingMessageReceived, 2s));
+    matchingMessageReceived = false;
+
+    con.reset();
+    m_adaptor->emitSimpleSignal();
+
+    ASSERT_FALSE(waitUntil(matchingMessageReceived, 2s));
+}
+
+TEST_F(AConnection, WillNotPassToMatchCallbackMessagesThatDoNotMatchTheRule)
+{
+    auto matchRule = "type='signal',interface='" + INTERFACE_NAME + "',member='simpleSignal'";
+    std::atomic<size_t> numberOfMatchingMessages{};
+    auto slot = s_proxyConnection->addMatch(matchRule, [&](sdbus::Message& msg)
+    {
+        if(msg.getMemberName() == "simpleSignal")
+            numberOfMatchingMessages++;
+    });
+    auto adaptor2 = std::make_unique<TestAdaptor>(*s_adaptorConnection, OBJECT_PATH_2);
+
+    m_adaptor->emitSignalWithMap({});
+    adaptor2->emitSimpleSignal();
+    m_adaptor->emitSimpleSignal();
+
+    ASSERT_TRUE(waitUntil([&](){ return numberOfMatchingMessages == 2; }));
+    ASSERT_FALSE(waitUntil([&](){ return numberOfMatchingMessages > 2; }, 1s));
+}
--- a/tests/integrationtests/DBusMethodsTests.cpp
+++ b/tests/integrationtests/DBusMethodsTests.cpp
@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2020 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
 *
 * @file DBusMethodsTests.cpp
 *
--- a/tests/integrationtests/DBusPropertiesTests.cpp
+++ b/tests/integrationtests/DBusPropertiesTests.cpp
@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2020 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
 *
 * @file DBusPropertiesTests.cpp
 *
--- a/tests/integrationtests/DBusSignalsTests.cpp
+++ b/tests/integrationtests/DBusSignalsTests.cpp
@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
 *
 * @file AdaptorAndProxy_test.cpp
 *
--- a/tests/integrationtests/DBusStandardInterfacesTests.cpp
+++ b/tests/integrationtests/DBusStandardInterfacesTests.cpp
@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2020 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
 *
 * @file DBusStandardInterfacesTests.cpp
 *
--- a/tests/integrationtests/Defs.h
+++ b/tests/integrationtests/Defs.h
@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
 *
 * @file Defs.h
 *
--- a/tests/integrationtests/TestAdaptor.cpp
+++ b/tests/integrationtests/TestAdaptor.cpp
@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
 *
 * @file TestAdaptor.cpp
 *
--- a/tests/integrationtests/TestAdaptor.h
+++ b/tests/integrationtests/TestAdaptor.h
@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
 *
 * @file TestAdaptor.h
 *
--- a/tests/integrationtests/TestFixture.cpp
+++ b/tests/integrationtests/TestFixture.cpp
@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
 *
 * @file TestAdaptor.cpp
 *
--- a/tests/integrationtests/TestFixture.h
+++ b/tests/integrationtests/TestFixture.h
@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
 *
 * @file TestAdaptor.h
 *
--- a/tests/integrationtests/TestProxy.cpp
+++ b/tests/integrationtests/TestProxy.cpp
@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
 *
 * @file TestAdaptor.cpp
 *
--- a/tests/integrationtests/TestProxy.h
+++ b/tests/integrationtests/TestProxy.h
@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
 *
 * @file TestAdaptor.h
 *
--- a/tests/integrationtests/sdbus-c++-integration-tests.cpp
+++ b/tests/integrationtests/sdbus-c++-integration-tests.cpp
@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
 *
 * @file sdbus-c++-integration-tests.cpp
 *
--- a/tests/unittests/Connection_test.cpp
+++ b/tests/unittests/Connection_test.cpp
@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
 *
 * @file Connection_test.cpp
 * @author Ardazishvili Roman (ardazishvili.roman@yandex.ru)
@ -35,11 +35,7 @@ using ::testing::DoAll;
 using ::testing::SetArgPointee;
 using ::testing::Return;
 using ::testing::NiceMock;
-using sdbus::internal::Connection;
-constexpr sdbus::internal::Connection::default_bus_t default_bus;
-constexpr sdbus::internal::Connection::system_bus_t system_bus;
-constexpr sdbus::internal::Connection::session_bus_t session_bus;
-constexpr sdbus::internal::Connection::remote_system_bus_t remote_system_bus;
+using ::sdbus::internal::Connection;

 class ConnectionCreationTest : public ::testing::Test
 {
@ -58,81 +54,81 @@ TEST_F(ADefaultBusConnection, OpensAndFlushesBusWhenCreated)
 {
    EXPECT_CALL(*sdBusIntfMock_, sd_bus_open(_)).WillOnce(DoAll(SetArgPointee<0>(fakeBusPtr_), Return(1)));
    EXPECT_CALL(*sdBusIntfMock_, sd_bus_flush(_)).Times(1);
-    Connection(std::move(sdBusIntfMock_), default_bus);
+    Connection(std::move(sdBusIntfMock_), Connection::default_bus);
 }

 TEST_F(ASystemBusConnection, OpensAndFlushesBusWhenCreated)
 {
    EXPECT_CALL(*sdBusIntfMock_, sd_bus_open_system(_)).WillOnce(DoAll(SetArgPointee<0>(fakeBusPtr_), Return(1)));
    EXPECT_CALL(*sdBusIntfMock_, sd_bus_flush(_)).Times(1);
-    Connection(std::move(sdBusIntfMock_), system_bus);
+    Connection(std::move(sdBusIntfMock_), Connection::system_bus);
 }

 TEST_F(ASessionBusConnection, OpensAndFlushesBusWhenCreated)
 {
    EXPECT_CALL(*sdBusIntfMock_, sd_bus_open_user(_)).WillOnce(DoAll(SetArgPointee<0>(fakeBusPtr_), Return(1)));
    EXPECT_CALL(*sdBusIntfMock_, sd_bus_flush(_)).Times(1);
-    Connection(std::move(sdBusIntfMock_), session_bus);
+    Connection(std::move(sdBusIntfMock_), Connection::session_bus);
 }

 TEST_F(ADefaultBusConnection, ClosesAndUnrefsBusWhenDestructed)
 {
    ON_CALL(*sdBusIntfMock_, sd_bus_open(_)).WillByDefault(DoAll(SetArgPointee<0>(fakeBusPtr_), Return(1)));
    EXPECT_CALL(*sdBusIntfMock_, sd_bus_flush_close_unref(_)).Times(1);
-    Connection(std::move(sdBusIntfMock_), default_bus);
+    Connection(std::move(sdBusIntfMock_), Connection::default_bus);
 }

 TEST_F(ASystemBusConnection, ClosesAndUnrefsBusWhenDestructed)
 {
    ON_CALL(*sdBusIntfMock_, sd_bus_open_system(_)).WillByDefault(DoAll(SetArgPointee<0>(fakeBusPtr_), Return(1)));
    EXPECT_CALL(*sdBusIntfMock_, sd_bus_flush_close_unref(_)).Times(1);
-    Connection(std::move(sdBusIntfMock_), system_bus);
+    Connection(std::move(sdBusIntfMock_), Connection::system_bus);
 }

 TEST_F(ASessionBusConnection, ClosesAndUnrefsBusWhenDestructed)
 {
    ON_CALL(*sdBusIntfMock_, sd_bus_open_user(_)).WillByDefault(DoAll(SetArgPointee<0>(fakeBusPtr_), Return(1)));
    EXPECT_CALL(*sdBusIntfMock_, sd_bus_flush_close_unref(_)).Times(1);
-    Connection(std::move(sdBusIntfMock_), session_bus);
+    Connection(std::move(sdBusIntfMock_), Connection::session_bus);
 }

 TEST_F(ADefaultBusConnection, ThrowsErrorWhenOpeningTheBusFailsDuringConstruction)
 {
    ON_CALL(*sdBusIntfMock_, sd_bus_open(_)).WillByDefault(DoAll(SetArgPointee<0>(fakeBusPtr_), Return(-1)));
-    ASSERT_THROW(Connection(std::move(sdBusIntfMock_), default_bus), sdbus::Error);
+    ASSERT_THROW(Connection(std::move(sdBusIntfMock_), Connection::default_bus), sdbus::Error);
 }

 TEST_F(ASystemBusConnection, ThrowsErrorWhenOpeningTheBusFailsDuringConstruction)
 {
    ON_CALL(*sdBusIntfMock_, sd_bus_open_system(_)).WillByDefault(DoAll(SetArgPointee<0>(fakeBusPtr_), Return(-1)));
-    ASSERT_THROW(Connection(std::move(sdBusIntfMock_), system_bus), sdbus::Error);
+    ASSERT_THROW(Connection(std::move(sdBusIntfMock_), Connection::system_bus), sdbus::Error);
 }

 TEST_F(ASessionBusConnection, ThrowsErrorWhenOpeningTheBusFailsDuringConstruction)
 {
    ON_CALL(*sdBusIntfMock_, sd_bus_open_user(_)).WillByDefault(DoAll(SetArgPointee<0>(fakeBusPtr_), Return(-1)));
-    ASSERT_THROW(Connection(std::move(sdBusIntfMock_), session_bus), sdbus::Error);
+    ASSERT_THROW(Connection(std::move(sdBusIntfMock_), Connection::session_bus), sdbus::Error);
 }

 TEST_F(ADefaultBusConnection, ThrowsErrorWhenFlushingTheBusFailsDuringConstruction)
 {
    ON_CALL(*sdBusIntfMock_, sd_bus_open(_)).WillByDefault(DoAll(SetArgPointee<0>(fakeBusPtr_), Return(1)));
    ON_CALL(*sdBusIntfMock_, sd_bus_flush(_)).WillByDefault(Return(-1));
-    ASSERT_THROW(Connection(std::move(sdBusIntfMock_), default_bus), sdbus::Error);
+    ASSERT_THROW(Connection(std::move(sdBusIntfMock_), Connection::default_bus), sdbus::Error);
 }

 TEST_F(ASystemBusConnection, ThrowsErrorWhenFlushingTheBusFailsDuringConstruction)
 {
    ON_CALL(*sdBusIntfMock_, sd_bus_open_system(_)).WillByDefault(DoAll(SetArgPointee<0>(fakeBusPtr_), Return(1)));
    ON_CALL(*sdBusIntfMock_, sd_bus_flush(_)).WillByDefault(Return(-1));
-    ASSERT_THROW(Connection(std::move(sdBusIntfMock_), system_bus), sdbus::Error);
+    ASSERT_THROW(Connection(std::move(sdBusIntfMock_), Connection::system_bus), sdbus::Error);
 }

 TEST_F(ASessionBusConnection, ThrowsErrorWhenFlushingTheBusFailsDuringConstruction)
 {
    ON_CALL(*sdBusIntfMock_, sd_bus_open_user(_)).WillByDefault(DoAll(SetArgPointee<0>(fakeBusPtr_), Return(1)));
    ON_CALL(*sdBusIntfMock_, sd_bus_flush(_)).WillByDefault(Return(-1));
-    ASSERT_THROW(Connection(std::move(sdBusIntfMock_), session_bus), sdbus::Error);
+    ASSERT_THROW(Connection(std::move(sdBusIntfMock_), Connection::session_bus), sdbus::Error);
 }

 namespace
@ -169,24 +165,40 @@ template<> void AConnectionNameRequest<Connection::session_bus_t>::setUpBusOpenE
 {
    EXPECT_CALL(*sdBusIntfMock_, sd_bus_open_user(_)).WillOnce(DoAll(SetArgPointee<0>(fakeBusPtr_), Return(1)));
 }
+template<> void AConnectionNameRequest<Connection::custom_session_bus_t>::setUpBusOpenExpectation()
+{
+    EXPECT_CALL(*sdBusIntfMock_, sd_bus_open_user_with_address(_, _)).WillOnce(DoAll(SetArgPointee<0>(fakeBusPtr_), Return(1)));
+}
 template<> void AConnectionNameRequest<Connection::remote_system_bus_t>::setUpBusOpenExpectation()
 {
    EXPECT_CALL(*sdBusIntfMock_, sd_bus_open_system_remote(_, _)).WillOnce(DoAll(SetArgPointee<0>(fakeBusPtr_), Return(1)));
 }
+template<> void AConnectionNameRequest<Connection::pseudo_bus_t>::setUpBusOpenExpectation()
+{
+    EXPECT_CALL(*sdBusIntfMock_, sd_bus_new(_)).WillOnce(DoAll(SetArgPointee<0>(fakeBusPtr_), Return(1)));
+    // `sd_bus_start` for pseudo connection shall return an error value, remember this is a fake connection...
+    EXPECT_CALL(*sdBusIntfMock_, sd_bus_start(fakeBusPtr_)).WillOnce(Return(-EINVAL));
+}
 template <typename _BusTypeTag>
 std::unique_ptr<Connection> AConnectionNameRequest<_BusTypeTag>::makeConnection()
 {
    return std::make_unique<Connection>(std::unique_ptr<NiceMock<SdBusMock>>(sdBusIntfMock_), _BusTypeTag{});
 }
+template<> std::unique_ptr<Connection> AConnectionNameRequest<Connection::custom_session_bus_t>::makeConnection()
+{
+    return std::make_unique<Connection>(std::unique_ptr<NiceMock<SdBusMock>>(sdBusIntfMock_), Connection::custom_session_bus, "custom session bus");
+}
 template<> std::unique_ptr<Connection> AConnectionNameRequest<Connection::remote_system_bus_t>::makeConnection()
 {
-    return std::make_unique<Connection>(std::unique_ptr<NiceMock<SdBusMock>>(sdBusIntfMock_), remote_system_bus, "some host");
+    return std::make_unique<Connection>(std::unique_ptr<NiceMock<SdBusMock>>(sdBusIntfMock_), Connection::remote_system_bus, "some host");
 }

 typedef ::testing::Types< Connection::default_bus_t
                        , Connection::system_bus_t
                        , Connection::session_bus_t
+                        , Connection::custom_session_bus_t
                        , Connection::remote_system_bus_t
+                        , Connection::pseudo_bus_t
                        > BusTypeTags;

 TYPED_TEST_SUITE(AConnectionNameRequest, BusTypeTags);
--- a/tests/unittests/Message_test.cpp
+++ b/tests/unittests/Message_test.cpp
@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
 *
 * @file Message_test.cpp
 *
--- a/tests/unittests/TypeTraits_test.cpp
+++ b/tests/unittests/TypeTraits_test.cpp
@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
 *
 * @file TypeTraits_test.cpp
 *
--- a/tests/unittests/Types_test.cpp
+++ b/tests/unittests/Types_test.cpp
@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
 *
 * @file Types_test.cpp
 *
--- a/tests/unittests/mocks/SdBusMock.h
+++ b/tests/unittests/mocks/SdBusMock.h
@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
 *
 * @file SdBusMock.h
 * @author Ardazishvili Roman (ardazishvili.roman@yandex.ru)
@ -58,8 +58,9 @@ public:
    MOCK_METHOD3(sd_bus_emit_interfaces_removed_strv, int(sd_bus *bus, const char *path, char **interfaces));

    MOCK_METHOD1(sd_bus_open, int(sd_bus **ret));
-    MOCK_METHOD1(sd_bus_open_user, int(sd_bus **ret));
    MOCK_METHOD1(sd_bus_open_system, int(sd_bus **ret));
+    MOCK_METHOD1(sd_bus_open_user, int(sd_bus **ret));
+    MOCK_METHOD2(sd_bus_open_user_with_address, int(sd_bus **ret, const char* address));
    MOCK_METHOD2(sd_bus_open_system_remote, int(sd_bus **ret, const char *host));
    MOCK_METHOD3(sd_bus_request_name, int(sd_bus *bus, const char *name, uint64_t flags));
    MOCK_METHOD2(sd_bus_release_name, int(sd_bus *bus, const char *name));
@ -69,11 +70,15 @@ public:
    MOCK_METHOD5(sd_bus_add_match, int(sd_bus *bus, sd_bus_slot **slot, const char *match, sd_bus_message_handler_t callback, void *userdata));
    MOCK_METHOD1(sd_bus_slot_unref, sd_bus_slot*(sd_bus_slot *slot));

+    MOCK_METHOD1(sd_bus_new, int(sd_bus **ret));
+    MOCK_METHOD1(sd_bus_start, int(sd_bus *bus));
+
    MOCK_METHOD2(sd_bus_process, int(sd_bus *bus, sd_bus_message **r));
    MOCK_METHOD2(sd_bus_get_poll_data, int(sd_bus *bus, PollData* data));

    MOCK_METHOD1(sd_bus_flush, int(sd_bus *bus));
    MOCK_METHOD1(sd_bus_flush_close_unref, sd_bus *(sd_bus *bus));
+    MOCK_METHOD1(sd_bus_close_unref, sd_bus *(sd_bus *bus));

    MOCK_METHOD2(sd_bus_message_set_destination, int(sd_bus_message *m, const char *destination));

--- a/tests/unittests/sdbus-c++-unit-tests.cpp
+++ b/tests/unittests/sdbus-c++-unit-tests.cpp
@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
 *
 * @file sdbus-c++-unit-tests.cpp
 *
--- a/tools/CMakeLists.txt
+++ b/tools/CMakeLists.txt
@ -4,7 +4,7 @@

 cmake_minimum_required(VERSION 3.5)

-project(sdbus-c++-tools VERSION 1.1.0)
+project(sdbus-c++-tools VERSION 1.2.0)

 include(GNUInstallDirs)

--- a/tools/xml2cpp-codegen/AdaptorGenerator.cpp
+++ b/tools/xml2cpp-codegen/AdaptorGenerator.cpp
@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
 *
 * @file AdaptorGenerator.cpp
 *
--- a/tools/xml2cpp-codegen/AdaptorGenerator.h
+++ b/tools/xml2cpp-codegen/AdaptorGenerator.h
@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
 *
 * @file AdaptorGenerator.h
 *
--- a/tools/xml2cpp-codegen/BaseGenerator.cpp
+++ b/tools/xml2cpp-codegen/BaseGenerator.cpp
@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
 *
 * @file BaseGenerator.cpp
 *
@ -182,4 +182,3 @@ std::string BaseGenerator::outArgsToType(const Nodes& args, bool bareList) const

    return retTypeSS.str();
 }
-
--- a/tools/xml2cpp-codegen/BaseGenerator.h
+++ b/tools/xml2cpp-codegen/BaseGenerator.h
@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
 *
 * @file BaseGenerator.h
 *
--- a/tools/xml2cpp-codegen/ProxyGenerator.cpp
+++ b/tools/xml2cpp-codegen/ProxyGenerator.cpp
@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
 *
 * @file ProxyGenerator.cpp
 *
--- a/tools/xml2cpp-codegen/ProxyGenerator.h
+++ b/tools/xml2cpp-codegen/ProxyGenerator.h
@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
 *
 * @file ProxyGenerator.h
 *
--- a/tools/xml2cpp-codegen/generator_utils.cpp
+++ b/tools/xml2cpp-codegen/generator_utils.cpp
@ -85,6 +85,15 @@ static void _parse_signature(const std::string &signature, std::string &type, un

                        break;
                    }
+                    case '\0':
+                    {
+                        std::cerr << 
+                            "Invalid array definition. Type is missing after '" << signature
+                            << "'."
+                            << std::endl;
+                        exit(-1);
+                    }
+
                    default:
                    {
                        type += "std::vector<";
--- a/tools/xml2cpp-codegen/xml.cpp
+++ b/tools/xml2cpp-codegen/xml.cpp
@ -292,12 +292,12 @@ void Document::Expat::character_data_handler(void* data, const XML_Char* chars,
        nod = &(nod->children.back());
    }

-    int x = 0, y = len - 1;
+    int offset = 0, count = len;

-    while (isspace(chars[y]) && y > 0) --y;
-    while (isspace(chars[x]) && x < y) ++x;
+    while (count > 0 && isspace(chars[count - 1])) --count;
+    while (offset < count && isspace(chars[offset])) { ++offset; --count; }

-    nod->cdata = std::string(chars, x, y + 1);
+    nod->cdata = std::string{chars + offset, static_cast<std::string::size_type>(count)};
 }

 void Document::Expat::end_element_handler(void* data, const XML_Char* /*name*/)
--- a/tools/xml2cpp-codegen/xml2cpp.cpp
+++ b/tools/xml2cpp-codegen/xml2cpp.cpp
@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
 *
 * @file xml2cpp.cpp
 *
Author	SHA1	Message	Date
0xFEEDC0DE64	e199dc58cf	Dont use deprecated api	2025-02-12 17:23:42 +01:00
0xFEEDC0DE64	ad7731d900	Fix out of memory access in parser	2023-07-04 19:09:53 +02:00
Taras Zaporozhets	101dd1c2ba	Add boost asio integration	2022-10-30 18:35:47 +01:00
Taras Zaporozhets	299e6940cd	Improve ABI	2022-10-30 18:17:51 +01:00
Taras Zaporozhets	3f825ffb30	Force event loop to re-enter processing to handle queued messages	2022-09-04 23:26:14 +02:00
James Le Cuirot	35bffd0f25	build: don't include libsystemd as shared pkg-config dep when statically linked (#283 ) This works whether `BUILD_LIBSYSTEMD` is `ON` or the separate build of libsystemd picked up by pkg-config is static. The Gentoo Linux package requires the latter. This change also handles `BUILD_SHARED_LIBS` being `OFF`. In this case, the libsystemd dependency does need to be included, even though it is static. CMake does not allow you to build shared and static libraries simultaneously (with a single `add_library` call), but this change declares the libsystemd dependency as `Requires.private` rather than omitting it entirely. This is in case someone builds and installs both a static and shared build and then calls `pkg-config --static sdbus-c++`. The static build needs to be installed first so that the pkg-config file from the shared build takes precedence.	2022-09-03 22:54:06 +02:00
b-s-e	e33a890ce7	docs: fix send_destination property (#284 )	2022-08-26 16:49:51 +02:00
Stanislav Angelovic	751c1addc4	chore: version 1.2.0	2022-08-09 09:50:33 +02:00
Stanislav Angelovic	2991fa4960	refactor: use pseudo D-Bus connection for plain messages	2022-08-09 08:55:29 +02:00
alivenets	0f2362d8c3	feat: add support for session bus connection at custom address (#273 ) * Add methods to initiate custom session bus connection The new function helper `createSessionBusConnectionWithAddress` allows to create connection to session bus with custom address. Signed-off-by: Alexander Livenets <a.livenets@gmail.com> * feat: add support for session bus connection at custom address Co-authored-by: Stanislav Angelovic <stanislav.angelovic@siemens.com>	2022-08-08 13:54:09 +02:00
Stanislav Angelovic	e07c1f3981	chore: update doxygen header info	2022-07-05 18:10:05 +02:00
Stanislav Angelovic	58426966f4	feat: add CMake variable for extra libsystemd config options	2022-06-27 15:01:06 +02:00
Stanislav Angelovic	4e105081c9	fix: remove executable flag from source files	2022-06-27 12:17:18 +02:00
Stanislav Angelovic	5ec6027d5f	feat: add support for match rules	2022-06-27 12:14:57 +02:00
Stanislav Angelovic	d864e1dfa4	refactor: rename dont_request_slot tag to floating_slot	2022-06-27 12:05:06 +02:00
Stanislav Angelovic	b7f3d7c876	refactor: little fixes and reorganizations around Connection class	2022-06-22 18:12:42 +02:00
Stanislav Angelovic	2a4c241303	docs: add more info on D-Bus security policy file	2022-06-22 18:12:13 +02:00
Michael Binz	5e933c3f17	Detects missing type after array declaration. Fixes #253 . (#255 ) Co-authored-by: Michael Binz <michael.binz@daimler.com>	2022-06-19 23:02:54 +02:00
Sergey Bobrenok	b5aee6d019	docs: add information about Buildroot package (#252 )	2022-06-07 08:45:34 +02:00