/*
 * @copyright Copyright (c) 2016-2020 TOYOTA MOTOR CORPORATION.
 *
 * 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.
 */

////////////////////////////////////////////////////////////////////////////////////////////////////
/// \ingroup  tag_NSSharedMemory
/// \brief    This file contains implementation of class CNSSharedMem.
///           This class provides API to open, read, write and close shared memory
///
////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////
// Include Files
////////////////////////////////////////////////////////////////////////////////////////////////////
#include <unistd.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <errno.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <limits.h>

#include <native_service/ns_sharedmem.h>
#include <native_service/ns_transmit_log.h>

#include <string>

static CNSSharedMem *g_pTransmitLogSharedBuf = NULL;

#define SHM_HEADER_EXT      "Hdr"

#ifdef __cplusplus
extern "C" {
#endif


////////////////////////////////////////////////////////////////////////////////////////////
/// NSSharedMemTransmitLogOpen
/// Open the shared memory for transmit logging
////////////////////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus NSSharedMemTransmitLogOpen() {
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;

  if (NULL == g_pTransmitLogSharedBuf) {
    // Create the instance
    g_pTransmitLogSharedBuf = new(std::nothrow) CNSSharedMem(TRANSMIT_LOG_SHAREDMEM_NAME, TRANSMIT_LOG_SHAREDMEM_SIZE);
  }

  if (NULL != g_pTransmitLogSharedBuf) {
    if (!g_pTransmitLogSharedBuf->IsOpen()) {
      // maps the shared memory buffer
      l_eStatus = g_pTransmitLogSharedBuf->Open();
    }
  } else {
    l_eStatus = eFrameworkunifiedStatusNullPointer;
  }

  return l_eStatus;
}

////////////////////////////////////////////////////////////////////////////////////////////
/// NSSharedMemTransmitLogClose
/// Close the transmit logging shared memory
////////////////////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus NSSharedMemTransmitLogClose() {
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;

  if (NULL != g_pTransmitLogSharedBuf) {
    // un-map the shared memory object
    l_eStatus = g_pTransmitLogSharedBuf->Close();

    delete g_pTransmitLogSharedBuf;
    g_pTransmitLogSharedBuf = NULL;
  } else {
    l_eStatus = eFrameworkunifiedStatusNullPointer;
  }

  return l_eStatus;
}

////////////////////////////////////////////////////////////////////////////////////////////
/// NSSharedMemReadTransmitLog
/// Reads transmit log from the shared memory buffer.
////////////////////////////////////////////////////////////////////////////////////////////
SI_32 NSSharedMemReadTransmitLog(PSTR f_pBuffer, const UI_32 f_uiLength, const BOOL f_bBlock) {
  // no. of bytes read
  SI_32 l_iReadSize = NS_SHM_ERROR;

  if (NULL != g_pTransmitLogSharedBuf && NULL != f_pBuffer) {
    // Writes log data into shared memory buffer
    l_iReadSize = g_pTransmitLogSharedBuf->Read(f_pBuffer, f_uiLength, f_bBlock);
  }

  return l_iReadSize;
}

////////////////////////////////////////////////////////////////////////////////////////////
/// NSSharedMemWriteTransmitLog
/// Write transmit log into the shared memory buffer.
////////////////////////////////////////////////////////////////////////////////////////////
SI_32 NSSharedMemWriteTransmitLog(PCSTR f_pBuffer, const UI_32 f_uiLength) {
  // no. of bytes read
  SI_32 l_iWriteSize = NS_SHM_ERROR;

  if (NULL != g_pTransmitLogSharedBuf && NULL != f_pBuffer) {
    // Writes log data into shared memory buffer
    l_iWriteSize = g_pTransmitLogSharedBuf->Write(f_pBuffer, f_uiLength);
  }

  return l_iWriteSize;
}

