diff --git a/.clang-format b/.clang-format
index 38daa66..d43e884 100644
--- a/.clang-format
+++ b/.clang-format
@@ -1,111 +1,135 @@
-# SPDX-License-Identifier: GPL-2.0
-#
-# Originally from Linux v5.6
 ---
-AccessModifierOffset: -4
+Language:        Cpp
+# BasedOnStyle:  LLVM
+AccessModifierOffset: -2
 AlignAfterOpenBracket: Align
-AlignConsecutiveMacros: true
 AlignConsecutiveAssignments: false
 AlignConsecutiveDeclarations: false
-#AlignEscapedNewlines: Left # Unknown to clang-format-4.0
-AlignOperands: true
-AlignTrailingComments: false
-AllowAllParametersOfDeclarationOnNextLine: false
-AllowShortBlocksOnASingleLine: false
+AlignEscapedNewlines: Right
+AlignOperands:  Align
+AlignTrailingComments:
+  Kind: Always
+  OverEmptyLines: 1
+AllowAllParametersOfDeclarationOnNextLine: true
+AllowShortBlocksOnASingleLine: Empty
 AllowShortCaseLabelsOnASingleLine: false
-AllowShortFunctionsOnASingleLine: None
-AllowShortIfStatementsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: Empty
+AllowShortIfStatementsOnASingleLine: Never
+AllowShortLambdasOnASingleLine: true
 AllowShortLoopsOnASingleLine: false
-AlwaysBreakAfterDefinitionReturnType: None
 AlwaysBreakAfterReturnType: None
 AlwaysBreakBeforeMultilineStrings: false
-AlwaysBreakTemplateDeclarations: false
+AlwaysBreakTemplateDeclarations: Yes
 BinPackArguments: true
 BinPackParameters: true
+BitFieldColonSpacing: None
 BraceWrapping:
-  AfterClass: false
-  AfterControlStatement: false
-  AfterEnum: false
-  AfterFunction: true
-  AfterNamespace: true
-  AfterObjCDeclaration: false
-  AfterStruct: false
-  AfterUnion: false
-  #AfterExternBlock: false # Unknown to clang-format-5.0
-  BeforeCatch: false
-  BeforeElse: false
-  IndentBraces: false
-  #SplitEmptyFunction: true # Unknown to clang-format-4.0
-  #SplitEmptyRecord: true # Unknown to clang-format-4.0
-  #SplitEmptyNamespace: true # Unknown to clang-format-4.0
+  AfterCaseLabel:  true
+  AfterClass:      true
+  AfterControlStatement: true
+  AfterEnum:       true
+  AfterExternBlock: true
+  AfterFunction:   true
+  AfterNamespace:  true
+  AfterObjCDeclaration: true
+  AfterStruct:     true
+  AfterUnion:      true
+  BeforeCatch:     true
+  BeforeElse:      true
+  BeforeLambdaBody: false
+  BeforeWhile:     false
+  IndentBraces:    false
+  SplitEmptyFunction:   false
+  SplitEmptyRecord:     false
+  SplitEmptyNamespace:  false
+BreakAfterAttributes: Never
 BreakBeforeBinaryOperators: None
 BreakBeforeBraces: Custom
-#BreakBeforeInheritanceComma: false # Unknown to clang-format-4.0
-BreakBeforeTernaryOperators: false
-BreakConstructorInitializersBeforeComma: false
-#BreakConstructorInitializers: BeforeComma # Unknown to clang-format-4.0
-BreakAfterJavaFieldAnnotations: false
+BreakBeforeTernaryOperators: true
+BreakConstructorInitializers: AfterColon
+BreakInheritanceList: AfterColon
 BreakStringLiterals: false
-ColumnLimit: 80
-CommentPragmas: '^ IWYU pragma:'
-#CompactNamespaces: false # Unknown to clang-format-4.0
-ConstructorInitializerAllOnOneLineOrOnePerLine: false
-ConstructorInitializerIndentWidth: 8
-ContinuationIndentWidth: 8
-Cpp11BracedListStyle: false
+ColumnLimit:     80
+CommentPragmas:  '^ IWYU pragma:'
+CompactNamespaces: false
+ConstructorInitializerIndentWidth: 4
+ContinuationIndentWidth: 4
+Cpp11BracedListStyle: true
 DerivePointerAlignment: false
-DisableFormat: false
-ExperimentalAutoDetectBinPacking: false
-#FixNamespaceComments: false # Unknown to clang-format-4.0
-#IncludeBlocks: Preserve # Unknown to clang-format-5.0
+DisableFormat:   false
+FixNamespaceComments: true
+ForEachMacros:
+  - foreach
+  - Q_FOREACH
+  - BOOST_FOREACH
+IncludeBlocks: Regroup
 IncludeCategories:
