BPI-CM9-Linux/aml-comp/vendor/amlogic/aml_pqserver/libpq/SSMHandler.cpp

/*
 * Copyright (c) 2014 Amlogic, Inc. All rights reserved.
 *
 * This source code is subject to the terms and conditions defined in the
 * file 'LICENSE' which is part of this source code package.
 *
 * Description: c++ file
 */

#define LOG_MODULE_TAG "PQ"
#define LOG_CLASS_TAG "SSMHandler"

#include "SSMHandler.h"

SSMHandler* SSMHandler::mSSMHandler = NULL;

SSMHandler* SSMHandler::GetSingletonInstance(const char *SSMHandlerPath)
{

    if (!mSSMHandler) {
        mSSMHandler = new SSMHandler();
        mSSMHandler->mSSMHandlerPath = SSMHandlerPath;
        if (mSSMHandler && !mSSMHandler->Construct()) {
            delete mSSMHandler;
            mSSMHandler = NULL;
        }
    }


    return mSSMHandler;
}

SSMHandler::SSMHandler()
{
    mFd = -1;
    mSSMHandlerPath = NULL;
    memset (&mSSMHeader_section1, 0, sizeof (SSMHeader_section1_t));

    unsigned int sum = 0;
    for (unsigned int i = 1; i < gSSMHeader_section1.count; i++) {
        sum += gSSMHeader_section2[i-1].size;

        gSSMHeader_section2[i].addr = sum;
    }
}

SSMHandler::~SSMHandler()
{
    if (mFd > 0) {
        close(mFd);
        mFd = -1;
    }
}

bool SSMHandler::Construct()
{
    bool ret = true;

    mFd = open(mSSMHandlerPath, O_RDWR | O_SYNC | O_CREAT, S_IRUSR | S_IWUSR);
    if (-1 == mFd) {
        ret = false;
        LOGD ("%s, Open %s failure\n", __FUNCTION__, mSSMHandlerPath);
    }

    return ret;
}

bool SSMHandler::CheckHandler(void)
{
    lseek (mFd, 0, SEEK_SET);

    SSMHeader_section1_t header_section1;
    ssize_t ssize = read(mFd, &header_section1, sizeof(SSMHeader_section1_t));
    if (ssize != sizeof(SSMHeader_section1_t)) {
        SYS_LOGE("Failed to read section1 header, expected %zu, got %zd\n", sizeof(SSMHeader_section1_t), ssize);
        return false;
    }

    if (header_section1.count > SSM_DATA_MAX || header_section1.count == 0) {
        SYS_LOGE("Invalid count value: %u\n", header_section1.count);
        return false;
    }

    size_t required_size = header_section1.count * sizeof(SSMHeader_section2_t);
    ssize_t ssize1 = read(mFd, gSSMHeader_section2, required_size);
    if (ssize1 != static_cast<ssize_t>(required_size)) {
        SYS_LOGE("Failed to read section2 data, expected %zu, got %zd\n", required_size, ssize1);
        memset(gSSMHeader_section2, 0, required_size);
        return false;
    }

    SYS_LOGD("%s, ssize %zd, ssize1 %zd, count %u\n", __FUNCTION__, ssize, ssize1, header_section1.count);

    return true;
}

SSM_status_t SSMHandler::SSMSection1Verify()
{
    SSM_status_t ret = SSM_HEADER_VALID;

    lseek (mFd, 0, SEEK_SET);
    ssize_t ssize = read(mFd, &mSSMHeader_section1, sizeof (SSMHeader_section1_t));

    if (ssize != sizeof (SSMHeader_section1_t) ||
        mSSMHeader_section1.magic != gSSMHeader_section1.magic ||
        mSSMHeader_section1.count != gSSMHeader_section1.count ||
        mSSMHeader_section1.version != gSSMHeader_section1.version) {
        ret = SSM_HEADER_INVALID;
    }

    return ret;
}

SSM_status_t SSMHandler::SSMSection2Verify(SSM_status_t SSM_status)
{
    return SSM_status;
}

int SSMHandler::SSMSaveCurrentHeader(current_ssmheader_section2_t *header_cur)
{
    std::vector<SSMHeader_section2_t> vsection2;
    unsigned int size = 0;
    int rd_size;

    LOGD ("%s --- line:%d\n", __FUNCTION__, __LINE__);

    if (lseek (mFd, sizeof (SSMHeader_section1_t), SEEK_SET) == 1) {
        LOGE("%s seek faile\n", __FUNCTION__);
    }

    for (unsigned int i = 0; i < gSSMHeader_section1.count; i++) {
        SSMHeader_section2_t temp;

        rd_size = read(mFd, &temp, sizeof (SSMHeader_section2_t));
        if (rd_size < 0) {
            LOGE("read error = %s\n", strerror(errno));
        }
        vsection2.push_back(temp);
        size += temp.size;
    }
    header_cur->size = size;
    memcpy(header_cur->header_section2_data, &vsection2, sizeof(vsection2));

    //if (header_cur->size < 0) {
    //    LOGE ("SSMSaveCurrentHeader error!\n");
    //    return -1;
    //}

    return 0;
}

bool SSMHandler::SSMRecreateHeader()
{
    bool ret = true;
    int wr_size;
    int size;

    LOGD ("%s ---.\n", __FUNCTION__);

    size = ftruncate(mFd, 0);
    if (size < 0) {
        LOGE("ftruncate error = %s\n", strerror(errno));
    }
    lseek (mFd, 0, SEEK_SET);

    //cal Addr and write
    size = write(mFd, &gSSMHeader_section1, sizeof (SSMHeader_section1_t));
    if (size < 0) {
        LOGE("write error = %s\n", strerror(errno));
    }

    wr_size = write(mFd, gSSMHeader_section2, gSSMHeader_section1.count * sizeof (SSMHeader_section2_t));
    if (wr_size < 0) {
        LOGE("write error = %s\n", strerror(errno));
    }

    return ret;
}

unsigned int SSMHandler::SSMGetActualAddr(int id)
{
    return gSSMHeader_section2[id].addr;
}

unsigned int SSMHandler::SSMGetActualSize(int id)
{
    return gSSMHeader_section2[id].size;
}

SSM_status_t SSMHandler::SSMVerify()
{
    return  SSMSection2Verify(SSMSection1Verify());
}

SSMHandler& SSMHandler::operator = (const SSMHandler& obj)
{
    return const_cast<SSMHandler&>(obj);
}