////////////////////////////////////////////////////////////////////////////////////////////
/// NSSharedMemDumpTransmitLogToFile
/// Dump transmit log from the shared memory buffer into file.
////////////////////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus NSSharedMemDumpTransmitLogToFile(PCSTR f_pPath, PUI_32 f_puiDumpSize) {
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusFail;

  if (NULL != g_pTransmitLogSharedBuf && NULL != f_pPath) {
    // Writes log data into shared memory buffer
    l_eStatus = g_pTransmitLogSharedBuf->DumpToFile(f_pPath, f_puiDumpSize);
  }

  return l_eStatus;
}

// Used only in nstest_sharedmem.
#if defined(SHM_UNITTEST_ENABLE)
////////////////////////////////////////////////////////////////////////////////////////////
/// NSSharedMemTransmitLogIsOpen
////////////////////////////////////////////////////////////////////////////////////////////
BOOL NSSharedMemTransmitLogIsOpen() {
  if (g_pTransmitLogSharedBuf != NULL) {
    return g_pTransmitLogSharedBuf->IsOpen();
  } else {
    return FALSE;
  }
}
#endif

#ifdef __cplusplus
}
#endif

////////////////////////////////////////////////////////////////////////////////////////////////
/// CNSSharedMem
/// Parameterized Constructor of CNSSharedMem class
////////////////////////////////////////////////////////////////////////////////////////////////
CNSSharedMem::CNSSharedMem(const std::string &f_cSharedMemName, const UI_32 f_uiSize):
  m_cShmName(f_cSharedMemName), m_uiShmBuffSize(f_uiSize), m_pShmHdr(NULL), m_pShmBuff(NULL) {
  m_cShmHdrName = f_cSharedMemName;
  m_cShmHdrName.append(SHM_HEADER_EXT);
}

////////////////////////////////////////////////////////////////////////////////////////////////
/// CNSSharedMem
/// Constructor of CNSSharedMem class
////////////////////////////////////////////////////////////////////////////////////////////////
CNSSharedMem::CNSSharedMem():
  m_cShmName(""), m_uiShmBuffSize(0), m_pShmHdr(NULL), m_pShmBuff(NULL) {
  // do nothing
}

////////////////////////////////////////////////////////////////////////////////////////////////
/// ~CNSSharedMem
/// Destructor of CNSSharedMem class
////////////////////////////////////////////////////////////////////////////////////////////////
CNSSharedMem::~CNSSharedMem() {
  if (NULL != m_pShmHdr) {
    // un-map the shared memory object
    Close();

    m_pShmHdr = NULL;
  }

  // TODO(framework_unified): currently shared memory is not being unlinked,
  // we need to find a method where we can unlink the sharedmem
  // shm_unlink(m_cShmName.c_str());
}

////////////////////////////////////////////////////////////////////////////////////////////////
/// Open
/// This function opens and maps the shared memory object.
/// It creates the shared memory if it does not exists.
////////////////////////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CNSSharedMem::Open() {
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusErrOther;

// Used only in nstest_sharedmem.
#if defined(SHM_UNITTEST_ENABLE)
  if (getenv(NSTEST_FAIL_SHAREDMEM_OPEN) != NULL) {
    return l_eStatus;
  }
