diff --git a/sensorhandler.cpp b/sensorhandler.cpp
index a175f20..e641a93 100644
--- a/sensorhandler.cpp
+++ b/sensorhandler.cpp
@@ -1128,8 +1128,7 @@
 }
 
 ipmi::Cc populate_record_from_dbus(get_sdr::SensorDataFullRecordBody* body,
-                                   const ipmi::sensor::Info* info,
-                                   ipmi_data_len_t)
+                                   const ipmi::sensor::Info* info)
 {
     /* Functional sensor case */
     if (isAnalogSensor(info->propertyInterfaces.begin()->first))
@@ -1166,27 +1165,24 @@
     return ipmi::ccSuccess;
 };
 
-ipmi::Cc ipmi_fru_get_sdr(ipmi_request_t request, ipmi_response_t response,
-                          ipmi_data_len_t data_len)
+ipmi::RspType<uint16_t,            // nextRecordId
+              std::vector<uint8_t> // recordData
+              >
+    ipmiFruGetSdr(uint16_t recordID, uint8_t offset, uint8_t bytesToRead)
 {
-    auto req = reinterpret_cast<get_sdr::GetSdrReq*>(request);
-    auto resp = reinterpret_cast<get_sdr::GetSdrResp*>(response);
-    get_sdr::SensorDataFruRecord record{};
-    auto dataLength = 0;
-
     auto fru = frus.begin();
     uint8_t fruID{};
-    auto recordID = get_sdr::request::get_record_id(req);
 
     fruID = recordID - FRU_RECORD_ID_START;
     fru = frus.find(fruID);
     if (fru == frus.end())
     {
-        return ipmi::ccSensorInvalid;
+        return ipmi::responseSensorInvalid();
     }
 
+    get_sdr::SensorDataFruRecord record{};
     /* Header */
-    get_sdr::header::set_record_id(recordID, &(record.header));
+    record.header.recordId = recordID;
     record.header.sdr_version = SDR_VERSION; // Based on IPMI Spec v2.0 rev 1.1
     record.header.record_type = get_sdr::SENSOR_DATA_FRU_RECORD;
     record.header.record_length = sizeof(record.key) + sizeof(record.body);
@@ -1217,6 +1213,7 @@
         get_sdr::body::set_device_id_strlen(deviceID.length(), &(record.body));
     }
 
+    uint16_t nextRecordId{};
     strncpy(record.body.deviceID, deviceID.c_str(),
             get_sdr::body::get_device_id_strlen(&(record.body)));
 
@@ -1227,60 +1224,53 @@
         const auto& entityRecords =
             ipmi::sensor::EntityInfoMapContainer::getContainer()
                 ->getIpmiEntityRecords();
-        auto next_record_id =
+        nextRecordId =
             (entityRecords.size())
                 ? entityRecords.begin()->first + ENTITY_RECORD_ID_START
                 : END_OF_RECORD;
-        get_sdr::response::set_next_record_id(next_record_id, resp);
     }
     else
     {
-        get_sdr::response::set_next_record_id(
-            (FRU_RECORD_ID_START + fru->first), resp);
+        nextRecordId = FRU_RECORD_ID_START + fru->first;
     }
 
     // Check for invalid offset size
-    if (req->offset > sizeof(record))
+    if (offset > sizeof(record))
     {
-        return ipmi::ccParmOutOfRange;
+        return ipmi::responseParmOutOfRange();
     }
 
-    dataLength = std::min(static_cast<size_t>(req->bytes_to_read),
-                          sizeof(record) - req->offset);
+    size_t dataLen =
+        std::min(static_cast<size_t>(bytesToRead), sizeof(record) - offset);
 
-    std::memcpy(resp->record_data,
-                reinterpret_cast<uint8_t*>(&record) + req->offset, dataLength);
+    std::vector<uint8_t> recordData(dataLen);
+    std::memcpy(recordData.data(),
+                reinterpret_cast<const uint8_t*>(&record) + offset, dataLen);
 
-    *data_len = dataLength;
-    *data_len += 2; // additional 2 bytes for next record ID
-
-    return ipmi::ccSuccess;
+    return ipmi::responseSuccess(nextRecordId, recordData);
 }
 
