diff --git a/ipmi/control.hpp b/ipmi/control.hpp
new file mode 100644
index 0000000..1cd1612
--- /dev/null
+++ b/ipmi/control.hpp
@@ -0,0 +1,27 @@
+#pragma once
+
+#include <cstdint>
+#include <string>
+
+namespace pid_control
+{
+namespace ipmi
+{
+
+// Implement this interface to control a zone's mode or read back its status.
+class ZoneControlInterface
+{
+  public:
+    // Reads the fan control property (either manual or failsafe) and returns an
+    // IPMI code based on success or failure of this.
+    virtual uint8_t getFanCtrlProperty(uint8_t zoneId, bool* value,
+                                       const std::string& property) = 0;
+
+    // Sets the fan control property (only manual mode is settable presently)
+    // and returns an IPMI code based on success or failure of this.
+    virtual uint8_t setFanCtrlProperty(uint8_t zoneId, bool value,
+                                       const std::string& property) = 0;
+};
+
+} // namespace ipmi
+} // namespace pid_control
diff --git a/ipmi/dbus_mode.cpp b/ipmi/dbus_mode.cpp
index 76b4eba..7ea7fd4 100644
--- a/ipmi/dbus_mode.cpp
+++ b/ipmi/dbus_mode.cpp
@@ -14,6 +14,8 @@
  * limitations under the License.
  */
 
+#include "dbus_mode.hpp"
+
 #include <ipmid/api.h>
 
 #include <sdbusplus/bus.hpp>
@@ -21,6 +23,7 @@
 
 #include <cstdint>
 #include <string>
+#include <variant>
 
 namespace pid_control
 {
@@ -44,8 +47,8 @@
     return std::string(objectPath) + std::to_string(zone);
 }
 
-uint8_t getFanCtrlProperty(uint8_t zoneId, bool* value,
-                           const std::string& property)
+uint8_t DbusZoneControl::getFanCtrlProperty(uint8_t zoneId, bool* value,
+                                            const std::string& property)
 {
     std::string path = getControlPath(zoneId);
 
@@ -73,5 +76,33 @@
     return IPMI_CC_OK;
 }
 
+uint8_t DbusZoneControl::setFanCtrlProperty(uint8_t zoneId, bool value,
+                                            const std::string& property)
+{
+    using Value = std::variant<bool>;
+    Value v{value};
+
+    std::string path = getControlPath(zoneId);
+
+    auto PropertyWriteBus = sdbusplus::bus::new_system();
+    auto pimMsg = PropertyWriteBus.new_method_call(busName, path.c_str(),
+                                                   propertiesintf, "Set");
+    pimMsg.append(intf);
+    pimMsg.append(property);
+    pimMsg.append(v);
+
+    try
+    {
+        PropertyWriteBus.call_noreply(pimMsg);
+    }
+    catch (const sdbusplus::exception::SdBusError& ex)
+    {
+        return IPMI_CC_INVALID;
+    }
+
+    /* TODO(venture): Should sanity check the result. */
+    return IPMI_CC_OK;
+}
+
 } // namespace ipmi
 } // namespace pid_control
diff --git a/ipmi/dbus_mode.hpp b/ipmi/dbus_mode.hpp
index 05e9734..b063ac4 100644
--- a/ipmi/dbus_mode.hpp
+++ b/ipmi/dbus_mode.hpp
@@ -1,5 +1,7 @@
 #pragma once
 
+#include "control.hpp"
+
 #include <cstdint>
 #include <string>
 
@@ -8,21 +10,31 @@
 namespace ipmi
 {
 
-/*
- * busctl call xyz.openbmc_project.State.FanCtrl \
- *     /xyz/openbmc_project/settings/fanctrl/zone1 \
- *     org.freedesktop.DBus.Properties \
- *     GetAll \
- *     s \
- *     xyz.openbmc_project.Control.Mode
- * a{sv} 2 "Manual" b false "FailSafe" b false
- *
- * This returns an IPMI code as a uint8_t (which will always be sufficient to
- * hold the result). NOTE: This does not return the typedef value to avoid
- * including a header with conflicting types.
- */
-uint8_t getFanCtrlProperty(uint8_t zoneId, bool* value,
-                           const std::string& property);
+class DbusZoneControl : public ZoneControlInterface
+{
+  public:
+    DbusZoneControl() = default;
+    ~DbusZoneControl() = default;
+
+    /*
+     * busctl call xyz.openbmc_project.State.FanCtrl \
+     *     /xyz/openbmc_project/settings/fanctrl/zone1 \
+     *     org.freedesktop.DBus.Properties \
+     *     GetAll \
+     *     s \
+     *     xyz.openbmc_project.Control.Mode
+     * a{sv} 2 "Manual" b false "FailSafe" b false
+     *
+     * This returns an IPMI code as a uint8_t (which will always be sufficient
+     * to hold the result). NOTE: This does not return the typedef value to
+     * avoid including a header with conflicting types.
+     */
+    uint8_t getFanCtrlProperty(uint8_t zoneId, bool* value,
+                               const std::string& property) override;
+
+    uint8_t setFanCtrlProperty(uint8_t zoneId, bool value,
+                               const std::string& property) override;
+};
 
 } // namespace ipmi
 } // namespace pid_control
