Improve ABI

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.

CMakeLists.txt

@@ -210,6 +210,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)

docs/systemd-dbus-config.md

@@ -41,7 +41,7 @@ Typical default D-Bus configuration does not allow to register services except e
 <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>

include/sdbus-c++/IConnection.h

@@ -78,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.
              *

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}

src/Connection.cpp

@@ -75,11 +75,16 @@ Connection::Connection(std::unique_ptr<ISdBus>&& interface, pseudo_bus_t)
     , 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)
@@ -141,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
@@ -445,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.

src/Connection.h

@@ -139,6 +139,7 @@ namespace sdbus::internal {
         void notifyEventLoop(int fd) const;
         void notifyEventLoopToExit() const;
         void clearEventLoopNotification(int fd) const;
+        void notifyEventLoop() const override;
         void notifyEventLoopNewTimeout() const override;
 
     private:

src/IConnection.h

@@ -90,6 +90,7 @@ namespace sdbus::internal {
                                                         , sd_bus_message_handler_t callback
                                                         , void* userData ) = 0;
 
+        virtual void notifyEventLoop() const = 0;
         virtual void notifyEventLoopNewTimeout() const = 0;
         virtual MethodReply tryCallMethodSynchronously(const MethodCall& message, uint64_t timeout) = 0;
     };

src/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,6 +794,10 @@ 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
 }