diff --git a/libipmid/Makefile.am b/libipmid/Makefile.am
index e5724a8..ac35bbf 100644
--- a/libipmid/Makefile.am
+++ b/libipmid/Makefile.am
@@ -1,8 +1,21 @@
+COMMON_CXX = \
+	-flto \
+	-Wno-psabi \
+	$(SYSTEMD_CFLAGS) \
+	$(SDBUSPLUS_CFLAGS) \
+	-DBOOST_ERROR_CODE_HEADER_ONLY \
+	-DBOOST_SYSTEM_NO_DEPRECATED \
+	-DBOOST_COROUTINES_NO_DEPRECATION_WARNING \
+	-DBOOST_ASIO_DISABLE_THREADS \
+	-DBOOST_ALL_NO_LIB
+
 pkgconfig_DATA = libipmid.pc
 lib_LTLIBRARIES = libipmid.la
-libipmid_la_SOURCES =
+libipmid_la_SOURCES = \
+	sdbus-asio.cpp \
+	systemintf-sdbus.cpp
 libipmid_la_LDFLAGS = \
 	$(SYSTEMD_LIBS) \
 	-version-info 0:0:0 -shared
 libipmid_la_CXXFLAGS = \
-	$(SYSTEMD_CFLAGS)
+	$(COMMON_CXX)
diff --git a/libipmid/sdbus-asio.cpp b/libipmid/sdbus-asio.cpp
new file mode 100644
index 0000000..e505797
--- /dev/null
+++ b/libipmid/sdbus-asio.cpp
@@ -0,0 +1,31 @@
+#include <boost/asio.hpp>
+#include <memory>
+#include <sdbusplus/asio/connection.hpp>
+
+namespace
+{
+
+std::shared_ptr<boost::asio::io_context> ioCtx;
+std::shared_ptr<sdbusplus::asio::connection> sdbusp;
+
+} // namespace
+
+void setIoContext(std::shared_ptr<boost::asio::io_context>& newIo)
+{
+    ioCtx = newIo;
+}
+
+std::shared_ptr<boost::asio::io_context> getIoContext()
+{
+    return ioCtx;
+}
+
+void setSdBus(std::shared_ptr<sdbusplus::asio::connection>& newBus)
+{
+    sdbusp = newBus;
+}
+
+std::shared_ptr<sdbusplus::asio::connection> getSdBus()
+{
+    return sdbusp;
+}
diff --git a/libipmid/systemintf-sdbus.cpp b/libipmid/systemintf-sdbus.cpp
new file mode 100644
index 0000000..abd30ec
--- /dev/null
+++ b/libipmid/systemintf-sdbus.cpp
@@ -0,0 +1,32 @@
+#include <ipmid/api.hpp>
+#include <memory>
+#include <sdbusplus/asio/connection.hpp>
+
+namespace
+{
+
+std::unique_ptr<sdbusplus::asio::connection> sdbusp;
+
+} // namespace
+
+/**
+ * @brief ipmid_get_sdbus_plus_handler is used by some ipmi providers
+ *
+ * @return: a reference to a unique pointer of the systemd connection
+ *          managed by the systemintfcmds code
+ */
+std::unique_ptr<sdbusplus::asio::connection>& ipmid_get_sdbus_plus_handler()
+{
+    if (!sdbusp)
+    {
+        // Create a new sdbus connection so it can have a well-known name
+        sd_bus* bus = nullptr;
+        sd_bus_open_system(&bus);
+        if (bus)
+        {
+            sdbusp = std::make_unique<sdbusplus::asio::connection>(
+                *getIoContext(), bus);
+        }
+    }
+    return sdbusp;
+}