diff --git a/ipmi/main_ipmi.cpp b/ipmi/main_ipmi.cpp
index 6056464..8e58b25 100644
--- a/ipmi/main_ipmi.cpp
+++ b/ipmi/main_ipmi.cpp
@@ -14,6 +14,8 @@
  * limitations under the License.
  */
 
+#include "control.hpp"
+#include "dbus_mode.hpp"
 #include "manualcmds.hpp"
 
 #include <ipmid/iana.hpp>
@@ -21,6 +23,18 @@
 #include <ipmid/oemrouter.hpp>
 
 #include <cstdio>
+#include <functional>
+#include <memory>
+
+namespace pid_control
+{
+namespace ipmi
+{
+
+ZoneControlIpmiHandler handler(std::make_unique<DbusZoneControl>());
+
+}
+} // namespace pid_control
 
 void setupGlobalOemFanControl() __attribute__((constructor));
 
@@ -33,6 +47,9 @@
         "Registering OEM:[%#08X], Cmd:[%#04X] for Manual Zone Control\n",
         oem::obmcOemNumber, oem::Cmd::fanManualCmd);
 
+    using namespace std::placeholders;
     router->registerHandler(oem::obmcOemNumber, oem::Cmd::fanManualCmd,
-                            pid_control::ipmi::manualModeControl);
+                            std::bind(pid_control::ipmi::manualModeControl,
+                                      &pid_control::ipmi::handler, _1, _2, _3,
+                                      _4));
 }
diff --git a/ipmi/manualcmds.cpp b/ipmi/manualcmds.cpp
index 5dcac09..0ff0c0a 100644
--- a/ipmi/manualcmds.cpp
+++ b/ipmi/manualcmds.cpp
@@ -16,6 +16,7 @@
 
 #include "manualcmds.hpp"
 
+#include "control.hpp"
 #include "dbus_mode.hpp"
 #include "manual_messages.hpp"
 
@@ -25,6 +26,7 @@
 #include <sdbusplus/message.hpp>
 
 #include <map>
+#include <memory>
 #include <string>
 #include <tuple>
 #include <variant>
