path: root/logger_service/server/src/ss_logger_cfg.cpp

/*
 * @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_SS_LoggerService
/// \brief    Provide support for CPU high load monitor configuration.
///
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
// INCLUDES
///////////////////////////////////////////////////////////////////////////////
#include "ss_logger_cfg.h"
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <dirent.h>
#include <boost/bind.hpp>
#include <native_service/nslogutil_cmd_if.h>
#include <native_service/ns_np_service_protocol.h>
#include <system_service/ss_logger_service_notifications.h>
#include <iostream>
#include <iomanip>
#include <sstream>
#include <string>
#include <algorithm>
#include <vector>

const static UI_32 cMAX_EMMC_COUNTER_VALUE = 100000u;  // NOLINT (build/storage_class)
///////////////////////////////////////////////////////////////////////////////
// CLASS METHODS
///////////////////////////////////////////////////////////////////////////////

CLoggerCfg::CLoggerCfg()
  : m_logMaxFileSize(0),
    m_performanceLogMaxFileSize(0),
    m_emmcOutputMax(0),
    m_emmcOutputErrMax(0),
    m_emmcOutputGrpRelaunchMax(0),
    m_emmcOutputNaviLogMax(0),
    m_emmcOutputNaviLogNmlMax(0),
    m_emmcOutputNaviLogErrMax(0),
    m_emmcOutputPath(""),
    m_emmcOutputNaviLogPath(""),
    m_usb0MountPath(""),
    m_usb1MountPath(""),
    m_sdMountPath(""),
    m_eDevType(eDevUSB1),
    m_UserInvokedLoggingNumber(1u),
    m_EmmcCounter(0u),
    m_eLoggerUDPLoggingStatus(eDeactivate),
    m_eLoggerStatus(SS_LOGGER_DEFAULT_VALUE) {
      m_udpEnvFlag = FALSE;
      std::memset(m_logMask, 0, sizeof(m_logMask));
      std::memset(&m_ExternalLogList, 0, sizeof(&m_ExternalLogList));
    }

CLoggerCfg::~CLoggerCfg(void) {  // LCOV_EXCL_START 14:global instance
  AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert

  if (m_ExternalLogList.p_info != NULL) {
    delete[] m_ExternalLogList.p_info;
    m_ExternalLogList.p_info = NULL;
  }
}
// LCOV_EXCL_STOP

EFrameworkunifiedStatus CLoggerCfg::Initialize(HANDLE f_hApp) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");

  char* l_udp_env = getenv("UDPLOGS_ON");
  m_udpEnvFlag = (
      l_udp_env == NULL ?
          FALSE : (strcmp("TRUE", l_udp_env) == 0 ? TRUE : FALSE));

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return eFrameworkunifiedStatusOK;
}
EFrameworkunifiedStatus CLoggerCfg::SetandPersistLoggingParams(HANDLE f_hApp,
                                                  STLoggerSetAllParams f_Params,
                                                  BOOL f_InitCall) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
  BOOL l_paramChanged = f_InitCall;
  BOOL l_updateLoggerState = f_InitCall;

  if ((TRUE == l_paramChanged)  // LCOV_EXCL_BR_LINE 200:l_paramChanged is never TRUE
      ||
      (m_eLoggerStatus != f_Params.Logger_State)
      ||  // LCOV_EXCL_BR_LINE 200:Because m_UserInvokedLoggingNumber != f_Params.Log_FolderCnt is never false
      (m_UserInvokedLoggingNumber != f_Params.Log_FolderCnt)
      || (m_eLoggerUDPLoggingStatus != f_Params.Logger_UDPState)
      || (m_eDevType != f_Params.Device_Type)) {
    l_paramChanged = TRUE;
  } else {
    l_paramChanged = FALSE;
  }

  l_updateLoggerState =
      ((l_updateLoggerState == TRUE)
          || (m_eLoggerStatus != f_Params.Logger_State)) ? TRUE : FALSE;

  // After startup Logging will be set to default value
  if (TRUE == f_InitCall) {  // LCOV_EXCL_BR_LINE 200:f_InitCall is never TRUE
    // LCOV_EXCL_START 200:f_InitCall is never TRUE
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    m_eLoggerStatus = SS_LOGGER_DEFAULT_VALUE;
    // LCOV_EXCL_STOP
  } else {
    m_eLoggerStatus = f_Params.Logger_State;
  }
  m_eLoggerUDPLoggingStatus = f_Params.Logger_UDPState;
  m_UserInvokedLoggingNumber = f_Params.Log_FolderCnt;
  m_eDevType = f_Params.Device_Type;

  if (TRUE == l_paramChanged) {
    l_eStatus = PersistLoggingParam(f_hApp);
    LOG_STATUS_IF_ERRORED(l_eStatus,  // LCOV_EXCL_BR_LINE 15: macro
                          "PersistLoggingParam()");
  }

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return (l_eStatus);
}

EFrameworkunifiedStatus CLoggerCfg::SetLoggingParams(HANDLE f_hApp,
                                        const STLoggerSetParams f_stLoggerSetParams) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
  STLoggerSetAllParams l_Params;

  l_Params.Logger_UDPState = m_eLoggerUDPLoggingStatus;
  l_Params.Log_FolderCnt = m_UserInvokedLoggingNumber;
  l_Params.Logger_State = f_stLoggerSetParams.Logger_State;
  l_Params.Device_Type = f_stLoggerSetParams.Device_Type;

  l_eStatus = SetandPersistLoggingParams(f_hApp, l_Params, FALSE);
  LOG_STATUS_IF_ERRORED(l_eStatus, "SetandPersistLoggingParams()");  // LCOV_EXCL_BR_LINE 15: macro

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return (l_eStatus);
}

EFrameworkunifiedStatus CLoggerCfg::SetUDPLogging(HANDLE f_hApp,
                                     const ELOGGER_STAT f_eUDPLoggingStatus) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
  STLoggerSetAllParams l_Params;

  l_Params.Logger_UDPState = f_eUDPLoggingStatus;
  l_Params.Log_FolderCnt = m_UserInvokedLoggingNumber;
  l_Params.Logger_State = m_eLoggerStatus;
  l_Params.Device_Type = m_eDevType;

  l_eStatus = SetandPersistLoggingParams(f_hApp, l_Params, FALSE);
  LOG_STATUS_IF_ERRORED(l_eStatus, "SetandPersistLoggingParams()");  // LCOV_EXCL_BR_LINE 15: macro

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return (l_eStatus);
}

EFrameworkunifiedStatus CLoggerCfg::PersistLoggingParam(HANDLE f_hApp) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  FRAMEWORKUNIFIEDLOG(
      ZONE_INFO, __FUNCTION__,
      "LoggerState = %d, Device_Type = %d,UDPLogging = %d, TriggerNumber = %d",
      m_eLoggerStatus, m_eDevType, m_eLoggerUDPLoggingStatus,
      m_UserInvokedLoggingNumber);  // LCOV_EXCL_BR_LINE 11:Unexpected branch

  this->UpdateLoggingStatus();
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return eFrameworkunifiedStatusOK;
}

void CLoggerCfg::RemoveCarriageReturn(std::string &f_str) {
  if (f_str.empty()) {  // LCOV_EXCL_BR_LINE 8: Because there is no empty string case
    return;
  }

  if ('\r' == f_str.at(f_str.size() - 1)) {
    f_str.erase(f_str.size() - 1, 1);
  }
}
EFrameworkunifiedStatus CLoggerCfg::Load(const std::string &f_filePathAndName) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusDbRecNotFound;

  if ("" == f_filePathAndName) {  // LCOV_EXCL_BR_LINE 200: Because there is no empty string case
    // LCOV_EXCL_START 200: Because there is no empty string case
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Invalid configuration file name detected.");
    l_eStatus = eFrameworkunifiedStatusInvldParam;
    // LCOV_EXCL_STOP
  } else {
    // FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Reading Configuration Data from %s", f_filePathAndName.c_str());

    CNSConfigReader *l_pReaderCfg = new CNSConfigReader();  // LCOV_EXCL_BR_LINE 11:except,C++ STL
    if (NULL == l_pReaderCfg) {  // LCOV_EXCL_BR_LINE 5:new error
      // LCOV_EXCL_START 5:new error
      AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
             " Error. Unable to allocate CNSConfigReader object.");
      l_eStatus = eFrameworkunifiedStatusFileLoadError;
      // LCOV_EXCL_STOP
    } else {
      if (eFrameworkunifiedStatusOK != (l_eStatus = l_pReaderCfg->Parse(f_filePathAndName))) {  // LCOV_EXCL_BR_LINE 200:To ensure success  // NOLINT[whitespace/line_length]
        // LCOV_EXCL_START 200:To ensure success
        AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
        FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
               " Error. l_pReaderCfg->Parse(%s) returned: 0x%X",
               f_filePathAndName.c_str(), l_eStatus);
        // LCOV_EXCL_STOP
      } else if (eFrameworkunifiedStatusOK != (l_eStatus = l_pReaderCfg->GetInt("LOGGING.LogMaxFileSize", m_logMaxFileSize))) {  // LCOV_EXCL_BR_LINE 200:To ensure success  // NOLINT[whitespace/line_length]
        // LCOV_EXCL_START 200:To ensure success
        AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
        LOG_STATUS(l_eStatus, "l_pReaderCfg->GetInt(LOGGING.LogMaxFileSize)");
        // LCOV_EXCL_STOP
      } else if (eFrameworkunifiedStatusOK != (l_eStatus = l_pReaderCfg->GetInt("LOGGING.PerformanceLogSize", m_performanceLogMaxFileSize))) {  // LCOV_EXCL_BR_LINE 200:To ensure success  // NOLINT[whitespace/line_length]
        // LCOV_EXCL_START 200:To ensure success
        AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
        LOG_STATUS(l_eStatus, "l_pReaderCfg->GetInt(LOGGING.LogMaxFileSize)");
        // LCOV_EXCL_STOP
      } else if (eFrameworkunifiedStatusOK != (l_eStatus = l_pReaderCfg->GetString("LOGGING.EmmcOutputPath", m_emmcOutputPath))) {  // LCOV_EXCL_BR_LINE 200:To ensure success  // NOLINT[whitespace/line_length]
        // LCOV_EXCL_START 200:To ensure success
        AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
        LOG_STATUS(l_eStatus, "l_pReaderCfg->GetString(LOGGING.EmmcOutputPath)");
        // LCOV_EXCL_STOP
      } else if (eFrameworkunifiedStatusOK != (l_eStatus = l_pReaderCfg->GetString("LOGGING.EmmcOutputNaviLogPath", m_emmcOutputNaviLogPath))) {  // LCOV_EXCL_BR_LINE 200:To ensure success  // NOLINT[whitespace/line_length]
        // LCOV_EXCL_START 200:To ensure success
        AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
        LOG_STATUS(l_eStatus,
                   "l_pReaderCfg->GetString(LOGGING.EmmcOutputNaviLogPath)");
        // LCOV_EXCL_STOP
      } else if (eFrameworkunifiedStatusOK != (l_eStatus = l_pReaderCfg->GetString("LOGGING.Usb0MountPath", m_usb0MountPath))) {  // LCOV_EXCL_BR_LINE 200:To ensure success  // NOLINT[whitespace/line_length]
        // LCOV_EXCL_START 200:To ensure success
        AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
        LOG_STATUS(l_eStatus, "l_pReaderCfg->GetString(LOGGING.Usb0MountPath)");
        // LCOV_EXCL_STOP
      } else if (eFrameworkunifiedStatusOK != (l_eStatus = l_pReaderCfg->GetString("LOGGING.Usb1MountPath", m_usb1MountPath))) {  // LCOV_EXCL_BR_LINE 200:To ensure success  // NOLINT[whitespace/line_length]
        // LCOV_EXCL_START 200:To ensure success
        AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
        LOG_STATUS(l_eStatus, "l_pReaderCfg->GetString(LOGGING.Usb1MountPath)");
        // LCOV_EXCL_STOP
      } else if (eFrameworkunifiedStatusOK != (l_eStatus = l_pReaderCfg->GetString("LOGGING.SdMountPath", m_sdMountPath))) {  // LCOV_EXCL_BR_LINE 200:To ensure success  // NOLINT[whitespace/line_length]
        // LCOV_EXCL_START 200:To ensure success
        AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
        LOG_STATUS(l_eStatus, "l_pReaderCfg->GetString(LOGGING.SdMountPath)");
        // LCOV_EXCL_STOP
      } else if (eFrameworkunifiedStatusOK != (l_eStatus = l_pReaderCfg->GetInt("LOGGING.EmmcOutputMax", m_emmcOutputMax))) {  // LCOV_EXCL_BR_LINE 200:To ensure success  // NOLINT[whitespace/line_length]
        // LCOV_EXCL_START 200:To ensure success
        AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
        LOG_STATUS(l_eStatus, "l_pReaderCfg->GetString(LOGGING.EmmcOutputMax)");
        // LCOV_EXCL_STOP
      } else if (eFrameworkunifiedStatusOK != (l_eStatus = l_pReaderCfg->GetInt("LOGGING.EmmcOutputErrMax", m_emmcOutputErrMax))) {  // LCOV_EXCL_BR_LINE 200:To ensure success  // NOLINT[whitespace/line_length]
        // LCOV_EXCL_START 200:To ensure success
        AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
        LOG_STATUS(l_eStatus,
                   "l_pReaderCfg->GetString(LOGGING.EmmcOutputErrMax)");
        // LCOV_EXCL_STOP
      } else if (eFrameworkunifiedStatusOK != (l_eStatus = l_pReaderCfg->GetInt("LOGGING.EmmcOutputGrpRelaunchMax", m_emmcOutputGrpRelaunchMax))) {  // LCOV_EXCL_BR_LINE 200:To ensure success  // NOLINT[whitespace/line_length]
        // LCOV_EXCL_START 200:To ensure success
        AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
        LOG_STATUS(l_eStatus,
                   "l_pReaderCfg->GetString(LOGGING.EmmcOutputGrpRelaunchMax)");
        // LCOV_EXCL_STOP
      } else if (eFrameworkunifiedStatusOK != (l_eStatus = l_pReaderCfg->GetInt("LOGGING.EmmcOutputNaviLogMax", m_emmcOutputNaviLogMax))) {  // LCOV_EXCL_BR_LINE 200:To ensure success  // NOLINT[whitespace/line_length]
        // LCOV_EXCL_START 200:To ensure success
        AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
        LOG_STATUS(l_eStatus,
                   "l_pReaderCfg->GetString(LOGGING.EmmcOutputNaviLogMax)");
        // LCOV_EXCL_STOP
      } else if (eFrameworkunifiedStatusOK != (l_eStatus = l_pReaderCfg->GetInt("LOGGING.EmmcOutputNaviLogNmlMax", m_emmcOutputNaviLogNmlMax))) {  // LCOV_EXCL_BR_LINE 200:To ensure success  // NOLINT[whitespace/line_length]
        // LCOV_EXCL_START 200:To ensure success
        AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
        LOG_STATUS(l_eStatus,
                   "l_pReaderCfg->GetString(LOGGING.EmmcOutputNaviLogNmlMax)");
        // LCOV_EXCL_STOP
      } else if (eFrameworkunifiedStatusOK != (l_eStatus = l_pReaderCfg->GetInt("LOGGING.EmmcOutputNaviLogErrMax", m_emmcOutputNaviLogErrMax))) {  // LCOV_EXCL_BR_LINE 200:To ensure success  // NOLINT[whitespace/line_length]
        // LCOV_EXCL_START 200:To ensure success
        AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
        LOG_STATUS(l_eStatus,
                   "l_pReaderCfg->GetString(LOGGING.EmmcOutputNaviLogErrMax)");
        // LCOV_EXCL_STOP
      } else if (eFrameworkunifiedStatusOK != (l_eStatus = l_pReaderCfg->GetString("STORAGE.ThreadName", m_loggerStorageInfo.Name))) {  // LCOV_EXCL_BR_LINE 200:To ensure success  // NOLINT[whitespace/line_length]
        // LCOV_EXCL_START 200:To ensure success
        AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
        LOG_STATUS(l_eStatus, "l_pReaderCfg->GetString(STORAGE.ThreadName)");
        // LCOV_EXCL_STOP
      } else if (eFrameworkunifiedStatusOK != (l_eStatus = l_pReaderCfg->GetInt("STORAGE.Priority", m_loggerStorageInfo.Priority))) {  // LCOV_EXCL_BR_LINE 200:To ensure success  // NOLINT[whitespace/line_length]
        // LCOV_EXCL_START 200:To ensure success
        AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
        LOG_STATUS(l_eStatus, "l_pReaderCfg->GetInt(STORAGE.Priority)");
        // LCOV_EXCL_STOP
      } else if (eFrameworkunifiedStatusOK != (l_eStatus = l_pReaderCfg->GetInt("STORAGE.Timeout", m_loggerStorageInfo.Timeout))) {  // LCOV_EXCL_BR_LINE 200:To ensure success  // NOLINT[whitespace/line_length]
        // LCOV_EXCL_START 200:To ensure success
        AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
        LOG_STATUS(l_eStatus, "l_pReaderCfg->GetInt(STORAGE.Timeout)");
        // LCOV_EXCL_STOP
      } else if (eFrameworkunifiedStatusOK != (l_eStatus = l_pReaderCfg->GetInt("STORAGE.TimeoutAfter", m_loggerStorageInfo.TimeoutAfter))) {  // LCOV_EXCL_BR_LINE 200:To ensure success  // NOLINT[whitespace/line_length]
        // LCOV_EXCL_START 200:To ensure success
        AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
        LOG_STATUS(l_eStatus, "l_pReaderCfg->GetInt(STORAGE.TimeoutAfter)");
        // LCOV_EXCL_STOP
      } else if (eFrameworkunifiedStatusOK != (l_eStatus = l_pReaderCfg->GetInt("LOGGING.ExternalLogNum", m_ExternalLogList.num))) {  // LCOV_EXCL_BR_LINE 200:To ensure success  // NOLINT[whitespace/line_length]
        LOG_STATUS(l_eStatus, "l_pReaderCfg->GetString(LOGGING.ExternalLogNum)");  // LCOV_EXCL_LINE 200:To ensure success  // NOLINT[whitespace/line_length]
      } else if (eFrameworkunifiedStatusOK != (l_eStatus = l_pReaderCfg->GetInt("LOGGING.ExternalLogMax", m_ExternalLogList.max))) {  // LCOV_EXCL_BR_LINE 200:To ensure success  // NOLINT[whitespace/line_length]
        LOG_STATUS(l_eStatus, "l_pReaderCfg->GetString(LOGGING.ExternalLogMax)");  // LCOV_EXCL_LINE 200:To ensure success  // NOLINT[whitespace/line_length]
      } else {
        RemoveCarriageReturn(m_emmcOutputPath);
        RemoveCarriageReturn(m_emmcOutputNaviLogPath);
        RemoveCarriageReturn(m_usb0MountPath);
        RemoveCarriageReturn(m_usb1MountPath);
        RemoveCarriageReturn(m_sdMountPath);
        RemoveCarriageReturn(m_loggerStorageInfo.Name);

        for (UI_32 i = 0; i < ZONE_MASK_ARRAY_ELTS; i++) {
          SI_32 l_logMaskTemp;
          std::stringstream l_cfgParamName;

          l_cfgParamName << "SETLOGMASK.MASK" << i;
          if (eFrameworkunifiedStatusOK != (l_eStatus = l_pReaderCfg->GetInt(l_cfgParamName.str(), l_logMaskTemp))) {  // LCOV_EXCL_BR_LINE 200:To ensure success  // NOLINT[whitespace/line_length]
            // LCOV_EXCL_START 200:To ensure success
            AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
            FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
                   " Error. l_pReaderCfg->GetInt(%s) failed with error: %d.",
                   l_cfgParamName.str().c_str(), l_eStatus);

            break;
            // LCOV_EXCL_STOP
          } else {
            m_logMask[i] = (UI_32) l_logMaskTemp;
          }
        }

        m_EELStorageRelPath = "/EEL_export";
        m_EELActivateRelPath = "/EEL_activate";
        m_LoggerserviceEmmcLogsRelPath = "/LOGGERSERVICE_EMMC_LOGS";

        if (m_ExternalLogList.num > 0) {
          std::string str = "EXTERNAL_";  // LCOV_EXCL_BR_LINE 11:Excluded due to gcov constraints (others)
          UI_32 num = 0;

          if (m_ExternalLogList.num <= m_ExternalLogList.max) {
            num = m_ExternalLogList.num;
          } else {
            num = m_ExternalLogList.max;
          }

          // LCOV_EXCL_BR_START 11:Excluded due to gcov constraints (others)
          m_ExternalLogList.p_info = new ExternalLogInfo[num];

          // Load external log info
          for (UI_32 i = 0; i < num; i++) {
            std::string query = str + std::to_string(i+1);
            if (eFrameworkunifiedStatusOK !=
                (l_eStatus = l_pReaderCfg->GetString((query+".OutputPath"), m_ExternalLogList.p_info[i].dirname))) {
              LOG_STATUS(l_eStatus, "l_pReaderCfg->GetString(EXTERNAL.OutputPath)");  // LCOV_EXCL_LINE 200:To ensure success  // NOLINT[whitespace/line_length]
            } else if (eFrameworkunifiedStatusOK !=
                (l_eStatus = l_pReaderCfg->GetString((query+".ExtLogPath"), m_ExternalLogList.p_info[i].path))) {
              LOG_STATUS(l_eStatus, "l_pReaderCfg->GetString(EXTERNAL.ExtLogPath)");  // LCOV_EXCL_LINE 200:To ensure success  // NOLINT[whitespace/line_length]
            } else if (eFrameworkunifiedStatusOK !=
                (l_eStatus = l_pReaderCfg->GetBool((query+".Remove"), m_ExternalLogList.p_info[i].remove))) {
              LOG_STATUS(l_eStatus, "l_pReaderCfg->GetBool(EXTERNAL.Remove)");  // LCOV_EXCL_LINE 200:To ensure success  // NOLINT[whitespace/line_length]
            } else {
              RemoveCarriageReturn(m_ExternalLogList.p_info[i].dirname);
              RemoveCarriageReturn(m_ExternalLogList.p_info[i].path);
            }
          }
          // LCOV_EXCL_BR_STOP 11:Excluded due to gcov constraints (others)
        } else {
          // None external log
        }

        if (eFrameworkunifiedStatusOK == l_eStatus) {  // LCOV_EXCL_BR_LINE 200:To ensure success
          FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__,
                 " Info. Configuration successfully loaded.");  // LCOV_EXCL_BR_LINE 15: macro
        }
      }

      delete l_pReaderCfg;  // LCOV_EXCL_BR_LINE 11:Unexpected branch
    }
  }

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return (l_eStatus);
}

EFrameworkunifiedStatus CLoggerCfg::Validate(void) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusInvldParam;

  if (m_logMaxFileSize == 0) {  // LCOV_EXCL_BR_LINE 200:Because the size is never 0
    // LCOV_EXCL_START 200:Because the size is never 0
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    FRAMEWORKUNIFIEDLOG(
        ZONE_ERR,
        __FUNCTION__,
        " Error. Invalid configuration detected. LogMaxFileSize: %d Must be > 0.",
        m_logMaxFileSize);
    // LCOV_EXCL_STOP
  } else if (m_emmcOutputPath == "") {
    FRAMEWORKUNIFIEDLOG(
        ZONE_ERR,
        __FUNCTION__,
        " Error. Invalid configuration detected."
        " EmmcOutputPath: %s Must be a valid path containing a trailing backslash.",
        m_emmcOutputPath.c_str());
  } else if (m_emmcOutputNaviLogPath == "") {  // LCOV_EXCL_BR_LINE 200:Because it is not always an empty string
    // LCOV_EXCL_START 200:Because it is not always an empty string
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    FRAMEWORKUNIFIEDLOG(
        ZONE_ERR,
        __FUNCTION__,
        " Error. Invalid configuration detected."
        " EmmcOutputNaviLogPath: %s Must be a valid path containing a trailing backslash.",
        m_emmcOutputNaviLogPath.c_str());
    // LCOV_EXCL_STOP
  } else if (m_usb0MountPath == "") {  // LCOV_EXCL_BR_LINE 200:Because it is not always an empty string
    // LCOV_EXCL_START 200:Because it is not always an empty string
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    FRAMEWORKUNIFIEDLOG(
        ZONE_ERR,
        __FUNCTION__,
        " Error. Invalid configuration detected."
        " Usb0MountPath: %s Must be a valid path containing a trailing backslash.",
        m_usb0MountPath.c_str());
    // LCOV_EXCL_STOP
  } else if (m_usb1MountPath == "") {  // LCOV_EXCL_BR_LINE 200:Because it is not always an empty string
    // LCOV_EXCL_START 200:Because it is not always an empty string
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    FRAMEWORKUNIFIEDLOG(
        ZONE_ERR,
        __FUNCTION__,
        " Error. Invalid configuration detected."
        " Usb1MountPath: %s Must be a valid path containing a trailing backslash.",
        m_usb1MountPath.c_str());
    // LCOV_EXCL_STOP
  } else if (m_sdMountPath == "") {  // LCOV_EXCL_BR_LINE 200:Because it is not always an empty string
    // LCOV_EXCL_START 200:Because it is not always an empty string
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    FRAMEWORKUNIFIEDLOG(
        ZONE_ERR,
        __FUNCTION__,
        " Error. Invalid configuration detected. SdMountPath: %s Must be a valid path containing a trailing backslash.",
        m_sdMountPath.c_str());
    // LCOV_EXCL_STOP
  } else {
    l_eStatus = eFrameworkunifiedStatusOK;
  }

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return (l_eStatus);
}

void CLoggerCfg::Print(void) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
}

std::string CLoggerCfg::getEmmcOutputPath(void) {
  return (m_emmcOutputPath);
}

std::string CLoggerCfg::getEmmcOutputNaviLogPath(void) {
  return (m_emmcOutputNaviLogPath);
}

std::string CLoggerCfg::getUsb0MountPath(void) {
  return (m_usb0MountPath);
}
void CLoggerCfg::setUsb0MountPath(std::string& f_deviceMountpath) {
  m_usb0MountPath = f_deviceMountpath;
}

EFrameworkunifiedStatus CLoggerCfg::GetUserInvokedDestination(std::string& f_dest) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;

  f_dest = "";
  switch (m_eDevType) {
    case eDevUSB1:
      f_dest = m_usb0MountPath;
      break;

    case eDevUSB2:
      f_dest = m_usb1MountPath;
      break;

    case eDevSD:
      f_dest = m_sdMountPath;
      break;

    case eTotalDevicesTypes:
    case eInvalid_DevType:
    default:
      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error. Unknown device type: %d",
             m_eDevType);
      l_eStatus = eFrameworkunifiedStatusFail;
      break;
  }

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return (l_eStatus);
}

EFrameworkunifiedStatus CLoggerCfg::GetEmmcDestination(std::string& f_dest) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;

  f_dest = m_emmcOutputPath;

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return (l_eStatus);
}

EFrameworkunifiedStatus CLoggerCfg::GetEmmcNaviLogDestination(std::string& f_dest) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;

  f_dest = m_emmcOutputNaviLogPath;

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return (l_eStatus);
}

UI_32 CLoggerCfg::GetUserInvokedCounter(void) {
  return m_UserInvokedLoggingNumber;
}

EFrameworkunifiedStatus CLoggerCfg::GetIncrementAndPersistUserInvokedCounter(
    HANDLE f_hApp, UI_32 &f_counter) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;

  f_counter = m_UserInvokedLoggingNumber;
  m_UserInvokedLoggingNumber++;
  l_eStatus = PersistLoggingParam(f_hApp);

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return (l_eStatus);
}

EFrameworkunifiedStatus CLoggerCfg::GetAndIncrementEmmcCounter(UI_32 &f_counter) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
  std::string l_checkFileName;
  std::vector<UI_32> l_vector;
  DIR *l_dirp;
  struct dirent l_dirent;
  struct dirent* next = NULL;
  size_t l_pos;
  UI_32 l_count;
  UI_32 l_maxCount;

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");

  if (m_EmmcCounter == 0u) {
    l_maxCount = 0;
    l_dirp = opendir(m_emmcOutputPath.c_str());
    if (l_dirp != NULL) {  // LCOV_EXCL_BR_LINE 5: m_emmcOutputPath is not null, opendir is C code, always ok
      for (;;) {
        int l_ret = readdir_r(l_dirp, &l_dirent, &next);
        if (((l_ret == 0) && (next == NULL))
            || (l_ret > 0)) {
          break;
        }
        l_checkFileName = l_dirent.d_name;
        l_pos = l_checkFileName.find(".tar.gz");
        if (std::string::npos != l_pos) {
          l_pos = l_checkFileName.find("_");
          if (std::string::npos != l_pos) {  // LCOV_EXCL_BR_LINE 200: tar.gz file is aways has "_"
            std::string l_numberString = l_checkFileName.substr(0, l_pos);
            l_count = static_cast<UI_32>(strtoul(l_numberString.c_str(), NULL, 10));
            l_vector.push_back(l_count);
            l_maxCount = std::max(l_count, l_maxCount);
          }
        }
      }
      closedir(l_dirp);
    } else {
      // LCOV_EXCL_START 5: m_emmcOutputPath is not null, opendir is C code, always ok
      AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
      f_counter = 1;
      return eFrameworkunifiedStatusOK;
      // LCOV_EXCL_STOP
    }

    // reach at max number
    if (l_maxCount >= LOGGERSERVICELOG_EMMC_COUNTER_MAX) {
      RefreshEmmcCounter(m_EmmcCounter);
    } else {
      m_EmmcCounter = l_maxCount + 1;
    }
  } else if (m_EmmcCounter >= LOGGERSERVICELOG_EMMC_COUNTER_MAX) {
    // reach at max number
    RefreshEmmcCounter(m_EmmcCounter);
  } else {
    m_EmmcCounter++;
  }

  f_counter = m_EmmcCounter;
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return (l_eStatus);
}

EFrameworkunifiedStatus CLoggerCfg::RefreshEmmcCounter(UI_32& f_counter) const {
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
  std::string l_checkFileName;
  std::vector<std::string> l_vector;
  DIR *l_dirp;
  struct dirent l_dirent;
  struct dirent* next = NULL;
  size_t l_pos;

  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");

  // get filename saved frameworkunifiedlog on eMMC Device
  l_dirp = opendir(m_emmcOutputPath.c_str());
  if (l_dirp != NULL) {  // LCOV_EXCL_BR_LINE 5: m_emmcOutputPath is not null, opendir is C code, always ok
    for (;;) {
      int l_ret = readdir_r(l_dirp, &l_dirent, &next);
      if (((l_ret == 0) && (next == NULL)) || (l_ret > 0)) {
        break;
      }
      l_checkFileName = l_dirent.d_name;
      l_pos = l_checkFileName.find(".tar.gz");
      if (std::string::npos != l_pos) {
        l_pos = l_checkFileName.find("_");
        if (std::string::npos != l_pos) {
          l_vector.push_back(l_checkFileName);
        }
      }
    }
    closedir(l_dirp);
  } else {
    // LCOV_EXCL_START 5: m_emmcOutputPath is not null, opendir is C code, always ok
      AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    // ignore opendir failure. this means saved frameworkunifiedlog is nothing on eMMC Device
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "open dir error path=%s errno=%s.",
           m_emmcOutputPath.c_str(), strerror(errno));
    f_counter = 1;
    return eFrameworkunifiedStatusOK;
    // LCOV_EXCL_STOP
  }

  // sort at log count
  std::sort(l_vector.begin(), l_vector.end());

  std::vector<std::string>::iterator it;
  std::string l_orgFilePath;
  std::string l_renameFilePath;
  UI_32 l_wpt = 0;
  UI_32 l_count;

  it = l_vector.begin();
  while (it != l_vector.end()) {
    std::stringstream l_nameStream;
    // get log counter parts
    l_wpt++;
    l_checkFileName = *it;
    l_pos = l_checkFileName.find("_");
    std::string l_numberString = l_checkFileName.substr(0, l_pos);
    l_count = static_cast<UI_32>(strtoul(l_numberString.c_str(), NULL, 10));

    // rename file if necessary
    if (l_count != l_wpt) {
      l_renameFilePath = l_orgFilePath = m_emmcOutputPath.c_str();
      l_renameFilePath.append("/");
      l_orgFilePath.append("/");
      l_orgFilePath.append(l_checkFileName);

      l_nameStream << std::setw(5) << std::setfill('0') << std::right
                   << std::dec << l_wpt;
      l_checkFileName.replace(0, l_pos, l_nameStream.str());

      l_renameFilePath.append(l_checkFileName);

      if (rename(l_orgFilePath.c_str(), l_renameFilePath.c_str()) != 0) {  // LCOV_EXCL_BR_LINE 5: rename is C code
        // LCOV_EXCL_START 5: rename is C code
        AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
        // rename failed but continue reamin log rename because new log need to be saved.
        FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
               "log file[%s]->[%s] rename failed: err=%s.",
               l_orgFilePath.c_str(), l_renameFilePath.c_str(), strerror(errno));
        // LCOV_EXCL_STOP
      }
    }
    it++;
  }

  f_counter = l_wpt + 1;

  // set return value as next log counter
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return l_eStatus;
}

BOOL CLoggerCfg::IsUDPLoggingEnabled(void) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  BOOL l_ret =
      ((this->m_eLoggerUDPLoggingStatus == eActivate)
          || (this->m_udpEnvFlag == TRUE)) ? TRUE : FALSE;
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "- : %s", (TRUE == l_ret)?"TRUE":"FALSE");
  return (l_ret);
}

void CLoggerCfg::AddLoggingParamCB(CbFuncPtr f_fp) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  if (f_fp != NULL) {  // LCOV_EXCL_BR_LINE 6: it aways not be null
    this->m_LoggingCallBack.push_back(f_fp);
    (void) f_fp(NULL);
  }
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
}

void CLoggerCfg::UpdateLoggingStatus(void) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  std::vector<CbFuncPtr>::iterator l_iter;
  for (l_iter = m_LoggingCallBack.begin(); l_iter != m_LoggingCallBack.end(); l_iter++) {  // LCOV_EXCL_BR_LINE 11:Unexpected branch  // NOLINT[whitespace/line_length]
    (void) (*l_iter)(NULL);
  }
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
}

EFrameworkunifiedStatus CLoggerCfg::GetLoggerStorageInfo(SLoggerStorageInfo &f_info) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
  f_info = m_loggerStorageInfo;
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
  return (l_eStatus);
}

BOOL CLoggerCfg::IsLoggingEnabled(void) {
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
  return (this->m_eLoggerStatus == eActivate) ? TRUE : FALSE;
  FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
}

ExternalLogList CLoggerCfg::GetExternalLogList(void) {
  return (m_ExternalLogList);
}  // LCOV_EXCL_BR_LINE 10:the last line