#endif

  if (NULL == m_pShmHdr) {
    // Open header shared memory
    if (eFrameworkunifiedStatusOK != (l_eStatus = MapSM(reinterpret_cast<PVOID *>(&m_pShmHdr),
      m_cShmHdrName, sizeof(NSSharedBufferHdr)))) {
      if (ENOENT == errno) {  // Shared memory is not created yet
        errno = EOK;

        // Create shared memory
        if (eFrameworkunifiedStatusOK == CreateSMHeader()) {
          // Retry to open
          l_eStatus = MapSM(reinterpret_cast<PVOID *>(&m_pShmHdr), m_cShmHdrName, sizeof(NSSharedBufferHdr));
        }
      }
    } else {
      pthread_mutex_lock(&m_pShmHdr->m_tBufMutex);

      // if shared memory buffer is created with size 0, then set new size in header if any change
      if (0 == m_pShmHdr->m_uiShMemSize && 0 < m_uiShmBuffSize) {
        m_pShmHdr->m_uiShMemSize = m_uiShmBuffSize;
      } else if (0 < m_pShmHdr->m_uiShMemSize && 0 == m_uiShmBuffSize) {
        m_uiShmBuffSize = m_pShmHdr->m_uiShMemSize;
      } else {
        // do nothing
      }

      pthread_mutex_unlock(&m_pShmHdr->m_tBufMutex);
    }
  }

  if (eFrameworkunifiedStatusOK == l_eStatus && 0 != m_uiShmBuffSize) {
    if (NULL == m_pShmBuff) {
      // Open shared memory data buffer, create if not exists
      if (eFrameworkunifiedStatusOK != (l_eStatus = MapSM(reinterpret_cast<PVOID *>(&m_pShmBuff), m_cShmName, m_uiShmBuffSize))) {
        if (ENOENT == errno) {  // Shared memory is not created yet
          // Create shared memory
          if (eFrameworkunifiedStatusOK == CreateSMDataBuffer()) {
            // Retry to open
            l_eStatus = MapSM(reinterpret_cast<PVOID *>(&m_pShmBuff), m_cShmName, m_uiShmBuffSize);
          }
        }
      }
    } else {
      l_eStatus = eFrameworkunifiedStatusErrOther;
    }
  }

  return l_eStatus;
}

////////////////////////////////////////////////////////////////////////////////////////////////
/// IsOpen
/// This function is used to check whether the shared memory buffer is opened or not.
////////////////////////////////////////////////////////////////////////////////////////////////
BOOL CNSSharedMem::IsOpen() {
  return NULL == m_pShmHdr ? FALSE : TRUE;
}

////////////////////////////////////////////////////////////////////////////////////////////////
/// Close
/// This function closes the shared memory object.
////////////////////////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CNSSharedMem::Close() {
  EFrameworkunifiedStatus l_eStatus1 = UnMapSM(m_pShmHdr, sizeof(NSSharedBufferHdr));
  m_pShmHdr = NULL;

  EFrameworkunifiedStatus l_eStatus2 = eFrameworkunifiedStatusOK;
  if (0 != m_uiShmBuffSize) {
    l_eStatus2 = UnMapSM(m_pShmBuff, m_uiShmBuffSize);
    m_pShmBuff = NULL;
  }
  /*
   * todo
   * Even if an error occurs due to eFrameworkunifiedStatusNullPointer when UnMapSM fails,
   * the error type cannot be determined by the caller because it is rounded to eFrameworkunifiedStatusFail
   * if the API final determination is not OK.
   */
  return (eFrameworkunifiedStatusOK != l_eStatus1 || eFrameworkunifiedStatusOK != l_eStatus2) ? eFrameworkunifiedStatusFail : eFrameworkunifiedStatusOK;
}