@@ -34,25 +36,12 @@
 namespace ipmi
 {
 
-static constexpr auto objectPath = "/xyz/openbmc_project/settings/fanctrl/zone";
-static constexpr auto busName = "xyz.openbmc_project.State.FanCtrl";
-static constexpr auto intf = "xyz.openbmc_project.Control.Mode";
 static constexpr auto manualProperty = "Manual";
 static constexpr auto failsafeProperty = "FailSafe";
-static constexpr auto propertiesintf = "org.freedesktop.DBus.Properties";
 
-using Property = std::string;
-using Value = std::variant<bool>;
-using PropertyMap = std::map<Property, Value>;
-
-/* The following was copied directly from my manual thread handler. */
-static std::string getControlPath(int8_t zone)
-{
-    return std::string(objectPath) + std::to_string(zone);
-}
-
-static ipmi_ret_t getFailsafeModeState(const uint8_t* reqBuf, uint8_t* replyBuf,
-                                       size_t* dataLen)
+ipmi_ret_t ZoneControlIpmiHandler::getFailsafeModeState(const uint8_t* reqBuf,
+                                                        uint8_t* replyBuf,
+                                                        size_t* dataLen)
 {
     bool current;
 
@@ -65,7 +54,7 @@
         reinterpret_cast<const struct FanCtrlRequest*>(&reqBuf[0]);
 
     ipmi_ret_t rc =
-        getFanCtrlProperty(request->zone, &current, failsafeProperty);
+        _control->getFanCtrlProperty(request->zone, &current, failsafeProperty);
     if (rc)
     {
         return rc;
@@ -82,8 +71,9 @@
  *   <arg name="properties" direction="out" type="a{sv}"/>
  * </method>
  */
-static ipmi_ret_t getManualModeState(const uint8_t* reqBuf, uint8_t* replyBuf,
-                                     size_t* dataLen)
+ipmi_ret_t ZoneControlIpmiHandler::getManualModeState(const uint8_t* reqBuf,
+                                                      uint8_t* replyBuf,
+                                                      size_t* dataLen)
 {
     bool current;
 
@@ -95,7 +85,8 @@
     const auto request =
         reinterpret_cast<const struct FanCtrlRequest*>(&reqBuf[0]);
 
-    ipmi_ret_t rc = getFanCtrlProperty(request->zone, &current, manualProperty);
+    ipmi_ret_t rc =
+        _control->getFanCtrlProperty(request->zone, &current, manualProperty);
     if (rc)
     {
         return rc;
@@ -113,51 +104,28 @@
  *   <arg name="value" direction="in" type="v"/>
  * </method>
  */
-static ipmi_ret_t setManualModeState(const uint8_t* reqBuf, uint8_t* replyBuf,
-                                     size_t* dataLen)
+ipmi_ret_t ZoneControlIpmiHandler::setManualModeState(const uint8_t* reqBuf,
+                                                      uint8_t* replyBuf,
+                                                      size_t* dataLen)
 {
     if (*dataLen < sizeof(struct FanCtrlRequestSet))
     {
         return IPMI_CC_INVALID;
     }
 
-    using Value = std::variant<bool>;
-
     const auto request =
         reinterpret_cast<const struct FanCtrlRequestSet*>(&reqBuf[0]);
 
     /* 0 is false, 1 is true */
-    bool setValue = static_cast<bool>(request->value);
-    Value v{setValue};
-
-    auto PropertyWriteBus = sdbusplus::bus::new_system();
-
-    std::string path = getControlPath(request->zone);
-
-    auto pimMsg = PropertyWriteBus.new_method_call(busName, path.c_str(),
-                                                   propertiesintf, "Set");
-    pimMsg.append(intf);
-    pimMsg.append(manualProperty);
-    pimMsg.append(v);
-
-    ipmi_ret_t rc = IPMI_CC_OK;
-
-    try
-    {
-        PropertyWriteBus.call_noreply(pimMsg);
-    }
-    catch (const sdbusplus::exception::SdBusError& ex)
-    {
-        rc = IPMI_CC_INVALID;
-    }
-    /* TODO(venture): Should sanity check the result. */
-
+    ipmi_ret_t rc = _control->setFanCtrlProperty(
+        request->zone, static_cast<bool>(request->value), manualProperty);
     return rc;
 }
 
 /* Three command packages: get, set true, set false */
-ipmi_ret_t manualModeControl(ipmi_cmd_t cmd, const uint8_t* reqBuf,
-                             uint8_t* replyCmdBuf, size_t* dataLen)
+ipmi_ret_t manualModeControl(ZoneControlIpmiHandler* handler, ipmi_cmd_t cmd,
+                             const uint8_t* reqBuf, uint8_t* replyCmdBuf,
+                             size_t* dataLen)
 {
     // FanCtrlRequest is the smaller of the requests, so it's at a minimum.
     if (*dataLen < sizeof(struct FanCtrlRequest))
@@ -173,11 +141,11 @@
     switch (request->command)
     {
         case getControlState:
-            return getManualModeState(reqBuf, replyCmdBuf, dataLen);
+            return handler->getManualModeState(reqBuf, replyCmdBuf, dataLen);
         case setControlState:
-            return setManualModeState(reqBuf, replyCmdBuf, dataLen);
+            return handler->setManualModeState(reqBuf, replyCmdBuf, dataLen);
         case getFailsafeState:
-            return getFailsafeModeState(reqBuf, replyCmdBuf, dataLen);
+            return handler->getFailsafeModeState(reqBuf, replyCmdBuf, dataLen);
         default:
             rc = IPMI_CC_INVALID;
     }
diff --git a/ipmi/manualcmds.hpp b/ipmi/manualcmds.hpp
index ac1513d..4e11662 100644
--- a/ipmi/manualcmds.hpp
+++ b/ipmi/manualcmds.hpp
@@ -1,16 +1,42 @@
 #pragma once
 
+#include "control.hpp"
+
 #include <ipmid/api.h>
 
 #include <cstdint>
+#include <memory>
 
 namespace pid_control
 {
 namespace ipmi
 {
 
-ipmi_ret_t manualModeControl(ipmi_cmd_t cmd, const uint8_t* reqBuf,
-                             uint8_t* replyCmdBuf, size_t* dataLen);
+// Implements validation of IPMI commands and handles sending back the
+// responses.
+class ZoneControlIpmiHandler
+{
+  public:
+    ZoneControlIpmiHandler(std::unique_ptr<ZoneControlInterface> control) :
+        _control(std::move(control))
+    {}
+
+    ipmi_ret_t getFailsafeModeState(const uint8_t* reqBuf, uint8_t* replyBuf,
+                                    size_t* dataLen);
+
+    ipmi_ret_t getManualModeState(const uint8_t* reqBuf, uint8_t* replyBuf,
+                                  size_t* dataLen);
+
+    ipmi_ret_t setManualModeState(const uint8_t* reqBuf, uint8_t* replyBuf,
+                                  size_t* dataLen);
+
+  private:
+    std::unique_ptr<ZoneControlInterface> _control;
+};
+
+ipmi_ret_t manualModeControl(ZoneControlIpmiHandler* handler, ipmi_cmd_t cmd,
+                             const uint8_t* reqBuf, uint8_t* replyCmdBuf,
+                             size_t* dataLen);
 
 } // namespace ipmi
 } // namespace pid_control