-  - Regex: '.*'
-    Priority: 1
-IncludeIsMainRegex: '(Test)?$'
-IndentCaseLabels: false
-#IndentPPDirectives: None # Unknown to clang-format-5.0
-IndentWidth: 8
-IndentWrappedFunctionNames: false
-JavaScriptQuotes: Leave
-JavaScriptWrapImports: true
+  - Regex:           '^[<"](gtest|gmock)'
+    Priority:        7
+  - Regex:           '^"config.h"'
+    Priority:        -1
+  - Regex:           '^".*\.h"'
+    Priority:        1
+  - Regex:           '^".*\.hpp"'
+    Priority:        2
+  - Regex:           '^<.*\.h>'
+    Priority:        3
+  - Regex:           '^<.*\.hpp>'
+    Priority:        4
+  - Regex:           '^<.*'
+    Priority:        5
+  - Regex:           '.*'
+    Priority:        6
+IndentCaseLabels: true
+IndentExternBlock: NoIndent
+IndentRequiresClause: true
+IndentWidth:     4
+IndentWrappedFunctionNames: true
+InsertNewlineAtEOF: true
 KeepEmptyLinesAtTheStartOfBlocks: false
+LambdaBodyIndentation: OuterScope
+LineEnding: LF
 MacroBlockBegin: ''
-MacroBlockEnd: ''
+MacroBlockEnd:   ''
 MaxEmptyLinesToKeep: 1
-NamespaceIndentation: Inner
-#ObjCBinPackProtocolList: Auto # Unknown to clang-format-5.0
-ObjCBlockIndentWidth: 8
-ObjCSpaceAfterProperty: true
+NamespaceIndentation: None
+ObjCBlockIndentWidth: 2
+ObjCSpaceAfterProperty: false
 ObjCSpaceBeforeProtocolList: true
-
-# Taken from git's rules
-#PenaltyBreakAssignment: 10 # Unknown to clang-format-4.0
-PenaltyBreakBeforeFirstCallParameter: 30
-PenaltyBreakComment: 10
-PenaltyBreakFirstLessLess: 0
-PenaltyBreakString: 10
-PenaltyExcessCharacter: 100
+PackConstructorInitializers: BinPack
+PenaltyBreakAssignment: 25
+PenaltyBreakBeforeFirstCallParameter: 19
+PenaltyBreakComment: 300
+PenaltyBreakFirstLessLess: 120
+PenaltyBreakString: 1000
+PenaltyExcessCharacter: 1000000
 PenaltyReturnTypeOnItsOwnLine: 60
-
-PointerAlignment: Right
-ReflowComments: false
-SortIncludes: false
-#SortUsingDeclarations: false # Unknown to clang-format-4.0
+PenaltyIndentedWhitespace: 0
+PointerAlignment: Left
+QualifierAlignment: Left
+ReferenceAlignment: Left
+ReflowComments:  true
+RequiresClausePosition: OwnLine
+RequiresExpressionIndentation: Keyword
+SortIncludes: CaseSensitive
+SortUsingDeclarations: true
 SpaceAfterCStyleCast: false
 SpaceAfterTemplateKeyword: true
 SpaceBeforeAssignmentOperators: true
-#SpaceBeforeCtorInitializerColon: true # Unknown to clang-format-5.0
-#SpaceBeforeInheritanceColon: true # Unknown to clang-format-5.0
+SpaceBeforeCpp11BracedList: false
+SpaceBeforeCtorInitializerColon: true
+SpaceBeforeInheritanceColon: true
 SpaceBeforeParens: ControlStatements
-#SpaceBeforeRangeBasedForLoopColon: true # Unknown to clang-format-5.0
+SpaceBeforeRangeBasedForLoopColon: true
 SpaceInEmptyParentheses: false
 SpacesBeforeTrailingComments: 1
-SpacesInAngles: false
-SpacesInContainerLiterals: false
+SpacesInAngles: Never
+SpacesInContainerLiterals: true
 SpacesInCStyleCastParentheses: false
 SpacesInParentheses: false
 SpacesInSquareBrackets: false
-Standard: Cpp03
-TabWidth: 8
-UseTab: Always
+Standard:        Latest
+TabWidth:        4
+UseTab:          Never
 ...
+
diff --git a/ssifbridged.cpp b/ssifbridged.cpp
index ee30df9..7ed8c66 100644
--- a/ssifbridged.cpp
+++ b/ssifbridged.cpp
@@ -26,8 +26,8 @@
 #include <phosphor-logging/log.hpp>
 #include <sdbusplus/asio/connection.hpp>
 #include <sdbusplus/asio/object_server.hpp>
-#include <sdbusplus/timer.hpp>
 #include <sdbusplus/asio/sd_event.hpp>
+#include <sdbusplus/timer.hpp>
 
 #include <iostream>
 
@@ -36,375 +36,364 @@
 
 using namespace phosphor::logging;
 