-ipmi::Cc ipmi_entity_get_sdr(ipmi_request_t request, ipmi_response_t response,
-                             ipmi_data_len_t data_len)
+ipmi::RspType<uint16_t,            // nextRecordId
+              std::vector<uint8_t> // recordData
+              >
+    ipmiEntityGetSdr(uint16_t recordID, uint8_t offset, uint8_t bytesToRead)
 {
-    auto req = reinterpret_cast<get_sdr::GetSdrReq*>(request);
-    auto resp = reinterpret_cast<get_sdr::GetSdrResp*>(response);
-    get_sdr::SensorDataEntityRecord record{};
-    auto dataLength = 0;
-
     const auto& entityRecords =
         ipmi::sensor::EntityInfoMapContainer::getContainer()
             ->getIpmiEntityRecords();
     auto entity = entityRecords.begin();
     uint8_t entityRecordID;
-    auto recordID = get_sdr::request::get_record_id(req);
 
     entityRecordID = recordID - ENTITY_RECORD_ID_START;
     entity = entityRecords.find(entityRecordID);
     if (entity == entityRecords.end())
     {
-        return ipmi::ccSensorInvalid;
+        return ipmi::responseSensorInvalid();
     }
 
+    get_sdr::SensorDataEntityRecord record{};
     /* Header */
-    get_sdr::header::set_record_id(recordID, &(record.header));
+    record.header.recordId = recordID;
     record.header.sdr_version = SDR_VERSION; // Based on IPMI Spec v2.0 rev 1.1
     record.header.record_type = get_sdr::SENSOR_DATA_ENTITY_RECORD;
     record.header.record_length = sizeof(record.key) + sizeof(record.body);
@@ -1301,47 +1291,41 @@
     record.body.entityId4 = entity->second.containedEntities[3].first;
     record.body.entityInstance4 = entity->second.containedEntities[3].second;
 
+    uint16_t nextRecordId{};
     if (++entity == entityRecords.end())
     {
-        get_sdr::response::set_next_record_id(END_OF_RECORD,
-                                              resp); // last record
+        nextRecordId = END_OF_RECORD;
     }
     else
     {
-        get_sdr::response::set_next_record_id(
-            (ENTITY_RECORD_ID_START + entity->first), resp);
+        nextRecordId = entity->first + ENTITY_RECORD_ID_START;
     }
 
     // Check for invalid offset size
-    if (req->offset > sizeof(record))
+    if (offset > sizeof(record))
     {
-        return ipmi::ccParmOutOfRange;
+        return ipmi::responseParmOutOfRange();
     }
 
-    dataLength = std::min(static_cast<size_t>(req->bytes_to_read),
-                          sizeof(record) - req->offset);
+    size_t dataLen =
+        std::min(static_cast<size_t>(bytesToRead), sizeof(record) - offset);
 
-    std::memcpy(resp->record_data,
-                reinterpret_cast<uint8_t*>(&record) + req->offset, dataLength);
+    std::vector<uint8_t> recordData(dataLen);
+    std::memcpy(recordData.data(),
+                reinterpret_cast<const uint8_t*>(&record) + offset, dataLen);
 
-    *data_len = dataLength;
-    *data_len += 2; // additional 2 bytes for next record ID
-
-    return ipmi::ccSuccess;
+    return ipmi::responseSuccess(nextRecordId, recordData);
 }
 
-ipmi::Cc ipmi_sen_get_sdr(ipmi_netfn_t, ipmi_cmd_t, ipmi_request_t request,
-                          ipmi_response_t response, ipmi_data_len_t data_len,
-                          ipmi_context_t)
+ipmi::RspType<uint16_t,            // nextRecordId
+              std::vector<uint8_t> // recordData
+              >
+    ipmiSensorGetSdr(uint16_t /* reservationId */, uint16_t recordID,
+                     uint8_t offset, uint8_t bytesToRead)
 {
-    ipmi::Cc ret = ipmi::ccSuccess;
-    get_sdr::GetSdrReq* req = (get_sdr::GetSdrReq*)request;
-    get_sdr::GetSdrResp* resp = (get_sdr::GetSdrResp*)response;
-
     // Note: we use an iterator so we can provide the next ID at the end of
     // the call.
     auto sensor = ipmi::sensor::sensors.begin();
-    auto recordID = get_sdr::request::get_record_id(req);
 
     // At the beginning of a scan, the host side will send us id=0.
     if (recordID != 0)
@@ -1353,19 +1337,19 @@
         // record, FRU record and Enttiy Association record.
         if (recordID >= ENTITY_RECORD_ID_START)
         {
-            return ipmi_entity_get_sdr(request, response, data_len);
+            return ipmiEntityGetSdr(recordID, offset, bytesToRead);
         }
         else if (recordID >= FRU_RECORD_ID_START &&
                  recordID < ENTITY_RECORD_ID_START)
         {
-            return ipmi_fru_get_sdr(request, response, data_len);
+            return ipmiFruGetSdr(recordID, offset, bytesToRead);
         }
         else
         {
             sensor = ipmi::sensor::sensors.find(recordID);
             if (sensor == ipmi::sensor::sensors.end())
             {
-                return ipmi::ccSensorInvalid;
+                return ipmi::responseSensorInvalid();
             }
         }
     }
