diff --git a/Makefile.am b/Makefile.am
index 890b9f6..ce96af7 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -10,11 +10,11 @@
 	ipmid
 
 ipmid_SOURCES = \
-	ipmid.cpp \
+	ipmid-new.cpp \
 	settings.cpp \
 	host-cmd-manager.cpp \
-	utils.cpp \
-	oemrouter.cpp
+	utils.cpp
+
 nodist_ipmid_SOURCES = ipmiwhitelist.cpp
 
 libipmi20_BUILT_LIST = \
@@ -46,6 +46,7 @@
 ipmid_CXXFLAGS = $(COMMON_CXX)
 ipmid_LDADD = \
 	libipmid/libipmid.la \
+	user_channel/libchannellayer.la \
 	libipmid-host/libipmid-host.la
 ipmid_LDFLAGS = \
 	$(SYSTEMD_LIBS) \
@@ -54,8 +55,8 @@
 	$(PHOSPHOR_LOGGING_LIBS) \
 	$(PHOSPHOR_DBUS_INTERFACES_LIBS) \
 	$(CRYPTO_LIBS) \
+	-lboost_coroutine \
 	-lstdc++fs \
-	-pthread \
 	-export-dynamic
 
 # TODO: Rather than use -export-dynamic, we should use -export-symbol to have a
@@ -116,6 +117,7 @@
 	$(PHOSPHOR_LOGGING_LIBS) \
 	$(PHOSPHOR_DBUS_INTERFACES_LIBS) \
 	-lstdc++fs \
+	-lboost_coroutine \
 	-version-info 0:0:0 -shared
 libipmi20_la_CXXFLAGS = $(COMMON_CXX)
 
diff --git a/include/ipmid-host/cmd.hpp b/include/ipmid-host/cmd.hpp
index adea960..e46c485 100644
--- a/include/ipmid-host/cmd.hpp
+++ b/include/ipmid-host/cmd.hpp
@@ -2,9 +2,5 @@
 #include <memory>
 #include <sdbusplus/bus.hpp>
 
-// Need this to use new sdbusplus compatible interfaces
-using sdbusPtr = std::unique_ptr<sdbusplus::bus::bus>;
-extern sdbusPtr& ipmid_get_sdbus_plus_handler();
-
 // Global Host Bound Command manager
 extern void ipmid_send_cmd_to_host(phosphor::host::command::CommandHandler&&);