////////////////////////////////////////////////////////////////////////////////////////////////
/// Read
/// This function reads data from the shared memory.
////////////////////////////////////////////////////////////////////////////////////////////////
SI_32 CNSSharedMem::Read(PSTR f_pBuffer, const UI_32 f_uilength, const BOOL f_bBlock) {
  SI_32 l_iReadSize = NS_SHM_ERROR;

  if ((NULL != f_pBuffer) && (NULL != m_pShmHdr) && (0 != f_uilength)) {
    UI_32 l_uiDataSizeToRead = 0;

    // Remaining buffer size from read pointer to end of the buffer
    UI_32 l_uiRemainSize = 0;

    if (0 == pthread_mutex_lock(&m_pShmHdr->m_tBufMutex)) {
      if ((TRUE == f_bBlock) && (0 == m_pShmHdr->m_uiUnReadSize)) {
        pthread_cond_wait(&m_pShmHdr->m_tCondVar, &m_pShmHdr->m_tBufMutex);
      }

      // if shared memory buffer size is changed by some other process, remap the updated buffer size in this process
      // shared memory buffer size can only be changed if the initial size is 0.
      if (m_uiShmBuffSize != m_pShmHdr->m_uiShMemSize) {
        if (eFrameworkunifiedStatusOK == MapSM(reinterpret_cast<PVOID *>(&m_pShmBuff), m_cShmName, m_pShmHdr->m_uiShMemSize)) {
          m_uiShmBuffSize = m_pShmHdr->m_uiShMemSize;
        }
      }

      if (NULL != m_pShmBuff) {
        l_uiRemainSize = m_uiShmBuffSize - m_pShmHdr->m_uiReadPtr;

        // Round read data size depending on un-read data size in the buffer
        l_uiDataSizeToRead = m_pShmHdr->m_uiUnReadSize < f_uilength ? m_pShmHdr->m_uiUnReadSize : f_uilength;

        if (l_uiRemainSize < l_uiDataSizeToRead) {
          // Wrapping read
          memcpy(f_pBuffer, m_pShmBuff + m_pShmHdr->m_uiReadPtr, l_uiRemainSize);
          memcpy(f_pBuffer + l_uiRemainSize, m_pShmBuff, l_uiDataSizeToRead - l_uiRemainSize);
          m_pShmHdr->m_uiReadPtr = l_uiDataSizeToRead - l_uiRemainSize;
        } else {
          memcpy(f_pBuffer, m_pShmBuff + m_pShmHdr->m_uiReadPtr, l_uiDataSizeToRead);

          m_pShmHdr->m_uiReadPtr += l_uiDataSizeToRead;

          // Read pointer is the end of the buffer
          if (m_pShmHdr->m_uiReadPtr == m_uiShmBuffSize) {
            m_pShmHdr->m_uiReadPtr = 0;
          }
        }

        m_pShmHdr->m_uiUnReadSize -= l_uiDataSizeToRead;  // Update un-read data size

        l_iReadSize = l_uiDataSizeToRead;
      }

      pthread_mutex_unlock(&m_pShmHdr->m_tBufMutex);
    }
  }

  return l_iReadSize;
}

////////////////////////////////////////////////////////////////////////////////////////////////
/// Write
/// This function writes the data into the shared memory.
////////////////////////////////////////////////////////////////////////////////////////////////
SI_32 CNSSharedMem::Write(PCSTR f_pBuffer, const UI_32 f_uilength) {
  SI_32 l_iWriteSize = NS_SHM_ERROR;

  // size available in buffer
  UI_32 l_uiRemainSize = 0;

  if (NULL != m_pShmHdr && NULL != m_pShmBuff && NULL != f_pBuffer && f_uilength <= m_uiShmBuffSize) {
    if (0 == pthread_mutex_lock(&m_pShmHdr->m_tBufMutex)) {
      l_uiRemainSize = m_uiShmBuffSize - m_pShmHdr->m_uiWritePtr;

      // Write data to the buffer
      if (l_uiRemainSize < f_uilength) {
        // Wrapping write
        memcpy(m_pShmBuff + m_pShmHdr->m_uiWritePtr, f_pBuffer, l_uiRemainSize);
        memcpy(m_pShmBuff, f_pBuffer + l_uiRemainSize, f_uilength - l_uiRemainSize);

        // Update the write pointer
        m_pShmHdr->m_uiWritePtr = f_uilength - l_uiRemainSize;

        // The buffer is full of valid data
        m_pShmHdr->m_bIsFull = TRUE;
      } else {
        memcpy(m_pShmBuff + m_pShmHdr->m_uiWritePtr, f_pBuffer, f_uilength);

        // Update the write pointer
        m_pShmHdr->m_uiWritePtr += f_uilength;

        // Write pointer is the end of the buffer
        if (m_pShmHdr->m_uiWritePtr == m_uiShmBuffSize) {
          m_pShmHdr->m_uiWritePtr = 0;

          // The buffer is full of valid data
          m_pShmHdr->m_bIsFull = TRUE;
        }
      }

      // Update un-read data size
      m_pShmHdr->m_uiUnReadSize += f_uilength;

      // Set read pointer to be same as write pointer if write pointer exceeds the read pointer
      if (m_uiShmBuffSize < m_pShmHdr->m_uiUnReadSize) {
        m_pShmHdr->m_uiReadPtr = m_pShmHdr->m_uiWritePtr;
        m_pShmHdr->m_uiUnReadSize = m_uiShmBuffSize;
      }

      pthread_cond_signal(&m_pShmHdr->m_tCondVar);

      pthread_mutex_unlock(&m_pShmHdr->m_tBufMutex);

      l_iWriteSize = f_uilength;
    }
  }

  return l_iWriteSize;
}