@@ -1377,7 +1361,7 @@
     {
         /* Header */
         get_sdr::SensorDataFullRecord record = {};
-        get_sdr::header::set_record_id(sensor_id, &(record.header));
+        record.header.recordId = sensor_id;
         record.header.sdr_version = 0x51; // Based on IPMI Spec v2.0 rev 1.1
         record.header.record_type = get_sdr::SENSOR_DATA_FULL_RECORD;
         record.header.record_length = sizeof(record.key) + sizeof(record.body);
@@ -1398,46 +1382,38 @@
         }
 
         // Set the type-specific details given the DBus interface
-        populate_record_from_dbus(&(record.body), &(sensor->second), data_len);
+        populate_record_from_dbus(&(record.body), &(sensor->second));
         sdrCacheMap[sensor_id] = std::move(record);
     }
 
+    uint16_t nextRecordId{};
     const auto& record = sdrCacheMap[sensor_id];
 
     if (++sensor == ipmi::sensor::sensors.end())
     {
         // we have reached till end of sensor, so assign the next record id
         // to 256(Max Sensor ID = 255) + FRU ID(may start with 0).
-        auto next_record_id = (frus.size())
-                                  ? frus.begin()->first + FRU_RECORD_ID_START
-                                  : END_OF_RECORD;
-
-        get_sdr::response::set_next_record_id(next_record_id, resp);
+        nextRecordId = (frus.size()) ? frus.begin()->first + FRU_RECORD_ID_START
+                                     : END_OF_RECORD;
     }
     else
     {
-        get_sdr::response::set_next_record_id(sensor->first, resp);
+        nextRecordId = sensor->first;
     }
 
-    if (req->offset > sizeof(record))
+    if (offset > sizeof(record))
     {
-        return ipmi::ccParmOutOfRange;
+        return ipmi::responseParmOutOfRange();
     }
 
-    // data_len will ultimately be the size of the record, plus
-    // the size of the next record ID:
-    *data_len = std::min(static_cast<size_t>(req->bytes_to_read),
-                         sizeof(record) - req->offset);
+    size_t dataLen =
+        std::min(static_cast<size_t>(bytesToRead), sizeof(record) - offset);
 
-    std::memcpy(resp->record_data,
-                reinterpret_cast<const uint8_t*>(&record) + req->offset,
-                *data_len);
+    std::vector<uint8_t> recordData(dataLen);
+    std::memcpy(recordData.data(),
+                reinterpret_cast<const uint8_t*>(&record) + offset, dataLen);
 
-    // data_len should include the LSB and MSB:
-    *data_len += sizeof(resp->next_record_id_lsb) +
-                 sizeof(resp->next_record_id_msb);
-
-    return ret;
+    return ipmi::responseSuccess(nextRecordId, recordData);
 }
 
 static bool isFromSystemChannel()
@@ -1571,9 +1547,9 @@
                           ipmi::Privilege::User, ipmiSenSetSensorThresholds);
 
     // <Get Device SDR>
-    ipmi_register_callback(ipmi::netFnSensor,
-                           ipmi::sensor_event::cmdGetDeviceSdr, nullptr,
-                           ipmi_sen_get_sdr, PRIVILEGE_USER);
+    ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnSensor,
+                          ipmi::sensor_event::cmdGetDeviceSdr,
+                          ipmi::Privilege::User, ipmiSensorGetSdr);
 
 #endif