diff --git a/ipmid-new.cpp b/ipmid-new.cpp
new file mode 100644
index 0000000..fb57666
--- /dev/null
+++ b/ipmid-new.cpp
@@ -0,0 +1,459 @@
+/**
+ * Copyright © 2018 Intel Corporation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include "config.h"
+
+#include "settings.hpp"
+
+#include <dlfcn.h>
+
+#include <algorithm>
+#include <any>
+#include <exception>
+#include <forward_list>
+#include <host-cmd-manager.hpp>
+#include <ipmid-host/cmd.hpp>
+#include <ipmid/api.hpp>
+#include <ipmid/handler.hpp>
+#include <ipmid/message.hpp>
+#include <ipmid/oemrouter.hpp>
+#include <ipmid/registration.hpp>
+#include <map>
+#include <memory>
+#include <optional>
+#include <phosphor-logging/log.hpp>
+#include <sdbusplus/asio/connection.hpp>
+#include <sdbusplus/asio/object_server.hpp>
+#include <sdbusplus/asio/sd_event.hpp>
+#include <sdbusplus/bus.hpp>
+#include <sdbusplus/bus/match.hpp>
+#include <sdbusplus/timer.hpp>
+#include <tuple>
+#include <types.hpp>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+#if __has_include(<filesystem>)
+#include <filesystem>
+#elif __has_include(<experimental/filesystem>)
+#include <experimental/filesystem>
+namespace std
+{
+// splice experimental::filesystem into std
+namespace filesystem = std::experimental::filesystem;
+} // namespace std
+#else
+#error filesystem not available
+#endif
+
+namespace fs = std::filesystem;
+
+using namespace phosphor::logging;
+
+// Global timer for network changes
+std::unique_ptr<phosphor::Timer> networkTimer = nullptr;
+
+// IPMI Spec, shared Reservation ID.
+static unsigned short selReservationID = 0xFFFF;
+static bool selReservationValid = false;
+
+unsigned short reserveSel(void)
+{
+    // IPMI spec, Reservation ID, the value simply increases against each
+    // execution of the Reserve SEL command.
+    if (++selReservationID == 0)
+    {
+        selReservationID = 1;
+    }
+    selReservationValid = true;
+    return selReservationID;
+}
+
+bool checkSELReservation(unsigned short id)
+{
+    return (selReservationValid && selReservationID == id);
+}
+
+void cancelSELReservation(void)
+{
+    selReservationValid = false;
+}
+
+EInterfaceIndex getInterfaceIndex(void)
+{
+    return interfaceKCS;
+}
+
+sd_bus* bus;
+sd_event* events = nullptr;
+sd_event* ipmid_get_sd_event_connection(void)
+{
+    return events;
+}
+sd_bus* ipmid_get_sd_bus_connection(void)
+{
+    return bus;
+}
+
+namespace ipmi
+{
+
+static inline unsigned int makeCmdKey(unsigned int cluster, unsigned int cmd)
+{
+    return (cluster << 8) | cmd;
+}
+
+using HandlerTuple = std::tuple<int,                        /* prio */
+                                Privilege, HandlerBase::ptr /* handler */
+                                >;
+
+/* map to handle standard registered commands */
+static std::unordered_map<unsigned int, /* key is NetFn/Cmd */
+                          HandlerTuple>
+    handlerMap;
+
+namespace impl
+{
+/* common function to register all standard IPMI handlers */
+bool registerHandler(int prio, NetFn netFn, Cmd cmd, Privilege priv,
+                     HandlerBase::ptr handler)
+{
+    // check for valid NetFn: even; 00-0Ch, 30-3Eh
+    if (netFn & 1 || (netFn > netFnTransport && netFn < netFnGroup) ||
+        netFn > netFnOemEight)
+    {
+        return false;
+    }
+
+    // create key and value for this handler
+    unsigned int netFnCmd = makeCmdKey(netFn, cmd);
+    HandlerTuple item(prio, priv, handler);
+
+    // consult the handler map and look for a match
+    auto& mapCmd = handlerMap[netFnCmd];
+    if (!std::get<HandlerBase::ptr>(mapCmd) || std::get<int>(mapCmd) <= prio)
+    {
+        mapCmd = item;
+        return true;
+    }
+    return false;
+}
+
+} // namespace impl
+
+message::Response::ptr executeIpmiCommandCommon(
+    std::unordered_map<unsigned int, HandlerTuple>& handlers,
+    unsigned int keyCommon, message::Request::ptr request)
+{
+    Cmd cmd = request->ctx->cmd;
+    unsigned int key = makeCmdKey(keyCommon, cmd);
+    auto cmdIter = handlers.find(key);
+    if (cmdIter != handlers.end())
+    {
+        HandlerTuple& chosen = cmdIter->second;
+        if (request->ctx->priv < std::get<Privilege>(chosen))
+        {
+            return errorResponse(request, ccInsufficientPrivilege);
+        }
+        return std::get<HandlerBase::ptr>(chosen)->call(request);
+    }
+    else
+    {
+        unsigned int wildcard = makeCmdKey(keyCommon, cmdWildcard);
+        cmdIter = handlers.find(wildcard);
+        if (cmdIter != handlers.end())
+        {
+            HandlerTuple& chosen = cmdIter->second;
+            if (request->ctx->priv < std::get<Privilege>(chosen))
+            {
+                return errorResponse(request, ccInsufficientPrivilege);
+            }
+            return std::get<HandlerBase::ptr>(chosen)->call(request);
+        }
+    }
+    return errorResponse(request, ccInvalidCommand);
+}
+
+message::Response::ptr executeIpmiCommand(message::Request::ptr request)
+{
+    NetFn netFn = request->ctx->netFn;
+    // TODO: handler OEM and group OEM commands here
+    return executeIpmiCommandCommon(handlerMap, netFn, request);
+}
+
+/* called from sdbus async server context */
+auto executionEntry(boost::asio::yield_context yield, NetFn netFn, uint8_t lun,
+                    Cmd cmd, std::vector<uint8_t>& data,
+                    std::map<std::string, ipmi::Value>& options)
+{
+    auto ctx = std::make_shared<ipmi::Context>(netFn, cmd, 0, 0,
+                                               ipmi::Privilege::Admin, &yield);
+    auto request = std::make_shared<ipmi::message::Request>(
+        ctx, std::forward<std::vector<uint8_t>>(data));
+    message::Response::ptr response = executeIpmiCommand(request);
+
+    // Responses in IPMI require a bit set.  So there ya go...
+    netFn |= 0x01;
+    return std::make_tuple(netFn, lun, cmd, response->cc,
+                           response->payload.raw);
+}
+
+/** @struct IpmiProvider
+ *
+ *  RAII wrapper for dlopen so that dlclose gets called on exit
+ */
+struct IpmiProvider
+{
+  public:
+    /** @brief address of the opened library */
+    void* addr;
+    std::string name;
+
+    IpmiProvider() = delete;
+    IpmiProvider(const IpmiProvider&) = delete;
+    IpmiProvider& operator=(const IpmiProvider&) = delete;
+    IpmiProvider(IpmiProvider&&) = delete;
+    IpmiProvider& operator=(IpmiProvider&&) = delete;
+
+    /** @brief dlopen a shared object file by path
+     *  @param[in]  filename - path of shared object to open
+     */
+    explicit IpmiProvider(const char* fname) : addr(nullptr), name(fname)
+    {
+        log<level::DEBUG>("Open IPMI provider library",
+                          entry("PROVIDER=%s", name.c_str()));
+        try
+        {
+            addr = dlopen(name.c_str(), RTLD_NOW);
+        }
+        catch (std::exception& e)
+        {
+            log<level::ERR>("ERROR opening IPMI provider",
+                            entry("PROVIDER=%s", name.c_str()),
+                            entry("ERROR=%s", e.what()));
+        }
+        catch (...)
+        {
+            std::exception_ptr eptr = std::current_exception();
+            try
+            {
+                std::rethrow_exception(eptr);
+            }
+            catch (std::exception& e)
+            {
+                log<level::ERR>("ERROR opening IPMI provider",
+                                entry("PROVIDER=%s", name.c_str()),
+                                entry("ERROR=%s", e.what()));
+            }
+        }
+        if (!isOpen())
+        {
+            log<level::ERR>("ERROR opening IPMI provider",
+                            entry("PROVIDER=%s", name.c_str()),
+                            entry("ERROR=%s", dlerror()));
+        }
+    }
+
+    ~IpmiProvider()
+    {
+        if (isOpen())
+        {
+            dlclose(addr);
+        }
+    }
+    bool isOpen() const
+    {
+        return (nullptr != addr);
+    }
+};
+
+// Plugin libraries need to contain .so either at the end or in the middle
+constexpr const char ipmiPluginExtn[] = ".so";
+
+/* return a list of self-closing library handles */
+std::forward_list<IpmiProvider> loadProviders(const fs::path& ipmiLibsPath)
+{
+    std::vector<fs::path> libs;
+    for (const auto& libPath : fs::directory_iterator(ipmiLibsPath))
+    {
+        fs::path fname = libPath.path();
+        while (fname.has_extension())
+        {
+            fs::path extn = fname.extension();
+            if (extn == ipmiPluginExtn)
+            {
+                libs.push_back(libPath.path());
+                break;
+            }
+            fname.replace_extension();
+        }
+    }
+    std::sort(libs.begin(), libs.end());
+
+    std::forward_list<IpmiProvider> handles;
+    for (auto& lib : libs)
+    {
+#ifdef __IPMI_DEBUG__
+        log<level::DEBUG>("Registering handler",
+                          entry("HANDLER=%s", lib.c_str()));
+#endif
+        handles.emplace_front(lib.c_str());
+    }
+    return handles;
+}
+
+} // namespace ipmi
+
+static std::shared_ptr<boost::asio::io_service> io;
+std::shared_ptr<boost::asio::io_service> getIoService()
+{
+    return io;
+}
+
+static std::shared_ptr<sdbusplus::asio::connection> sdbusp;
+std::shared_ptr<sdbusplus::asio::connection> getSdBus()
+{
+    return sdbusp;
+}
+
+#ifdef ALLOW_DEPRECATED_API
+/* legacy registration */
+void ipmi_register_callback(ipmi_netfn_t netFn, ipmi_cmd_t cmd,
+                            ipmi_context_t context, ipmid_callback_t handler,
+                            ipmi_cmd_privilege_t priv)
+{
+    auto h = ipmi::makeLegacyHandler(handler);
+    // translate priv from deprecated enum to current
+    ipmi::Privilege realPriv;
+    switch (priv)
+    {
+        case PRIVILEGE_CALLBACK:
+            realPriv = ipmi::Privilege::Callback;
+            break;
+        case PRIVILEGE_USER:
+            realPriv = ipmi::Privilege::User;
+            break;
+        case PRIVILEGE_OPERATOR:
+            realPriv = ipmi::Privilege::Operator;
+            break;
+        case PRIVILEGE_ADMIN:
+            realPriv = ipmi::Privilege::Admin;
+            break;
+        case PRIVILEGE_OEM:
+            realPriv = ipmi::Privilege::Oem;
+            break;
+        case SYSTEM_INTERFACE:
+            realPriv = ipmi::Privilege::Admin;
+            break;
+        default:
+            realPriv = ipmi::Privilege::Admin;
+            break;
+    }
+    ipmi::impl::registerHandler(ipmi::prioOpenBmcBase, netFn, cmd, realPriv, h);
+}
+
+/* legacy alternative to executionEntry */
+void handleLegacyIpmiCommand(sdbusplus::message::message& m)
+{
+    unsigned char seq, netFn, lun, cmd;
+    std::vector<uint8_t> data;
+
+    m.read(seq, netFn, lun, cmd, data);
+
+    auto ctx = std::make_shared<ipmi::Context>(netFn, cmd, 0, 0,
+                                               ipmi::Privilege::Admin);
+    auto request = std::make_shared<ipmi::message::Request>(
+        ctx, std::forward<std::vector<uint8_t>>(data));
+    ipmi::message::Response::ptr response = ipmi::executeIpmiCommand(request);
+
+    // Responses in IPMI require a bit set.  So there ya go...
+    netFn |= 0x01;
+
+    const char *dest, *path;
+    constexpr const char* DBUS_INTF = "org.openbmc.HostIpmi";
+
+    dest = m.get_sender();
+    path = m.get_path();
+    sdbusp->async_method_call([](boost::system::error_code ec) {}, dest, path,
+                              DBUS_INTF, "sendMessage", seq, netFn, lun, cmd,
+                              response->cc, response->payload.raw);
+}
+
+#endif /* ALLOW_DEPRECATED_API */
+
+// Calls host command manager to do the right thing for the command
+using CommandHandler = phosphor::host::command::CommandHandler;
+std::unique_ptr<phosphor::host::command::Manager> cmdManager;
+void ipmid_send_cmd_to_host(CommandHandler&& cmd)
+{
+    return cmdManager->execute(std::move(cmd));
+}
+
+std::unique_ptr<phosphor::host::command::Manager>& ipmid_get_host_cmd_manager()
+{
+    return cmdManager;
+}
+
+int main(int argc, char* argv[])
+{
+    // Connect to system bus
+    io = std::make_shared<boost::asio::io_service>();
+    if (argc > 1 && std::string(argv[1]) == "-session")
+    {
+        sd_bus_default_user(&bus);
+    }
+    else
+    {
+        sd_bus_default_system(&bus);
+    }
+    sdbusp = std::make_shared<sdbusplus::asio::connection>(*io, bus);
+    sdbusp->request_name("xyz.openbmc_project.Ipmi.Host");
+
+    // TODO: Hack to keep the sdEvents running.... Not sure why the sd_event
+    //       queue stops running if we don't have a timer that keeps re-arming
+    phosphor::Timer t2([]() { ; });
+    t2.start(std::chrono::microseconds(500000), true);
+
+    // TODO: Remove all vestiges of sd_event from phosphor-host-ipmid
+    //       until that is done, add the sd_event wrapper to the io object
+    sdbusplus::asio::sd_event_wrapper sdEvents(*io);
+
+    cmdManager = std::make_unique<phosphor::host::command::Manager>(*sdbusp);
+
+    // Register all command providers and filters
+    auto handles = ipmi::loadProviders(HOST_IPMI_LIB_PATH);
+
+    // Add bindings for inbound IPMI requests
+    auto server = sdbusplus::asio::object_server(sdbusp);
+    auto iface = server.add_interface("/xyz/openbmc_project/Ipmi",
+                                      "xyz.openbmc_project.Ipmi.Server");
+    iface->register_method("execute", ipmi::executionEntry);
+    iface->initialize();
+
+#ifdef ALLOW_DEPRECATED_API
+    // listen on deprecated signal interface for kcs/bt commands
+    constexpr const char* FILTER = "type='signal',interface='org.openbmc."
+                                   "HostIpmi',member='ReceivedMessage'";
+    sdbusplus::bus::match::match oldIpmiInterface(*sdbusp, FILTER,
+                                                  handleLegacyIpmiCommand);
+#endif /* ALLOW_DEPRECATED_API */
+
+    io->run();
+
+    // This avoids a warning about unused variables
+    handles.clear();
+    return 0;
+}
diff --git a/sensorhandler.cpp b/sensorhandler.cpp
index 9d0364d..051c4fd 100644
--- a/sensorhandler.cpp
+++ b/sensorhandler.cpp
@@ -139,11 +139,6 @@
     sd_bus_error error = SD_BUS_ERROR_NULL;
     sd_bus_message* m = NULL;
 