////////////////////////////////////////////////////////////////////////////////////////////////
/// DumpToFile
/// This function writes all the data in the buffer into provided file f_pPath.
////////////////////////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CNSSharedMem::DumpToFile(PCSTR f_pPath, PUI_32 f_uiDumpSize) {
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;

  ssize_t l_iSize = 0;

  SI_32 fd = -1;

  if (NULL == f_uiDumpSize) {
    return eFrameworkunifiedStatusNullPointer;
  }
  *f_uiDumpSize = 0;

  if (NULL != f_pPath) {
    if (NULL != m_pShmHdr) {
      // Open file
      if (-1 != (fd = open(f_pPath, O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC, S_IRWXU | S_IRWXG | S_IRWXO))) {
        if (NULL != m_pShmBuff && 0 != m_uiShmBuffSize) {
          if (0 == pthread_mutex_lock(&m_pShmHdr->m_tBufMutex)) {
            // Write buffer data to file
            if (m_pShmHdr->m_bIsFull) {
              // Buffer has full of data (read data from write pointer)
              if (-1 != (l_iSize = write(fd, m_pShmBuff + m_pShmHdr->m_uiWritePtr,
                m_uiShmBuffSize - m_pShmHdr->m_uiWritePtr))) {
                *f_uiDumpSize += static_cast<UI_32>(l_iSize);
              } else {
                l_eStatus = eFrameworkunifiedStatusErrOther;
              }
            }

            if (-1 != (l_iSize = write(fd, m_pShmBuff, m_pShmHdr->m_uiWritePtr))) {
              *f_uiDumpSize += static_cast<UI_32>(l_iSize);
            }

            if (0 != pthread_mutex_unlock(&m_pShmHdr->m_tBufMutex)) {
              l_eStatus = eFrameworkunifiedStatusSemUnlockFail;
            }
          } else {
            l_eStatus = eFrameworkunifiedStatusSemLockFail;
          }
        } else if (NULL == m_pShmBuff && 0 != m_uiShmBuffSize) {
          l_eStatus = eFrameworkunifiedStatusFail;
        } else {
          // do nothing
        }

        // Sync the file to force I/O operation completed
        fsync(fd);

        close(fd);
      } else {
        l_eStatus = eFrameworkunifiedStatusFileLoadError;
      }
    } else {
      l_eStatus = eFrameworkunifiedStatusFail;
    }
  } else {
    l_eStatus = eFrameworkunifiedStatusInvldParam;
  }

  return l_eStatus;
}

////////////////////////////////////////////////////////////////////////////////////////////////
/// GetSize
/// This function returns the number of unread bytes which can be read by Read().
////////////////////////////////////////////////////////////////////////////////////////////////
SI_32 CNSSharedMem::GetSize() {
  SI_32 l_uiReadSize = NS_SHM_ERROR;

  if (NULL != m_pShmHdr) {
    l_uiReadSize = m_pShmHdr->m_uiUnReadSize;
  }

  return l_uiReadSize;
}