-struct ipmi_cmd {
-	uint8_t netfn;
-	uint8_t lun;
-	uint8_t cmd;
+struct ipmi_cmd
+{
+    uint8_t netfn;
+    uint8_t lun;
+    uint8_t cmd;
 } prev_req_cmd;
 
 static constexpr const char devBase[] = "/dev/ipmi-ssif-host";
 /* SSIF use IPMI SSIF channel */
-static constexpr const char *ssifBus =
-	"xyz.openbmc_project.Ipmi.Channel.ipmi_ssif";
-static constexpr const char *ssifObj =
-	"/xyz/openbmc_project/Ipmi/Channel/ipmi_ssif";
+static constexpr const char* ssifBus =
+    "xyz.openbmc_project.Ipmi.Channel.ipmi_ssif";
+static constexpr const char* ssifObj =
+    "/xyz/openbmc_project/Ipmi/Channel/ipmi_ssif";
 /* The timer of driver is set to 15 seconds, need to send
  * response before timeout occurs
  */
 static constexpr const unsigned int hostReqTimeout = 14000000;
 
-class SsifChannel {
-    public:
-	static constexpr size_t ssifMessageSize =
-		IPMI_SSIF_PAYLOAD_MAX + sizeof(unsigned int);
-	size_t sizeofLenField = sizeof(unsigned int);
-	static constexpr uint8_t netFnShift = 2;
-	static constexpr uint8_t lunMask = (1 << netFnShift) - 1;
+class SsifChannel
+{
+  public:
+    static constexpr size_t ssifMessageSize = IPMI_SSIF_PAYLOAD_MAX +
+                                              sizeof(unsigned int);
+    size_t sizeofLenField = sizeof(unsigned int);
+    static constexpr uint8_t netFnShift = 2;
+    static constexpr uint8_t lunMask = (1 << netFnShift) - 1;
 
-	SsifChannel(std::shared_ptr<boost::asio::io_context> &io,
-		    std::shared_ptr<sdbusplus::asio::connection> &bus,
-		    const std::string &channel, bool verbose,
-		    int numberOfReqNotRsp);
-	bool initOK() const
-	{
-		return !!dev;
-	}
-	void channelAbort(const char *msg, const boost::system::error_code &ec);
-	void async_read();
-	void processMessage(const boost::system::error_code &ecRd, size_t rlen);
-	int showNumOfReqNotRsp();
-	std::unique_ptr<boost::asio::posix::stream_descriptor> dev = nullptr;
+    SsifChannel(std::shared_ptr<boost::asio::io_context>& io,
+                std::shared_ptr<sdbusplus::asio::connection>& bus,
+                const std::string& channel, bool verbose,
+                int numberOfReqNotRsp);
+    bool initOK() const
+    {
+        return !!dev;
+    }
+    void channelAbort(const char* msg, const boost::system::error_code& ec);
+    void async_read();
+    void processMessage(const boost::system::error_code& ecRd, size_t rlen);
+    int showNumOfReqNotRsp();
+    std::unique_ptr<boost::asio::posix::stream_descriptor> dev = nullptr;
 
-    protected:
-	std::array<uint8_t, ssifMessageSize> xferBuffer;
-	std::shared_ptr<boost::asio::io_context> io;
-	std::shared_ptr<sdbusplus::asio::connection> bus;
-	std::shared_ptr<sdbusplus::asio::object_server> server;
-	bool verbose;
-	/* This variable is always 0 when a request is responsed properly,
-	 * any value larger than 0 meaning there is/are request(s) which
-	 * not processed properly
-	 * */
-	int numberOfReqNotRsp;
+  protected:
+    std::array<uint8_t, ssifMessageSize> xferBuffer;
+    std::shared_ptr<boost::asio::io_context> io;
+    std::shared_ptr<sdbusplus::asio::connection> bus;
+    std::shared_ptr<sdbusplus::asio::object_server> server;
+    bool verbose;
+    /* This variable is always 0 when a request is responsed properly,
+     * any value larger than 0 meaning there is/are request(s) which
+     * not processed properly
+     * */
+    int numberOfReqNotRsp;
 };
 
 std::unique_ptr<phosphor::Timer> rspTimer __attribute__((init_priority(101)));
 std::unique_ptr<SsifChannel> ssifchannel = nullptr;
 
-SsifChannel::SsifChannel(std::shared_ptr<boost::asio::io_context> &io,
-			 std::shared_ptr<sdbusplus::asio::connection> &bus,
-			 const std::string &device, bool verbose,
-			 int numberOfReqNotRsp)
-	: io(io), bus(bus), verbose(verbose),
-	  numberOfReqNotRsp(numberOfReqNotRsp)
+SsifChannel::SsifChannel(std::shared_ptr<boost::asio::io_context>& io,
+                         std::shared_ptr<sdbusplus::asio::connection>& bus,
+                         const std::string& device, bool verbose,
+                         int numberOfReqNotRsp) :
+    io(io),
+    bus(bus), verbose(verbose), numberOfReqNotRsp(numberOfReqNotRsp)
 {
-	std::string devName = devBase;
-	if (!device.empty()) {
-		devName = device;
-	}
+    std::string devName = devBase;
+    if (!device.empty())
+    {
+        devName = device;
+    }
 
-	// open device
-	int fd = open(devName.c_str(), O_RDWR | O_NONBLOCK);
-	if (fd < 0) {
-		std::string msgToLog =
-			"Couldn't open SSIF driver with flags O_RDWR."
-			" FILENAME=" +
-			devName + " ERROR=" + strerror(errno);
-		log<level::ERR>(msgToLog.c_str());
-		return;
-	} else {
-		dev = std::make_unique<boost::asio::posix::stream_descriptor>(
-			*io, fd);
-	}
+    // open device
+    int fd = open(devName.c_str(), O_RDWR | O_NONBLOCK);
+    if (fd < 0)
+    {
+        std::string msgToLog = "Couldn't open SSIF driver with flags O_RDWR."
+                               " FILENAME=" +
+                               devName + " ERROR=" + strerror(errno);
+        log<level::ERR>(msgToLog.c_str());
+        return;
+    }
+    else
+    {
+        dev = std::make_unique<boost::asio::posix::stream_descriptor>(*io, fd);
+    }
 
-	async_read();
-	// register interfaces...
-	server = std::make_shared<sdbusplus::asio::object_server>(bus);
-	std::shared_ptr<sdbusplus::asio::dbus_interface> iface =
-		server->add_interface(ssifObj, ssifBus);
-	iface->initialize();
+    async_read();
+    // register interfaces...
+    server = std::make_shared<sdbusplus::asio::object_server>(bus);
+    std::shared_ptr<sdbusplus::asio::dbus_interface> iface =
+        server->add_interface(ssifObj, ssifBus);
+    iface->initialize();
 }
 
-void SsifChannel::channelAbort(const char *msg,
-			       const boost::system::error_code &ec)
+void SsifChannel::channelAbort(const char* msg,
+                               const boost::system::error_code& ec)
 {
-	std::string msgToLog = std::string(msg) + " ERROR=" + ec.message();
-	log<level::ERR>(msgToLog.c_str());
-	// bail; maybe a restart from systemd can clear the error
-	io->stop();
+    std::string msgToLog = std::string(msg) + " ERROR=" + ec.message();
+    log<level::ERR>(msgToLog.c_str());
+    // bail; maybe a restart from systemd can clear the error
+    io->stop();
 }
 
 void SsifChannel::async_read()
 {
-	boost::asio::async_read(
-		*dev, boost::asio::buffer(xferBuffer, xferBuffer.size()),
-		boost::asio::transfer_at_least(2),
-		[this](const boost::system::error_code &ec, size_t rlen) {
-			processMessage(ec, rlen);
-		});
+    boost::asio::async_read(*dev,
+                            boost::asio::buffer(xferBuffer, xferBuffer.size()),
+                            boost::asio::transfer_at_least(2),
+                            [this](const boost::system::error_code& ec,
+                                   size_t rlen) { processMessage(ec, rlen); });
 }
 
 int SsifChannel::showNumOfReqNotRsp()
 {
-	return numberOfReqNotRsp;
+    return numberOfReqNotRsp;
 }
 
 void rspTimerHandler()
 {
-	std::vector<uint8_t> rsp;
-	constexpr uint8_t ccResponseNotAvailable = 0xce;
+    std::vector<uint8_t> rsp;
+    constexpr uint8_t ccResponseNotAvailable = 0xce;
 
-	rsp.resize(ssifchannel->sizeofLenField + sizeof(prev_req_cmd.cmd) +
-		   sizeof(prev_req_cmd.netfn) + sizeof(ccResponseNotAvailable));
-	std::string msgToLog =
-		"timeout, send response to keep host alive"
-		" netfn=" +
-		std::to_string(prev_req_cmd.netfn) +
-		" lun=" + std::to_string(prev_req_cmd.lun) +
-		" cmd=" + std::to_string(prev_req_cmd.cmd) +
-		" cc=" + std::to_string(ccResponseNotAvailable) +
-		" numberOfReqNotRsp=" +
-		std::to_string(ssifchannel->showNumOfReqNotRsp());
-	log<level::INFO>(msgToLog.c_str());
+    rsp.resize(ssifchannel->sizeofLenField + sizeof(prev_req_cmd.cmd) +
+               sizeof(prev_req_cmd.netfn) + sizeof(ccResponseNotAvailable));
+    std::string msgToLog = "timeout, send response to keep host alive"
+                           " netfn=" +
+                           std::to_string(prev_req_cmd.netfn) +
+                           " lun=" + std::to_string(prev_req_cmd.lun) +
+                           " cmd=" + std::to_string(prev_req_cmd.cmd) +
+                           " cc=" + std::to_string(ccResponseNotAvailable) +
+                           " numberOfReqNotRsp=" +
+                           std::to_string(ssifchannel->showNumOfReqNotRsp());
+    log<level::INFO>(msgToLog.c_str());
 
-	unsigned int *t = (unsigned int *)&rsp[0];
-	*t = 3;
-	rsp[ssifchannel->sizeofLenField] =
-		((prev_req_cmd.netfn + 1) << ssifchannel->netFnShift) |
-		(prev_req_cmd.lun & ssifchannel->lunMask);
-	rsp[ssifchannel->sizeofLenField + 1] = prev_req_cmd.cmd;
-	rsp[ssifchannel->sizeofLenField + 2] = ccResponseNotAvailable;
+    unsigned int* t = (unsigned int*)&rsp[0];
+    *t = 3;
+    rsp[ssifchannel->sizeofLenField] =
+        ((prev_req_cmd.netfn + 1) << ssifchannel->netFnShift) |
+        (prev_req_cmd.lun & ssifchannel->lunMask);
+    rsp[ssifchannel->sizeofLenField + 1] = prev_req_cmd.cmd;
+    rsp[ssifchannel->sizeofLenField + 2] = ccResponseNotAvailable;
 
-	boost::system::error_code ecWr;
+    boost::system::error_code ecWr;
 
-	size_t wlen = boost::asio::write(*(ssifchannel->dev),
-					 boost::asio::buffer(rsp), ecWr);
-	if (ecWr || wlen != rsp.size()) {
-		msgToLog =
-			"Failed to send ssif respond message:"
-			" size=" +
-			std::to_string(wlen) +
-			" expect=" + std::to_string(rsp.size()) +
-			" error=" + ecWr.message() +
-			" netfn=" + std::to_string(prev_req_cmd.netfn + 1) +
-			" lun=" + std::to_string(prev_req_cmd.lun) + " cmd=" +
-			std::to_string(rsp[ssifchannel->sizeofLenField + 1]) +
-			" cc=" + std::to_string(ccResponseNotAvailable);
-		log<level::ERR>(msgToLog.c_str());
-	}
+    size_t wlen = boost::asio::write(*(ssifchannel->dev),
+                                     boost::asio::buffer(rsp), ecWr);
+    if (ecWr || wlen != rsp.size())
+    {
+        msgToLog =
+            "Failed to send ssif respond message:"
+            " size=" +
+            std::to_string(wlen) + " expect=" + std::to_string(rsp.size()) +
+            " error=" + ecWr.message() +
+            " netfn=" + std::to_string(prev_req_cmd.netfn + 1) +
+            " lun=" + std::to_string(prev_req_cmd.lun) +
+            " cmd=" + std::to_string(rsp[ssifchannel->sizeofLenField + 1]) +
+            " cc=" + std::to_string(ccResponseNotAvailable);
+        log<level::ERR>(msgToLog.c_str());
+    }
 }
 
 void initTimer()
 {
-	if (!rspTimer) {
-		rspTimer = std::make_unique<phosphor::Timer>(rspTimerHandler);
-	}
+    if (!rspTimer)
+    {
+        rspTimer = std::make_unique<phosphor::Timer>(rspTimerHandler);
+    }
 }
 
-void SsifChannel::processMessage(const boost::system::error_code &ecRd,
-				 size_t rlen)
+void SsifChannel::processMessage(const boost::system::error_code& ecRd,
+                                 size_t rlen)
 {
-	if (ecRd || rlen < 2) {
-		channelAbort("Failed to read req msg", ecRd);
-		return;
-	}
-	async_read();
+    if (ecRd || rlen < 2)
+    {
+        channelAbort("Failed to read req msg", ecRd);
+        return;
+    }
+    async_read();
 
-	auto rawIter = xferBuffer.cbegin();
-	auto rawEnd = rawIter + rlen;
-	uint8_t netfn = rawIter[sizeofLenField] >> netFnShift;
-	uint8_t lun = rawIter[sizeofLenField] & lunMask;
-	uint8_t cmd = rawIter[sizeofLenField + 1];
+    auto rawIter = xferBuffer.cbegin();
+    auto rawEnd = rawIter + rlen;
+    uint8_t netfn = rawIter[sizeofLenField] >> netFnShift;
+    uint8_t lun = rawIter[sizeofLenField] & lunMask;
+    uint8_t cmd = rawIter[sizeofLenField + 1];
 
-	/* keep track of previous request */
-	prev_req_cmd.netfn = netfn;
-	prev_req_cmd.lun = lun;
-	prev_req_cmd.cmd = cmd;
+    /* keep track of previous request */
+    prev_req_cmd.netfn = netfn;
+    prev_req_cmd.lun = lun;
+    prev_req_cmd.cmd = cmd;
 
-	/* there is a request coming */
-	numberOfReqNotRsp++;
-	/* start response timer */
-	rspTimer->start(std::chrono::microseconds(hostReqTimeout), false);
+    /* there is a request coming */
+    numberOfReqNotRsp++;
+    /* start response timer */
+    rspTimer->start(std::chrono::microseconds(hostReqTimeout), false);
 
-	if (verbose) {
-		unsigned int lenRecv;
-		unsigned int *p = (unsigned int *)rawIter;
-		lenRecv = p[0];
-		std::string msgToLog = "Read ssif request message with"
-				       " len=" +
-				       std::to_string(lenRecv) +
-				       " netfn=" + std::to_string(netfn) +
-				       " lun=" + std::to_string(lun) +
-				       " cmd=" + std::to_string(cmd) +
-				       " numberOfReqNotRsp=" +
-				       std::to_string(numberOfReqNotRsp);
-		log<level::INFO>(msgToLog.c_str());
-	}
-	// copy out payload
-	std::vector<uint8_t> data(rawIter + sizeofLenField + 2, rawEnd);
-	// non-session bridges still need to pass an empty options map
-	std::map<std::string, std::variant<int> > options;
-	// the response is a tuple because dbus can only return a single value
-	using IpmiDbusRspType = std::tuple<uint8_t, uint8_t, uint8_t, uint8_t,
-					   std::vector<uint8_t> >;
-	static constexpr const char ipmiQueueService[] =
-		"xyz.openbmc_project.Ipmi.Host";
-	static constexpr const char ipmiQueuePath[] =
-		"/xyz/openbmc_project/Ipmi";
-	static constexpr const char ipmiQueueIntf[] =
-		"xyz.openbmc_project.Ipmi.Server";
-	static constexpr const char ipmiQueueMethod[] = "execute";
-	/* now, we do not care dbus timeout, since we already have actions
-	 * before dbus timeout occurs
-	 */
-	static constexpr unsigned int dbusTimeout = 60000000;
-	bus->async_method_call_timed(
-		[this, netfnCap{ netfn }, lunCap{ lun },
-		 cmdCap{ cmd }](const boost::system::error_code &ec,
-				const IpmiDbusRspType &response) {
-			std::vector<uint8_t> rsp;
-			const auto &[netfn, lun, cmd, cc, payload] = response;
-			numberOfReqNotRsp--;
-			if (ec) {
-				std::string msgToLog =
-					"ssif<->ipmid bus error:"
-					" netfn=" +
-					std::to_string(netfn) +
-					" lun=" + std::to_string(lun) +
-					" cmd=" + std::to_string(cmd) +
-					" error=" + ec.message();
-				log<level::ERR>(msgToLog.c_str());
-				rsp.resize(sizeofLenField + sizeof(netfn) +
-					   sizeof(cmd) + sizeof(cc));
-				/* if dbusTimeout, just return and do not send any response
-				 * to let host continue with other commands, response here
-				 * is potentially make the response duplicated
-				 * */
-				return;
-			} else {
-				if ((prev_req_cmd.netfn != (netfn - 1) ||
-				     prev_req_cmd.lun != lun ||
-				     prev_req_cmd.cmd != cmd) ||
-				    ((prev_req_cmd.netfn == (netfn - 1) &&
-				      prev_req_cmd.lun == lun &&
-				      prev_req_cmd.cmd == cmd) &&
-				     numberOfReqNotRsp != 0)) {
-					/* Only send response to the last request command to void
-					 * duplicated response which makes host driver confused and
-					 * failed to create interface
-					 *
-					 * Drop responses which are (1) different from the request
-					 * (2) parameters are the same as request but handshake flow
-					 * are in dupplicate request state
-					 * */
-					if (verbose) {
-						std::string msgToLog =
-							"Drop ssif respond message with"
-							" len=" +
-							std::to_string(
-								payload.size() +
-								3) +
-							" netfn=" +
-							std::to_string(netfn) +
-							" lun=" +
-							std::to_string(lun) +
-							" cmd=" +
-							std::to_string(cmd) +
-							" cc=" +
-							std::to_string(cc) +
-							" numberOfReqNotRsp=" +
-							std::to_string(
-								numberOfReqNotRsp);
-						log<level::INFO>(
-							msgToLog.c_str());
-					}
-					return;
-				}
-				rsp.resize(sizeofLenField + sizeof(netfn) +
-					   sizeof(cmd) + sizeof(cc) +
-					   payload.size());
+    if (verbose)
+    {
+        unsigned int lenRecv;
+        unsigned int* p = (unsigned int*)rawIter;
+        lenRecv = p[0];
+        std::string msgToLog =
+            "Read ssif request message with"
+            " len=" +
+            std::to_string(lenRecv) + " netfn=" + std::to_string(netfn) +
+            " lun=" + std::to_string(lun) + " cmd=" + std::to_string(cmd) +
+            " numberOfReqNotRsp=" + std::to_string(numberOfReqNotRsp);
+        log<level::INFO>(msgToLog.c_str());
+    }
+    // copy out payload
+    std::vector<uint8_t> data(rawIter + sizeofLenField + 2, rawEnd);
+    // non-session bridges still need to pass an empty options map
+    std::map<std::string, std::variant<int>> options;
+    // the response is a tuple because dbus can only return a single value
+    using IpmiDbusRspType =
+        std::tuple<uint8_t, uint8_t, uint8_t, uint8_t, std::vector<uint8_t>>;
+    static constexpr const char ipmiQueueService[] =
+        "xyz.openbmc_project.Ipmi.Host";
+    static constexpr const char ipmiQueuePath[] = "/xyz/openbmc_project/Ipmi";
+    static constexpr const char ipmiQueueIntf[] =
+        "xyz.openbmc_project.Ipmi.Server";
+    static constexpr const char ipmiQueueMethod[] = "execute";
+    /* now, we do not care dbus timeout, since we already have actions
+     * before dbus timeout occurs
+     */
+    static constexpr unsigned int dbusTimeout = 60000000;
+    bus->async_method_call_timed(
+        [this, netfnCap{netfn}, lunCap{lun},
+         cmdCap{cmd}](const boost::system::error_code& ec,
+                      const IpmiDbusRspType& response) {
+        std::vector<uint8_t> rsp;
+        const auto& [netfn, lun, cmd, cc, payload] = response;
+        numberOfReqNotRsp--;
+        if (ec)
+        {
+            std::string msgToLog =
+                "ssif<->ipmid bus error:"
+                " netfn=" +
+                std::to_string(netfn) + " lun=" + std::to_string(lun) +
+                " cmd=" + std::to_string(cmd) + " error=" + ec.message();
+            log<level::ERR>(msgToLog.c_str());
+            rsp.resize(sizeofLenField + sizeof(netfn) + sizeof(cmd) +
+                       sizeof(cc));
+            /* if dbusTimeout, just return and do not send any response
+             * to let host continue with other commands, response here
+             * is potentially make the response duplicated
+             * */
+            return;
+        }
+        else
+        {
+            if ((prev_req_cmd.netfn != (netfn - 1) || prev_req_cmd.lun != lun ||
+                 prev_req_cmd.cmd != cmd) ||
+                ((prev_req_cmd.netfn == (netfn - 1) &&
+                  prev_req_cmd.lun == lun && prev_req_cmd.cmd == cmd) &&
+                 numberOfReqNotRsp != 0))
+            {
+                /* Only send response to the last request command to void
+                 * duplicated response which makes host driver confused and
+                 * failed to create interface
+                 *
+                 * Drop responses which are (1) different from the request
+                 * (2) parameters are the same as request but handshake flow
+                 * are in dupplicate request state
+                 * */
+                if (verbose)
+                {
+                    std::string msgToLog = "Drop ssif respond message with"
+                                           " len=" +
+                                           std::to_string(payload.size() + 3) +
+                                           " netfn=" + std::to_string(netfn) +
+                                           " lun=" + std::to_string(lun) +
+                                           " cmd=" + std::to_string(cmd) +
+                                           " cc=" + std::to_string(cc) +
+                                           " numberOfReqNotRsp=" +
+                                           std::to_string(numberOfReqNotRsp);
+                    log<level::INFO>(msgToLog.c_str());
+                }
+                return;
+            }
+            rsp.resize(sizeofLenField + sizeof(netfn) + sizeof(cmd) +
+                       sizeof(cc) + payload.size());
 
-				// write the response
-				auto rspIter = rsp.begin();
-				unsigned int *p = (unsigned int *)&rspIter[0];
-				*p = payload.size() + 3;
-				rspIter[sizeofLenField] =
-					(netfn << netFnShift) | (lun & lunMask);
-				rspIter[sizeofLenField + 1] = cmd;
-				rspIter[sizeofLenField + 2] = cc;
-				if (payload.size()) {
-					std::copy(payload.cbegin(),
-						  payload.cend(),
-						  rspIter + sizeofLenField + 3);
-				}
-			}
-			if (verbose) {
-				std::string msgToLog =
-					"Send ssif respond message with"
-					" len=" +
-					std::to_string(payload.size() + 3) +
-					" netfn=" + std::to_string(netfn) +
-					" lun=" + std::to_string(lun) +
-					" cmd=" + std::to_string(cmd) +
-					" cc=" + std::to_string(cc) +
-					" numberOfReqNotRsp=" +
-					std::to_string(numberOfReqNotRsp);
-				log<level::INFO>(msgToLog.c_str());
-			}
-			boost::system::error_code ecWr;
-			size_t wlen = boost::asio::write(
-				*dev, boost::asio::buffer(rsp), ecWr);
-			if (ecWr || wlen != rsp.size()) {
-				std::string msgToLog =
-					"Failed to send ssif respond message:"
-					" size=" +
-					std::to_string(wlen) + " expect=" +
-					std::to_string(rsp.size()) +
-					" error=" + ecWr.message() +
-					" netfn=" + std::to_string(netfn) +
-					" lun=" + std::to_string(lun) +
-					" cmd=" + std::to_string(cmd) +
-					" cc=" + std::to_string(cc);
-				log<level::ERR>(msgToLog.c_str());
-			}
-			rspTimer->stop();
-		},
-		ipmiQueueService, ipmiQueuePath, ipmiQueueIntf, ipmiQueueMethod,
-		dbusTimeout, netfn, lun, cmd, data, options);
+            // write the response
+            auto rspIter = rsp.begin();
+            unsigned int* p = (unsigned int*)&rspIter[0];
+            *p = payload.size() + 3;
+            rspIter[sizeofLenField] = (netfn << netFnShift) | (lun & lunMask);
+            rspIter[sizeofLenField + 1] = cmd;
+            rspIter[sizeofLenField + 2] = cc;
+            if (payload.size())
+            {
+                std::copy(payload.cbegin(), payload.cend(),
+                          rspIter + sizeofLenField + 3);
+            }
+        }
+        if (verbose)
+        {
+            std::string msgToLog =
+                "Send ssif respond message with"
+                " len=" +
+                std::to_string(payload.size() + 3) +
+                " netfn=" + std::to_string(netfn) +
+                " lun=" + std::to_string(lun) + " cmd=" + std::to_string(cmd) +
+                " cc=" + std::to_string(cc) +
+                " numberOfReqNotRsp=" + std::to_string(numberOfReqNotRsp);
+            log<level::INFO>(msgToLog.c_str());
+        }
+        boost::system::error_code ecWr;
+        size_t wlen = boost::asio::write(*dev, boost::asio::buffer(rsp), ecWr);
+        if (ecWr || wlen != rsp.size())
+        {
+            std::string msgToLog =
+                "Failed to send ssif respond message:"
+                " size=" +
+                std::to_string(wlen) + " expect=" + std::to_string(rsp.size()) +
+                " error=" + ecWr.message() + " netfn=" + std::to_string(netfn) +
+                " lun=" + std::to_string(lun) + " cmd=" + std::to_string(cmd) +
+                " cc=" + std::to_string(cc);
+            log<level::ERR>(msgToLog.c_str());
+        }
+        rspTimer->stop();
+    },
+        ipmiQueueService, ipmiQueuePath, ipmiQueueIntf, ipmiQueueMethod,
+        dbusTimeout, netfn, lun, cmd, data, options);
 }
 
-int main(int argc, char *argv[])
+int main(int argc, char* argv[])
 {
-	CLI::App app("SSIF IPMI bridge");
-	std::string device;
-	app.add_option("-d,--device", device,
-		       "use <DEVICE> file. Default is /dev/ipmi-ssif-host");
-	bool verbose = false;
-	int numberOfReqNotRsp = 0;
-	app.add_option("-v,--verbose", verbose, "print more verbose output");
-	CLI11_PARSE(app, argc, argv);
+    CLI::App app("SSIF IPMI bridge");
+    std::string device;
+    app.add_option("-d,--device", device,
+                   "use <DEVICE> file. Default is /dev/ipmi-ssif-host");
+    bool verbose = false;
+    int numberOfReqNotRsp = 0;
+    app.add_option("-v,--verbose", verbose, "print more verbose output");
+    CLI11_PARSE(app, argc, argv);
 
-	// Connect to system bus
-	auto io = std::make_shared<boost::asio::io_context>();
-	sd_bus *dbus;
-	sd_bus_default_system(&dbus);
+    // Connect to system bus
+    auto io = std::make_shared<boost::asio::io_context>();
+    sd_bus* dbus;
+    sd_bus_default_system(&dbus);
 
-	/* This might be a phosphor::Timer bug, without timer t2, rspTimer
-	 * will not work
-	 */
-	phosphor::Timer t2([]() { ; });
-	t2.start(std::chrono::microseconds(500000), true);
-	auto bus = std::make_shared<sdbusplus::asio::connection>(*io, dbus);
-	bus->request_name(ssifBus);
-	// Create the SSIF channel, listening on D-Bus and on the SSIF device
-	ssifchannel = make_unique<SsifChannel>(io, bus, device, verbose,
-					       numberOfReqNotRsp);
-	if (!ssifchannel->initOK()) {
-		return EXIT_FAILURE;
-	}
-	initTimer();
-	sdbusplus::asio::sd_event_wrapper sdEvents(*io);
-	io->run();
+    /* This might be a phosphor::Timer bug, without timer t2, rspTimer
+     * will not work
+     */
+    phosphor::Timer t2([]() { ; });
+    t2.start(std::chrono::microseconds(500000), true);
+    auto bus = std::make_shared<sdbusplus::asio::connection>(*io, dbus);
+    bus->request_name(ssifBus);
+    // Create the SSIF channel, listening on D-Bus and on the SSIF device
+    ssifchannel = make_unique<SsifChannel>(io, bus, device, verbose,
+                                           numberOfReqNotRsp);
+    if (!ssifchannel->initOK())
+    {
+        return EXIT_FAILURE;
+    }
+    initTimer();
+    sdbusplus::asio::sd_event_wrapper sdEvents(*io);
+    io->run();
 
-	return 0;
+    return 0;
 }