-    std::fprintf(ipmidbus,
-                 "Attempting to set a dbus Variant Sensor 0x%02x via %s with a "
-                 "value of %s\n",
-                 number, method, value);
-
     r = find_openbmc_path(number, &a);
 
     if (r < 0)
@@ -190,11 +185,6 @@
     sd_bus_error error = SD_BUS_ERROR_NULL;
     sd_bus_message* m = NULL;
 
-    std::fprintf(ipmidbus,
-                 "Attempting to set a dbus Variant Sensor 0x%02x via %s with a "
-                 "value of 0x%02x\n",
-                 number, method, value);
-
     r = find_openbmc_path(number, &a);
 
     if (r < 0)
diff --git a/systemintfcmds.cpp b/systemintfcmds.cpp
index d044030..564cc38 100644
--- a/systemintfcmds.cpp
+++ b/systemintfcmds.cpp
@@ -5,10 +5,10 @@
 #include "host-cmd-manager.hpp"
 #include "host-interface.hpp"
 
-#include <ipmid/api.h>
-
 #include <cstring>
 #include <ipmid-host/cmd.hpp>
+#include <ipmid/api.hpp>
+#include <ipmid/registration.hpp>
 
 void register_netfn_app_functions() __attribute__((constructor));
 
@@ -109,6 +109,8 @@
     __attribute__((init_priority(101)));
 std::unique_ptr<sdbusplus::server::manager::manager> objManager
     __attribute__((init_priority(101)));