////////////////////////////////////////////////////////////////////////////////////////////////
/// ClearBuf
/// This function clears the buffer.
////////////////////////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CNSSharedMem::ClearBuf() {
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;

  if (NULL != m_pShmHdr) {
    if (0 == pthread_mutex_lock(&m_pShmHdr->m_tBufMutex)) {
      // Initialize the r/w pointers
      m_pShmHdr->m_uiReadPtr = 0;
      m_pShmHdr->m_uiWritePtr = 0;
      m_pShmHdr->m_uiUnReadSize = 0;
      m_pShmHdr->m_bIsFull = FALSE;

      if (0 != pthread_mutex_unlock(&m_pShmHdr->m_tBufMutex)) {
        l_eStatus = eFrameworkunifiedStatusSemUnlockFail;
      }
    } else {
      l_eStatus = eFrameworkunifiedStatusSemLockFail;
    }
  } else {
    l_eStatus = eFrameworkunifiedStatusFail;
  }

  return l_eStatus;
}

////////////////////////////////////////////////////////////////////////////////////////////////
/// SetReadPtrToWritePtr
/// This function sets the position of read ptr to write ptr in buffer.
////////////////////////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CNSSharedMem::SetReadPtrToWritePtr() {
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;

  if (NULL != m_pShmHdr) {
    if (0 == pthread_mutex_lock(&m_pShmHdr->m_tBufMutex)) {  // LCOV_EXCL_BR_LINE 5: pthread_mutex_lock's error case
      // Initialize the r/w pointers
      m_pShmHdr->m_uiReadPtr = m_pShmHdr->m_uiWritePtr;
      m_pShmHdr->m_uiUnReadSize = 0;

      if (0 != pthread_mutex_unlock(&m_pShmHdr->m_tBufMutex)) {  // LCOV_EXCL_BR_LINE 5: pthread_mutex_unlock's error
        l_eStatus = eFrameworkunifiedStatusSemUnlockFail;
      }
    } else {
      l_eStatus = eFrameworkunifiedStatusSemLockFail;
    }
  } else {
    l_eStatus = eFrameworkunifiedStatusFail;
  }

  return l_eStatus;
}

////////////////////////////////////////////////////////////////////////////////////////////////
/// CreateSMHeader
/// This function creates the shared memory object for header.
////////////////////////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CNSSharedMem::CreateSMHeader() {
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusFail;

  // file descriptor of shared memory
  SI_32 l_siId = -1;

  // shared memory buffer headers
  NSSharedBufferHdr *l_pShmHdr = NULL;

  if ((!m_cShmHdrName.empty()) && (m_cShmHdrName.size() <= NAME_MAX)) {
    // Try to create shared memory
    l_siId = shm_open(m_cShmHdrName.c_str(), O_CREAT | O_EXCL | O_RDWR, S_IRWXU | S_IRWXG | S_IRWXO);

    if (-1 != l_siId) {
      // Set the size of shared memory
      if (-1 != ftruncate(l_siId, sizeof(NSSharedBufferHdr))) {
        // Map the shared memory
        l_pShmHdr = reinterpret_cast<NSSharedBufferHdr *>(mmap(NULL, sizeof(NSSharedBufferHdr),
          (PROT_READ | PROT_WRITE), MAP_SHARED, l_siId, 0));

        if (MAP_FAILED != l_pShmHdr) {
          // mutex attribute
          pthread_mutexattr_t l_tMtxAttr = {};
          pthread_condattr_t l_tCondAttr = {};

          // Initialize mutex
          pthread_mutexattr_init(&l_tMtxAttr);
          pthread_mutexattr_setpshared(&l_tMtxAttr, PTHREAD_PROCESS_SHARED);
          pthread_mutex_init(&l_pShmHdr->m_tBufMutex, &l_tMtxAttr);
          pthread_mutexattr_destroy(&l_tMtxAttr);

          pthread_condattr_init(&l_tCondAttr);
          pthread_condattr_setpshared(&l_tCondAttr, PTHREAD_PROCESS_SHARED);
          pthread_cond_init(&l_pShmHdr->m_tCondVar, &l_tCondAttr);
          pthread_condattr_destroy(&l_tCondAttr);

          pthread_mutex_lock(&l_pShmHdr->m_tBufMutex);

          // Initialize the r/w pointers
          l_pShmHdr->m_uiReadPtr = 0;
          l_pShmHdr->m_uiWritePtr = 0;
          l_pShmHdr->m_uiUnReadSize = 0;
          l_pShmHdr->m_bIsFull = FALSE;
          l_pShmHdr->m_uiShMemSize = m_uiShmBuffSize;

          pthread_mutex_unlock(&l_pShmHdr->m_tBufMutex);

          // Once initialized un-map the shared memory
          munmap(l_pShmHdr, sizeof(NSSharedBufferHdr));

          l_eStatus = eFrameworkunifiedStatusOK;
        }
      }

      close(l_siId);
    } else if (EEXIST == errno) {
      // Shared memory is already created
      l_eStatus = eFrameworkunifiedStatusDuplicate;
    } else {
      // do nothing
    }
  } else {
    l_eStatus = eFrameworkunifiedStatusInvldParam;
  }

  return l_eStatus;
}

