diff --git a/src/selcommands.cpp b/src/selcommands.cpp
new file mode 100644
index 0000000..0fc33b4
--- /dev/null
+++ b/src/selcommands.cpp
@@ -0,0 +1,349 @@
+/*
+ * Copyright (c)  2018 Intel Corporation.
+ * Copyright (c)  2018-present Facebook.
+ *
+ * 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 <ipmid/api.hpp>
+
+#include <boost/algorithm/string/join.hpp>
+#include <nlohmann/json.hpp>
+#include <iostream>
+#include <sstream>
+#include <fstream>
+#include <phosphor-logging/log.hpp>
+#include <sdbusplus/message/types.hpp>
+#include <sdbusplus/timer.hpp>
+#include <storagecommands.hpp>
+
+//----------------------------------------------------------------------
+// Platform specific functions for storing app data
+//----------------------------------------------------------------------
+
+static void toHexStr(std::vector<uint8_t> &bytes, std::string &hexStr)
+{
+    std::stringstream stream;
+    stream << std::hex << std::uppercase << std::setfill('0');
+    for (const uint8_t byte : bytes)
+    {
+        stream << std::setw(2) << static_cast<int>(byte);
+    }
+    hexStr = stream.str();
+}
+
+static int fromHexStr(const std::string hexStr, std::vector<uint8_t> &data)
+{
+    for (unsigned int i = 0; i < hexStr.size(); i += 2)
+    {
+        try
+        {
+            data.push_back(static_cast<uint8_t>(
+                std::stoul(hexStr.substr(i, 2), nullptr, 16)));
+        }
+        catch (std::invalid_argument &e)
+        {
+            phosphor::logging::log<phosphor::logging::level::ERR>(e.what());
+            return -1;
+        }
+        catch (std::out_of_range &e)
+        {
+            phosphor::logging::log<phosphor::logging::level::ERR>(e.what());
+            return -1;
+        }
+    }
+    return 0;
+}
+
+namespace fb_oem::ipmi::sel
+{
+
+class SELData
+{
+  private:
+    nlohmann::json selDataObj;
+
+    void flush()
+    {
+        std::ofstream file(SEL_JSON_DATA_FILE);
+        file << selDataObj;
+        file.close();
+    }
+
+    void init()
+    {
+        selDataObj[KEY_SEL_VER] = 0x51;
+        selDataObj[KEY_SEL_COUNT] = 0;
+        selDataObj[KEY_ADD_TIME] = 0xFFFFFFFF;
+        selDataObj[KEY_ERASE_TIME] = 0xFFFFFFFF;
+        selDataObj[KEY_OPER_SUPP] = 0x02;
+        /* Spec indicates that more than 64kB is free */
+        selDataObj[KEY_FREE_SPACE] = 0xFFFF;
+    }
+
+  public:
+    SELData()
+    {
+        /* Get App data stored in json file */
+        std::ifstream file(SEL_JSON_DATA_FILE);
+        if (file)
+        {
+            file >> selDataObj;
+            file.close();
+        }
+
+        /* Initialize SelData object if no entries. */
+        if (selDataObj.find(KEY_SEL_COUNT) == selDataObj.end())
+        {
+            init();
+        }
+    }
+
+    int clear()
+    {
+        /* Clear the complete Sel Json object */
+        selDataObj.clear();
+        /* Reinitialize it with basic data */
+        init();
+        /* Save the erase time */
+        struct timespec selTime = {};
+        if (clock_gettime(CLOCK_REALTIME, &selTime) < 0)
+        {
+            return -1;
+        }
+        selDataObj[KEY_ERASE_TIME] = selTime.tv_sec;
+        flush();
+        return 0;
+    }
+
+    uint32_t getCount()
+    {
+        return selDataObj[KEY_SEL_COUNT];
+    }
+
+    void getInfo(GetSELInfoData &info)
+    {
+        info.selVersion = selDataObj[KEY_SEL_VER];
+        info.entries = selDataObj[KEY_SEL_COUNT];
+        info.freeSpace = selDataObj[KEY_FREE_SPACE];
+        info.addTimeStamp = selDataObj[KEY_ADD_TIME];
+        info.eraseTimeStamp = selDataObj[KEY_ERASE_TIME];
+        info.operationSupport = selDataObj[KEY_OPER_SUPP];
+    }
+
+    int getEntry(uint32_t index, std::string &rawStr)
+    {
+        std::stringstream ss;
+        ss << std::hex;
+        ss << std::setw(2) << std::setfill('0') << index;
+
+        /* Check or the requested SEL Entry, if record is available */
+        if (selDataObj.find(ss.str()) == selDataObj.end())
+        {
+            return -1;
+        }
+
+        rawStr = selDataObj[ss.str()][KEY_SEL_ENTRY_RAW];
+        return 0;
+    }
+
+    int addEntry(std::string keyStr)
+    {
+        struct timespec selTime = {};
+
+        if (clock_gettime(CLOCK_REALTIME, &selTime) < 0)
+        {
+            return -1;
+        }
+
+        selDataObj[KEY_ADD_TIME] = selTime.tv_sec;
+
+        int selCount = selDataObj[KEY_SEL_COUNT];
+        selDataObj[KEY_SEL_COUNT] = ++selCount;
+
+        std::stringstream ss;
+        ss << std::hex;
+        ss << std::setw(2) << std::setfill('0') << selCount;
+
+        selDataObj[ss.str()][KEY_SEL_ENTRY_RAW] = keyStr;
+        flush();
+        return selCount;
+    }
+};
+
+} // namespace fb_oem::ipmi::sel
+
+namespace ipmi
+{
+
+namespace storage
+{
+
+static void registerSELFunctions() __attribute__((constructor));
+static fb_oem::ipmi::sel::SELData selObj __attribute__((init_priority(101)));
+
+ipmi::RspType<uint8_t,  // SEL version
+              uint16_t, // SEL entry count
+              uint16_t, // free space
+              uint32_t, // last add timestamp
+              uint32_t, // last erase timestamp
+              uint8_t>  // operation support
+    ipmiStorageGetSELInfo()
+{
+
+    fb_oem::ipmi::sel::GetSELInfoData info;
+
+    selObj.getInfo(info);
+    return ipmi::responseSuccess(info.selVersion, info.entries, info.freeSpace,
+                                 info.addTimeStamp, info.eraseTimeStamp,
+                                 info.operationSupport);
+}
+
+ipmi::RspType<uint16_t, std::vector<uint8_t>>
+    ipmiStorageGetSELEntry(std::vector<uint8_t> data)
+{
+
+    if (data.size() != sizeof(fb_oem::ipmi::sel::GetSELEntryRequest))
+    {
+        return ipmi::responseReqDataLenInvalid();
+    }
+
+    fb_oem::ipmi::sel::GetSELEntryRequest *reqData =
+        reinterpret_cast<fb_oem::ipmi::sel::GetSELEntryRequest *>(&data[0]);
+
+    if (reqData->reservID != 0)
+    {
+        if (!checkSELReservation(reqData->reservID))
+        {
+            return ipmi::responseInvalidReservationId();
+        }
+    }
+
+    uint16_t selCnt = selObj.getCount();
+    if (selCnt == 0)
+    {
+        return ipmi::responseSensorInvalid();
+    }
+
+    /* If it is asked for first entry */
+    if (reqData->recordID == fb_oem::ipmi::sel::firstEntry)
+    {
+        /* First Entry (0x0000) as per Spec */
+        reqData->recordID = 1;
+    }
+    else if (reqData->recordID == fb_oem::ipmi::sel::lastEntry)
+    {
+        /* Last entry (0xFFFF) as per Spec */
+        reqData->recordID = selCnt;
+    }
+
+    std::string ipmiRaw;
+
+    if (selObj.getEntry(reqData->recordID, ipmiRaw) < 0)
+    {
+        return ipmi::responseSensorInvalid();
+    }
+
+    std::vector<uint8_t> recDataBytes;
+    if (fromHexStr(ipmiRaw, recDataBytes) < 0)
+    {
+        return ipmi::responseUnspecifiedError();
+    }
+
+    /* Identify the next SEL record ID. If recordID is same as
+     * total SeL count then next id should be last entry else
+     * it should be incremented by 1 to current RecordID
+     */
+    uint16_t nextRecord;
+    if (reqData->recordID == selCnt)
+    {
+        nextRecord = fb_oem::ipmi::sel::lastEntry;
+    }
+    else
+    {
+        nextRecord = reqData->recordID + 1;
+    }
+
+    if (reqData->readLen == fb_oem::ipmi::sel::entireRecord)
+    {
+        return ipmi::responseSuccess(nextRecord, recDataBytes);
+    }
+    else
+    {
+        if (reqData->offset >= fb_oem::ipmi::sel::selRecordSize ||
+            reqData->readLen > fb_oem::ipmi::sel::selRecordSize)
+        {
+            return ipmi::responseUnspecifiedError();
+        }
+        std::vector<uint8_t> recPartData;
+
+        auto diff = fb_oem::ipmi::sel::selRecordSize - reqData->offset;
+        auto readLength = std::min(diff, static_cast<int>(reqData->readLen));
+
+        for (int i = 0; i < readLength; i++)
+        {
+            recPartData.push_back(recDataBytes[i + reqData->offset]);
+        }
+        return ipmi::responseSuccess(nextRecord, recPartData);
+    }
+}
+
+ipmi::RspType<uint16_t> ipmiStorageAddSELEntry(std::vector<uint8_t> data)
+{
+    /* Per the IPMI spec, need to cancel any reservation when a
+     * SEL entry is added
+     */
+    cancelSELReservation();
+
+    if (data.size() != fb_oem::ipmi::sel::selRecordSize)
+    {
+        return ipmi::responseReqDataLenInvalid();
+    }
+
+    std::string ipmiRaw, logErr;
+    toHexStr(data, ipmiRaw);
+
+    /* Log the Raw SEL message to the journal */
+    std::string journalMsg = "SEL Entry Added: " + ipmiRaw;
+    phosphor::logging::log<phosphor::logging::level::INFO>(journalMsg.c_str());
+
+    int responseID = selObj.addEntry(ipmiRaw.c_str());
+    if (responseID < 0)
+    {
+        return ipmi::responseUnspecifiedError();
+    }
+    return ipmi::responseSuccess((uint16_t)responseID);
+}
+
+void registerSELFunctions()
+{
+    // <Get SEL Info>
+    ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnStorage,
+                          ipmi::storage::cmdGetSelInfo, ipmi::Privilege::User,
+                          ipmiStorageGetSELInfo);
+
+    // <Get SEL Entry>
+    ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnStorage,
+                          ipmi::storage::cmdGetSelEntry, ipmi::Privilege::User,
+                          ipmiStorageGetSELEntry);
+
+    // <Add SEL Entry>
+    ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnStorage,
+                          ipmi::storage::cmdAddSelEntry,
+                          ipmi::Privilege::Operator, ipmiStorageAddSELEntry);
+
+    return;
+}
+
+} // namespace storage
+} // namespace ipmi