+std::unique_ptr<sdbusplus::asio::connection> sdbusp
+    __attribute__((init_priority(101)));
 } // namespace
 
 #include <unistd.h>
@@ -130,14 +132,23 @@
     // Create new xyz.openbmc_project.host object on the bus
     auto objPath = std::string{CONTROL_HOST_OBJ_MGR} + '/' + HOST_NAME + '0';
 
-    // Add sdbusplus ObjectManager.
-    auto& sdbusPlusHandler = ipmid_get_sdbus_plus_handler();
-    objManager = std::make_unique<sdbusplus::server::manager::manager>(
-        *sdbusPlusHandler, CONTROL_HOST_OBJ_MGR);
+    // Create a new sdbus connection so it can have a well-known name
+    sd_bus* bus = nullptr;
+    sd_bus_open_system(&bus);
+    if (!bus)
+    {
+        return;
+    }
+    auto io = getIoService();
+    sdbusp = std::make_unique<sdbusplus::asio::connection>(*io, bus);
 
-    host = std::make_unique<phosphor::host::command::Host>(*sdbusPlusHandler,
+    // Add sdbusplus ObjectManager.
+    objManager = std::make_unique<sdbusplus::server::manager::manager>(
+        *sdbusp, CONTROL_HOST_OBJ_MGR);
+
+    host = std::make_unique<phosphor::host::command::Host>(*sdbusp,
                                                            objPath.c_str());
-    sdbusPlusHandler->request_name(CONTROL_HOST_BUSNAME);
+    sdbusp->request_name(CONTROL_HOST_BUSNAME);
 
     return;
 }