////////////////////////////////////////////////////////////////////////////////////////////////
/// CreateSMDataBuffer
/// This function creates the shared memory object for data buffer.
////////////////////////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CNSSharedMem::CreateSMDataBuffer() {
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusFail;

  // file descriptor of shared memory
  SI_32 l_siId = -1;

  if ((!m_cShmName.empty()) && (m_cShmName.size() <= NAME_MAX)) {
    // Try to create shared memory
    l_siId = shm_open(m_cShmName.c_str(), O_CREAT | O_EXCL | O_RDWR, S_IRWXU | S_IRWXG | S_IRWXO);

    if (-1 != l_siId) {
      // Set the size of shared memory
      if (-1 != ftruncate(l_siId, m_uiShmBuffSize)) {
        l_eStatus = eFrameworkunifiedStatusOK;
      }

      close(l_siId);
    } else if (EEXIST == errno) {
      // Shared memory is already created
      l_eStatus = eFrameworkunifiedStatusDuplicate;
    } else {
      // do nothing
    }
  } else {
    l_eStatus = eFrameworkunifiedStatusInvldParam;
  }

  return l_eStatus;
}

////////////////////////////////////////////////////////////////////////////////////////////////
/// MapSMHeader
/// This function open and maps the shared memory header in process space.
////////////////////////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CNSSharedMem::MapSM(PVOID *f_pShMem, const std::string &f_cShmName, const UI_32 f_uiShmSize) {
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusFail;

  // file descriptor of shared memory
  SI_32 l_siId = -1;

  // shared memory buffer headers
  PVOID l_pShmBuf = NULL;

  // Open shared memory
  l_siId = shm_open(f_cShmName.c_str(), O_RDWR, 0);

  if (-1 != l_siId) {
    // Map the shared memory into its memory space
    l_pShmBuf = mmap(NULL, f_uiShmSize, (PROT_READ | PROT_WRITE), MAP_SHARED, l_siId, 0);

    if (MAP_FAILED != l_pShmBuf) {
      *f_pShMem = l_pShmBuf;
      l_eStatus = eFrameworkunifiedStatusOK;
    }

    close(l_siId);
  }

  return l_eStatus;
}

////////////////////////////////////////////////////////////////////////////////////////////////
/// UnMapSM
/// This function unmaps the shared memory object.
////////////////////////////////////////////////////////////////////////////////////////////////
EFrameworkunifiedStatus CNSSharedMem::UnMapSM(PVOID f_pShMem, const UI_32 f_uiShmSize) {
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;

  // Un-map the shared memory
  if (NULL != f_pShMem) {
    if (0 != munmap(f_pShMem, f_uiShmSize)) {
      l_eStatus = eFrameworkunifiedStatusFail;
    }
  } else {
    l_eStatus = eFrameworkunifiedStatusNullPointer;
  }

  return l_eStatus;
}