embedded-framework/utils/SharedData/src/SharedDataImpl.cpp

/*
 * Copyright (c) 2023 Fancy Code.
 * 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 "SharedDataImpl.h"
#include "ILog.h"
#include "SharedData.h"
#include "SharedDataCode.h"
#include "SharedMemory.h"
#include "StatusCode.h"
#include <cstring>
constexpr short THERE_TWO_USER_DATA_HEADER = 2;
SharedDataImpl::SharedDataImpl(const SHARER_NAME &sharerName, const char *path, const int &projectId)
    : SharedMemory(path, projectId), mSharerName(sharerName)
{
    mPrimaryReadSize = 0;
    mMinorReadSize = 0;
    mSharedMemeory = nullptr;
}
void SharedDataImpl::MakeSharedMemory(const unsigned int readableSize, const unsigned int writableSize)
{
    if (SHARER_NAME_PRIMARY == mSharerName) {
        mPrimaryReadSize = readableSize;
        mMinorReadSize = writableSize;
    }
    else if (SHARER_NAME_MINOR == mSharerName) {
        mPrimaryReadSize = writableSize;
        mMinorReadSize = readableSize;
    }
    else {
        LogError("Make shared memory failed.\n");
        return;
    }
    const int SHARED_MEMORY_SIZE = readableSize + writableSize + sizeof(UserDataHeader) * THERE_TWO_USER_DATA_HEADER;
    SharedMemory::MakeSharedMemory(SHARED_MEMORY_SIZE);
    mSharedMemeory = SharedMemory::GetMemory();
    WritableDataInit();
}
const StatusCode SharedDataImpl::GetReadableMemory(void *buf, const unsigned int &bufLength)
{
    if (nullptr == mSharedMemeory) {
        LogError("mSharedMemeory is nullptr, failed.\n");
        return CreateStatusCode(STATUS_CODE_NOT_OK);
    }
    if (SHARER_NAME_PRIMARY == mSharerName && bufLength == mPrimaryReadSize) {
        UserDataHeader *readableHeader = (UserDataHeader *)((char *)mSharedMemeory);
        LogInfo("Want to read %d and can be read %d\n", bufLength, readableHeader->mDataLength);
        if (memcmp(readableHeader->mUserName, USER_NAME_INIT_NAME, USER_NAME_BUF_LENGTH) == 0 &&
            bufLength == readableHeader->mDataLength) {
            memcpy(buf, (char *)mSharedMemeory + sizeof(UserDataHeader), bufLength);
        }
        else {
            LogError("Readable memory didn't init yet or init error.\n");
            return CreateSharedDataCode(SHARED_DATA_CODE_WRONG_PEER_PARAMETERS);
        }
    }
    else if (SHARER_NAME_MINOR == mSharerName && bufLength == mMinorReadSize) {
        UserDataHeader *readableHeader =
            (UserDataHeader *)((char *)mSharedMemeory + sizeof(UserDataHeader) + mPrimaryReadSize);
        LogInfo("Want to read %d and can be read %d\n", bufLength, readableHeader->mDataLength);
        if (memcmp(readableHeader->mUserName, USER_NAME_INIT_NAME, USER_NAME_BUF_LENGTH) == 0 &&
            bufLength == readableHeader->mDataLength) {
            memcpy(buf,
                   (char *)mSharedMemeory + sizeof(UserDataHeader) * THERE_TWO_USER_DATA_HEADER + mPrimaryReadSize,
                   bufLength);
        }
        else {
            LogError("Readable memory didn't init yet or init error.\n");
            return CreateSharedDataCode(SHARED_DATA_CODE_WRONG_PEER_PARAMETERS);
        }
    }
    else {
        LogError("Get readable memory failed.\n");
        return CreateStatusCode(STATUS_CODE_INVALID_PARAMENTER);
    }
    return CreateStatusCode(STATUS_CODE_OK);
}
void SharedDataImpl::SetWritableMemory(void *buf, const unsigned int &bufLength)
{
    if (nullptr == mSharedMemeory) {
        LogError("mSharedMemeory is nullptr, failed.\n");
        return;
    }
    if (SHARER_NAME_PRIMARY == mSharerName && bufLength == mMinorReadSize) {
        UserDataHeader *readableHeader = (UserDataHeader *)((char *)mSharedMemeory);
        if (memcmp(readableHeader->mUserName, USER_NAME_INIT_NAME, USER_NAME_BUF_LENGTH) == 0) {
            if (mPrimaryReadSize == readableHeader->mDataLength) {
                memcpy((char *)mSharedMemeory + sizeof(UserDataHeader) * THERE_TWO_USER_DATA_HEADER + mPrimaryReadSize,
                       buf,
                       bufLength);
            }
            else {
                LogError("Peer not match.\n");
            }
        }
        else {
            memcpy((char *)mSharedMemeory + sizeof(UserDataHeader) * THERE_TWO_USER_DATA_HEADER + mPrimaryReadSize,
                   buf,
                   bufLength);
        }
    }
    else if (SHARER_NAME_MINOR == mSharerName && bufLength == mPrimaryReadSize) {
        memcpy((char *)mSharedMemeory + sizeof(UserDataHeader), buf, bufLength);
    }
    else {
        LogError("Set writable memory failed.\n");
    }
}
StatusCode SharedDataImpl::FreeSharedMemory(void)
{
    return CleanSharedMemory();
}
void SharedDataImpl::WritableDataInit(void)
{
    if (nullptr == mSharedMemeory) {
        LogError("mSharedMemeory is nullptr, failed.\n");
        return;
    }
    if (SHARER_NAME_PRIMARY == mSharerName) {
        UserDataHeader *writableHeader =
            (UserDataHeader *)((char *)mSharedMemeory + sizeof(UserDataHeader) + mPrimaryReadSize);
        memcpy(writableHeader->mUserName, USER_NAME_INIT_NAME, USER_NAME_BUF_LENGTH);
        writableHeader->mDataLength = mMinorReadSize;
    }
    else if (SHARER_NAME_MINOR == mSharerName) {
        UserDataHeader *writableHeader = (UserDataHeader *)((char *)mSharedMemeory);
        memcpy(writableHeader->mUserName, USER_NAME_INIT_NAME, USER_NAME_BUF_LENGTH);
        writableHeader->mDataLength = mPrimaryReadSize;
    }
    else {
        LogError("Make shared memory failed.\n");
        return;
    }
}