--- /dev/null
+/*
+ * @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_SystemServices_Logger
+/// \brief This file supports the logger service interface for SystemManager.
+///
+///////////////////////////////////////////////////////////////////////////////
+#include "system_service/ss_logger_store_logs.h"
+#include <stdio.h>
+#include <string.h>
+#include <fcntl.h>
+#include <dirent.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <errno.h>
+#include <libtar_listhash.h>
+#include <libtar.h>
+#include <zlib.h>
+#include <sys/klog.h>
+
+#include <stdlib.h>
+#include <native_service/frameworkunified_application.h>
+#include <native_service/frameworkunified_types.h>
+#include <native_service/frameworkunified_framework_types.h>
+#include <native_service/frameworkunified_framework_if.h>
+#include <system_service/ss_system_types.h>
+#include <native_service/ns_ringbuffer.h>
+#include <native_service/ns_logger_if.h>
+#include <native_service/ns_config_parser_if.h>
+#include <native_service/cl_lockid.h>
+#include <stub/Clock_API.h>
+#include <vector>
+#include <sstream>
+#include <iomanip>
+#include <string>
+#include <algorithm>
+#include "ss_logger_store_logs_loggerservicelog.h"
+#include "ss_logger_cfg.h"
+
+#define LOGGERSERVICELOG_CONFIG_PATH "/usr/agl/conf/BS/ss/logger_service/rodata/ss_logger.cfg"
+#define LOGGER_TMP_FN "__LOGGER.tmp"
+#define LOGGERSERVICELOG_TMP_OUTPUT_PATH "/tmp"
+#define PSTORE_DIR_PATH "/dev/pstore"
+#define KERNEL_BOOT_LOG_FN "kernelboot.log"
+#define KERNEL_LOG_FN "kernel.log"
+#define COMMUNICATION_DIR_NAME "communication"
+#define ACCOFFON_DIR_NAME "accoffon"
+
+#define PATHNAME_SEPARATOR '/'
+#define PATHNAME_SEPARATOR_STR "/"
+#define SS_STORE_FILENAME_SYSILG_TERM "_SYS_ILG_RESET.tar.gz"
+#define SS_STORE_FILENAME__CWORD52__TERM "__CWORD52_.log"
+#define LOGARCHIVE_FILENAME_STORE_ARCHIVE "/tmp/ss_logger_ilgfilenum"
+#define TMPFILE_MODE 0640
+#define SSLOGGER_PATHNAME (255 + 1)
+#define FILENUMBER_UPPER_LIMIT_OVER 100000u
+#define FILENUMBER_LOWER_LIMIT 1u
+#define FILENUMBER_DIGIT_NUM 5
+#define INVALID_FILENUMBER (FILENUMBER_UPPER_LIMIT_OVER)
+
+
+/* Read all messages remaining in the ring buffer. (allowed for non-root) */
+#define SYSLOG_ACTION_READ_ALL 3
+/* Return size of the log buffer */
+#define SYSLOG_ACTION_SIZE_BUFFER 10
+
+#define ENABLE_DEBUG_LOG 0
+#if ENABLE_DEBUG_LOG
+#define DEB_LOGGERSERVICELOG(zone,funcname,print_fmt, ...) if(zone!=ZONE_FUNC) \
+fprintf(stderr,"%d/%s/%d:="print_fmt"\n", zone, funcname, __LINE__,##__VA_ARGS__)
+#else
+#define DEB_LOGGERSERVICELOG(zone,funcname,print_fmt, ...)
+#endif
+
+typedef struct {
+ std::string output_path;
+ SI_32 output_max;
+ SI_32 output_errmax;
+ SI_32 external_log_num;
+ SI_32 external_log_max;
+} CfgInfo;
+
+typedef struct {
+ std::string file_path;
+ std::string dest_name;
+ BOOL tmp_file_delete;
+} LogInfo;
+
+typedef struct {
+ std::string path;
+ int index;
+} LoggerservicelogInfo;
+
+
+static const char* sys_illegal_log[] = {
+ "frameworkunified_sys.log",
+ };
+
+
+typedef enum {
+ SS_STORELOGS_KERNEL_LOG = 0,
+ SS_STORELOGS_KERNEL_BOOT_LOG
+} SS_STORELOGS_KERNEL_LOG_TYPE;
+
+typedef void (*GetLogFileFunc)(SS_STORELOGS_OPE_TYPE type,
+ std::vector<LogInfo>& list); // NOLINT (runtime/references)
+
+static const UI_8 MAX_DIRECTORY_DEPTH = 4;
+static const UI_32 TARMODE = 0644;
+
+static EFrameworkunifiedStatus addToArchive(TAR* f_pTarInfo, std::string f_filePathAndName,
+ std::string f_destinationName, UI_8 f_depth =
+ MAX_DIRECTORY_DEPTH);
+static EFrameworkunifiedStatus addDirectoryToArchive(TAR* f_pTarInfo, std::string f_path,
+ std::string f_destinationName,
+ UI_8 f_depth = MAX_DIRECTORY_DEPTH);
+static SI_32 gzOpenArchive(PCHAR f_pcPathname, SI_32 f_siOflags,
+ SI_32 f_siMode);
+static SI_32 gzCloseArchive();
+static ssize_t gzWriteArchive(int fd, const void* buf, size_t count);
+static ssize_t gzReadArchive(int fd, void* buf, size_t count);
+static EFrameworkunifiedStatus addFileToArchive(TAR* f_pTarInfo, std::string f_filename,
+ std::string f_destinationName);
+static EFrameworkunifiedStatus addAllFileToArchive (TAR* f_pTarInfo, std::string collectDir);
+static EFrameworkunifiedStatus copyFile(std::string f_source, std::string f_destination);
+static EFrameworkunifiedStatus copyDirectory (std::string f_source, std::string f_destination);
+static EFrameworkunifiedStatus copyUntyped (std::string f_source, std::string f_destination);
+static EFrameworkunifiedStatus copyFileToAccOffOnDir(std::vector<LogInfo>& list, SS_STORELOGS_OPE_TYPE type);
+static void getLoggerservicelogFile(SS_STORELOGS_OPE_TYPE type,
+ std::vector<LogInfo>& list, // NOLINT (runtime/references)
+ std::vector<LoggerservicelogInfo> &loggerservicelogList); // NOLINT (runtime/references)
+static void getKernellogFile(SS_STORELOGS_OPE_TYPE type,
+ std::vector<LogInfo>& list); // NOLINT (runtime/references)
+static void getLastKernelLog(std::vector<LogInfo>& list); // NOLINT (runtime/references)
+static void getKernelLog(std::vector<LogInfo>& list); // NOLINT (runtime/references)
+static void getKernelBootLog(SS_STORELOGS_OPE_TYPE type,
+ std::vector<LogInfo>& list); // NOLINT (runtime/references)
+static void getCommunicationlogFile(SS_STORELOGS_OPE_TYPE type,
+ std::vector<LogInfo>& list); // NOLINT (runtime/references)
+static void getExternallogFile(SS_STORELOGS_OPE_TYPE type,
+ std::vector<LogInfo>& list); // NOLINT (runtime/references)
+
+//static std::string getFileName(std::string &path, uint32_t f_time, // NOLINT (runtime/references)
+// SS_STORELOGS_OPE_TYPE type);
+static std::string getFileName(std::string &path, uint32_t f_time, // NOLINT (runtime/references)
+ SS_STORELOGS_OPE_TYPE type, UI_32 l_counter);
+
+static void getEmmcCounter(std::string &path, UI_32& f_counter); // NOLINT (runtime/references)
+static void getConfigInfo(CfgInfo& f_cfginfo); // NOLINT (runtime/references)
+static EFrameworkunifiedStatus deleteOldEmmcLog(CfgInfo& f_cfginfo, // NOLINT (runtime/references)
+ std::string& f_archive_destination, // NOLINT (runtime/references)
+ SS_STORELOGS_OPE_TYPE type);
+static EFrameworkunifiedStatus storeLogs(SS_STORELOGS_OPE_TYPE type);
+static EFrameworkunifiedStatus deleteOldLog(std::string log_path,
+ std::vector<std::string>& l_vector, // NOLINT (runtime/references)
+ std::string& f_archive_destination, // NOLINT (runtime/references)
+ UI_32 max_num);
+static size_t deleteRequestLogs(std::string f_emmcpath, ELOGGERSERVICELOGTYPE f_reqtype,
+ size_t f_reqsize, ELOGGERSERVICELOGTYPE f_deltype);
+static EFrameworkunifiedStatus forceDeleteOldLog(std::string f_archive_destination,
+ size_t f_req_size);
+static ELOGGERSERVICELOGTYPE QueryLoggerservicelogType(std::string f_logname);
+static void SyncDir(std::string f_dir_path);
+static BOOL RemoveSubDirectory(std::string &f_cPath); // NOLINT (runtime/references)
+static void CreateSaveFinFlag(SS_STORELOGS_OPE_TYPE type);
+static void ClearLoggerservicelogBuffer(std::vector<LoggerservicelogInfo> &loggerservicelogList); // NOLINT (runtime/references)
+static void copyLoggerservicelogFile(std::string distPath);
+static void deleteTmpAccOffOn(std::string accOffOnDir);
+static void deleteAccOffOnDir(std::string deletePath);
+static void deleteAccOffOnUntyped(std::string deletePath);
+
+static EFrameworkunifiedStatus getFileNumber(const std::string &filename,UI_32 &number);
+static bool compareFileNumber(UI_32 filename1_number,const std::string &filename2);
+static EFrameworkunifiedStatus removeFiles(const std::string &log_path, std::vector<std::string> &l_vector,
+ size_t begin_pos, size_t end_pos);
+static EFrameworkunifiedStatus removeSameNumFiles(std::vector<std::string>::iterator &itr, const std::string &log_path,
+ std::vector<std::string> &l_vector);
+static EFrameworkunifiedStatus deleteOldLogAbnrm(const std::string& log_path, std::vector<std::string>& l_vector,
+ const std::string& f_archive_destination, SI_32 max_num, UI_32 abnrm_total);
+static EFrameworkunifiedStatus storeTempArchive(const std::string &real_name);
+static EFrameworkunifiedStatus getFileNumberFromTempArchive(UI_32 &filenumber);
+
+
+static std::string m_pathAndName; // NOLINT (runtime/string)
+static std::string m_tmpName; // NOLINT (runtime/string)
+
+const GetLogFileFunc GetLogFuncTbl[] = { getKernellogFile,
+ getCommunicationlogFile,
+ getExternallogFile
+ };
+// GZF save variables
+static gzFile g_gztype;
+
+// ->Bus-Error avoidance
+static tartype_t l_gztype;
+
+static EFrameworkunifiedStatus openArchive(TAR** f_pTarInfo, std::string f_pathAndName) {
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+ EFrameworkunifiedStatus l_eFrameworkunifiedStatus = eFrameworkunifiedStatusOK;
+
+// ->Bus-Error avoidance (because of local variables, content becomes indeterminate when functions exit)
+// tartype_t l_gztype;
+
+ *f_pTarInfo = NULL;
+ g_gztype = NULL;
+ l_gztype.openfunc = (openfunc_t) &gzOpenArchive;
+ l_gztype.closefunc = (closefunc_t) &gzCloseArchive;
+ l_gztype.readfunc = (readfunc_t) &gzReadArchive;
+ l_gztype.writefunc = (writefunc_t) &gzWriteArchive;
+
+ m_pathAndName = f_pathAndName;
+
+ /* check if directory exists */
+ size_t l_found = f_pathAndName.find_last_of('/');
+ std::string l_path = f_pathAndName.substr(0, l_found);
+
+ if (0 != access(l_path.c_str(), F_OK)) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Directory does not exist. Creating...");
+ return eFrameworkunifiedStatusFail;
+ }
+
+ /* create archive in tmp */
+ m_tmpName = "/tmp/log.tar.gz";
+
+ int l_tarRetVal = tar_open(f_pTarInfo, const_cast<char*>(m_tmpName.c_str()), &l_gztype,
+ O_WRONLY | O_CREAT, TARMODE, TAR_GNU);
+
+ if ((l_tarRetVal != 0) || (*f_pTarInfo == NULL) || g_gztype == NULL) { // LCOV_EXCL_BR_LINE 6: tar_open must return ok // NOLINT[whitespace/line_length]
+ // LCOV_EXCL_START 6: tar_open must return ok
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Could not open TAR-Archive!");
+ l_eFrameworkunifiedStatus = eFrameworkunifiedStatusAccessError;
+ // LCOV_EXCL_STOP
+ }
+
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return (l_eFrameworkunifiedStatus);
+}
+
+static EFrameworkunifiedStatus addToArchive(TAR* f_pTarInfo, std::string f_filePathAndName,
+ std::string f_destinationName, UI_8 f_depth) {
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+ EFrameworkunifiedStatus l_eFrameworkunifiedStatus = eFrameworkunifiedStatusFileLoadError;
+ struct stat l_stat;
+ int l_statRetVal;
+
+ if (0 != access(f_filePathAndName.c_str(), F_OK)) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ " Error. The specified file path and name does not exist: %s",
+ f_filePathAndName.c_str());
+ } else if (0 != (l_statRetVal = stat(f_filePathAndName.c_str(), &l_stat))) { // LCOV_EXCL_BR_LINE 5: stat's error case // NOLINT[whitespace/line_length]
+ // LCOV_EXCL_START 5: stat's error case
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ " Error. stat() for file or directory returned error: %s -> %d",
+ f_filePathAndName.c_str(), l_statRetVal);
+ // LCOV_EXCL_STOP
+ } else if (0 != S_ISDIR(l_stat.st_mode)) {
+ if (0 < f_depth) { // LCOV_EXCL_BR_LINE 6: f_depth must be greater than 0
+ l_eFrameworkunifiedStatus = addDirectoryToArchive(f_pTarInfo, f_filePathAndName,
+ f_destinationName, f_depth);
+ } else {
+ // LCOV_EXCL_START 6: f_depth must be greater than 0
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__,
+ "Maximum recursive depth reached! File %s not added to archive.",
+ f_filePathAndName.c_str());
+ // LCOV_EXCL_STOP
+ }
+ } else if (0 != S_ISREG(l_stat.st_mode)) {
+ char path[PATH_MAX];
+ if (realpath(f_filePathAndName.c_str(), path) != NULL) {
+ f_filePathAndName = path;
+ l_eFrameworkunifiedStatus = addFileToArchive(f_pTarInfo, f_filePathAndName,
+ f_destinationName);
+ } else {
+ FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__,
+ "Archive not opened or could not access file: \"%s\"",
+ f_filePathAndName.c_str());
+ }
+ } else {
+ FRAMEWORKUNIFIEDLOG(
+ ZONE_ERR,
+ __FUNCTION__,
+ " Error. specified file may be a symbolic link or other non 'regular' type. File: %s, mode: 0x%04X.",
+ f_filePathAndName.c_str(), l_stat.st_mode);
+ }
+
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return (l_eFrameworkunifiedStatus);
+}
+
+
+static EFrameworkunifiedStatus getFileNumberFromTempArchive(UI_32 &filenumber)
+{
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+ char buf[FILENUMBER_DIGIT_NUM + 1];
+ int fd;
+ int result;
+ EFrameworkunifiedStatus l_eFrameworkunifiedStatus = eFrameworkunifiedStatusOK;
+
+ fd = open(LOGARCHIVE_FILENAME_STORE_ARCHIVE, O_RDONLY);
+ if (fd == -1) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR,__FUNCTION__," Error. open(). path = %s ,errno = %d", LOGARCHIVE_FILENAME_STORE_ARCHIVE, errno);
+ return eFrameworkunifiedStatusAccessError;
+ }
+
+ result = read(fd, buf, FILENUMBER_DIGIT_NUM);
+ if (result != FILENUMBER_DIGIT_NUM) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR,__FUNCTION__," Error. read(). path = %s ,result = %d, errno = %d",
+ LOGARCHIVE_FILENAME_STORE_ARCHIVE, result, errno);
+ l_eFrameworkunifiedStatus = eFrameworkunifiedStatusAccessError;
+ } else {
+ char *endptr;
+ int error_number;
+ int temp_value;
+ buf[FILENUMBER_DIGIT_NUM] = '\x0';
+ errno = EOK;
+ temp_value = strtol(buf, &endptr, 10);
+ error_number = errno;
+ if ((error_number != EOK) || (*endptr != '\x0')) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR,__FUNCTION__," Error. Failed to comvert string. source = %s ,errno = %d", buf, errno);
+ l_eFrameworkunifiedStatus = eFrameworkunifiedStatusInvldParam;
+ } else {
+ filenumber = temp_value;
+ }
+ }
+ result = close(fd);
+ if (result != 0) { // LCOV_EXCL_BR_LINE 6: close() must return ok
+ // LCOV_EXCL_START 6: close() must return ok
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR,__FUNCTION__," Error. close(). path = %s ,errno = %d", LOGARCHIVE_FILENAME_STORE_ARCHIVE, errno);
+ // LCOV_EXCL_STOP
+ }
+ result = remove(LOGARCHIVE_FILENAME_STORE_ARCHIVE);
+ if (result != 0) { // LCOV_EXCL_BR_LINE 6: remove() must return ok
+ // LCOV_EXCL_START 6: remove() must return ok
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR,__FUNCTION__," Error. remove(). path = %s ,errno = %d", LOGARCHIVE_FILENAME_STORE_ARCHIVE, errno);
+ // LCOV_EXCL_STOP
+ }
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return l_eFrameworkunifiedStatus;
+}
+
+static EFrameworkunifiedStatus storeTempArchive(const std::string &real_name)
+{
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+ std::string filename;
+ size_t pos;
+ int fd;
+ int result;
+ const char *p_real_filename;
+ EFrameworkunifiedStatus l_eFrameworkunifiedStatus = eFrameworkunifiedStatusOK;
+
+ fd = open(LOGARCHIVE_FILENAME_STORE_ARCHIVE, O_CREAT | O_WRONLY, TMPFILE_MODE);
+ if (fd == -1) { // LCOV_EXCL_BR_LINE 5: open's error case
+ // LCOV_EXCL_START 5: open's error case
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR,__FUNCTION__," Error. open(). path = %s ,errno = %d", LOGARCHIVE_FILENAME_STORE_ARCHIVE, errno);
+ return eFrameworkunifiedStatusAccessError;
+ // LCOV_EXCL_STOP
+ }
+
+ pos = real_name.find_last_of(PATHNAME_SEPARATOR);
+ if (pos == std::string::npos) { // LCOV_EXCL_BR_LINE 6: there must be '/' in string real_name
+ // LCOV_EXCL_START 6: there must be '/' in string real_name
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ p_real_filename = real_name.c_str();
+ // LCOV_EXCL_STOP
+ } else {
+ p_real_filename = &real_name[pos + 1];
+ }
+
+ result = write(fd, p_real_filename, FILENUMBER_DIGIT_NUM);
+ if (result != FILENUMBER_DIGIT_NUM) { // LCOV_EXCL_BR_LINE 5: write's error case
+ // LCOV_EXCL_START 5: write's error case
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR,__FUNCTION__," Error. write(). path = %s ,result = %d, errno = %d",
+ LOGARCHIVE_FILENAME_STORE_ARCHIVE, result, errno);
+ l_eFrameworkunifiedStatus = eFrameworkunifiedStatusAccessError;
+ // LCOV_EXCL_STOP
+ }
+
+ result = close(fd);
+ if (result != 0) { // LCOV_EXCL_BR_LINE 5: close's error case
+ // LCOV_EXCL_START 5: close's error case
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR,__FUNCTION__," Error. close(). path = %s ,errno = %d", LOGARCHIVE_FILENAME_STORE_ARCHIVE, errno);
+ l_eFrameworkunifiedStatus = eFrameworkunifiedStatusAccessError;
+ // LCOV_EXCL_STOP
+ }
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return l_eFrameworkunifiedStatus;
+}
+
+
+
+//static EFrameworkunifiedStatus closeArchive(TAR* f_pTarInfo) {
+static EFrameworkunifiedStatus closeArchive(TAR* f_pTarInfo, SS_STORELOGS_OPE_TYPE type) {
+
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+ EFrameworkunifiedStatus l_eFrameworkunifiedStatus = eFrameworkunifiedStatusOK;
+
+ if (0 != tar_append_eof(f_pTarInfo)) { // LCOV_EXCL_BR_LINE 5: tar_append_eof's error case
+ // LCOV_EXCL_START 5: tar_append_eof's error case
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __PRETTY_FUNCTION__, "tar_append_eof()");
+ l_eFrameworkunifiedStatus = eFrameworkunifiedStatusFail;
+ // LCOV_EXCL_STOP
+ }
+ if (0 != tar_close(f_pTarInfo)) { // LCOV_EXCL_BR_LINE 5: tar_close's error case
+ // LCOV_EXCL_START 5: tar_close's error case
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Could not close archive");
+ l_eFrameworkunifiedStatus = eFrameworkunifiedStatusFail;
+ // LCOV_EXCL_STOP
+ }
+
+ if (eFrameworkunifiedStatusOK == l_eFrameworkunifiedStatus) { // LCOV_EXCL_BR_LINE 6: l_eFrameworkunifiedStatus must be eFrameworkunifiedStatusOK
+ l_eFrameworkunifiedStatus = copyFile(m_tmpName, m_pathAndName);
+ if (eFrameworkunifiedStatusOK == l_eFrameworkunifiedStatus) {
+
+ if (type == SS_STORELOGS_ILLEGAL) {
+ l_eFrameworkunifiedStatus = storeTempArchive(m_pathAndName);
+ if (eFrameworkunifiedStatusOK != l_eFrameworkunifiedStatus) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error. Failed to store temporary file.");
+ }
+ }
+
+ l_eFrameworkunifiedStatus =
+ (0 == remove(m_tmpName.c_str())) ? eFrameworkunifiedStatusOK : eFrameworkunifiedStatusFault;
+ if (eFrameworkunifiedStatusOK != l_eFrameworkunifiedStatus) { // LCOV_EXCL_BR_LINE 5: remove's error case
+ // LCOV_EXCL_START 5: remove's error case
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FRAMEWORKUNIFIEDLOG(
+ ZONE_WARN,
+ __FUNCTION__,
+ " Warning. Failed to remove temporary archive. Will overwrite on next event");
+ // LCOV_EXCL_STOP
+ }
+ } else if (eFrameworkunifiedStatusErrNoEAGAIN == l_eFrameworkunifiedStatus) { // LCOV_EXCL_BR_LINE 4: no space error case
+ // LCOV_EXCL_START 4: no space error case
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ // disk space full
+ struct stat st_buf;
+ size_t req_size;
+ if (stat(m_tmpName.c_str(), &st_buf) != -1) {
+ req_size = st_buf.st_size;
+ if (eFrameworkunifiedStatusOK == forceDeleteOldLog(m_pathAndName, req_size)) {
+ l_eFrameworkunifiedStatus = copyFile(m_tmpName, m_pathAndName);
+ if (eFrameworkunifiedStatusOK != l_eFrameworkunifiedStatus) {
+ FRAMEWORKUNIFIEDLOG(
+ ZONE_ERR,
+ __FUNCTION__,
+ "Try Again but Error. Failed to copy to destination.%s, size=%d",
+ m_pathAndName.c_str(), req_size);
+ }
+ } else {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ "Error. force delete failed.%s, size=%d",
+ m_pathAndName.c_str(), req_size);
+ }
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " emmc full: dest=%s, size=%d",
+ m_pathAndName.c_str(), req_size);
+ } else {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ "Warning. Failed to get tmp log file stat. dest=%s",
+ m_pathAndName.c_str());
+ }
+ // LCOV_EXCL_STOP
+ } else {
+ /* should we copy lost archive to emmc?? */
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ " Error. Failed to copy to destination. %s", m_pathAndName.c_str());
+ }
+ remove(m_tmpName.c_str());
+ m_tmpName = "";
+ }
+
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return (l_eFrameworkunifiedStatus);
+}
+
+static EFrameworkunifiedStatus addFileToArchive(TAR* f_pTarInfo, std::string f_filename,
+ std::string f_destinationName) {
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+ EFrameworkunifiedStatus l_eFrameworkunifiedStatus = eFrameworkunifiedStatusOK; /* check if Tar is open and if file can be read */
+
+ if ((NULL != f_pTarInfo) && (0 == access(f_filename.c_str(), R_OK))
+ && (0 != f_destinationName.length())) {
+ int l_tarRetVal = tar_append_file(f_pTarInfo, const_cast<char*>(f_filename.c_str()),
+ const_cast<char*>(f_destinationName.c_str()));
+ if (0 != l_tarRetVal) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ "Could not add file \'%s\' to tar archive.", f_filename.c_str());
+ l_eFrameworkunifiedStatus = eFrameworkunifiedStatusAccessError;
+ }
+ } else {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ "Archive not opened or could not access file: \"%s\"",
+ f_filename.c_str());
+ l_eFrameworkunifiedStatus = eFrameworkunifiedStatusInvldParam;
+ }
+
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return (l_eFrameworkunifiedStatus);
+}
+
+static EFrameworkunifiedStatus addAllFileToArchive (TAR* f_pTarInfo, std::string collectDir)
+{
+ struct dirent l_pDirent;
+ struct dirent* next;
+ EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusFail;
+ DEB_LOGGERSERVICELOG(ZONE_FUNC, __FUNCTION__, "+");
+ DIR * l_pDir = opendir(collectDir.c_str());
+ if (l_pDir == NULL) {
+ DEB_LOGGERSERVICELOG(ZONE_ERR, __FUNCTION__, "Could not open directory: %s", collectDir.c_str());
+ } else {
+ while (0 == readdir_r(l_pDir,&l_pDirent,&next) && next != NULL) {
+ if ( ( 0 != strcmp( l_pDirent.d_name, "." ) ) &&
+ ( 0 != strcmp( l_pDirent.d_name, ".." )) &&
+ ( 0 != strcmp( l_pDirent.d_name, "lost+found" )) &&
+ ( '.' != l_pDirent.d_name[0] ) ) {
+ std::string l_fileSource = collectDir;
+ l_fileSource.append("/");
+ l_fileSource.append(l_pDirent.d_name);
+ std::string l_fileDestination = l_pDirent.d_name;
+ l_eStatus = addToArchive(f_pTarInfo,l_fileSource,l_fileDestination);
+ if (l_eStatus != eFrameworkunifiedStatusOK) {
+ break;
+ }
+ }
+ }
+ closedir (l_pDir);
+ }
+ DEB_LOGGERSERVICELOG(ZONE_FUNC, __FUNCTION__, "-");
+ return l_eStatus;
+}
+
+static EFrameworkunifiedStatus addDirectoryToArchive(TAR* f_pTarInfo, std::string f_path,
+ std::string f_destinationName,
+ UI_8 f_depth) {
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+ EFrameworkunifiedStatus l_eFrameworkunifiedStatus = eFrameworkunifiedStatusOK;
+
+ DIR *l_pDir = opendir(f_path.c_str());
+ if (l_pDir != NULL) {
+ struct dirent* l_pDirent;
+ while ((l_pDirent = readdir(l_pDir)) != NULL) {
+ if ((0 != strcmp(l_pDirent->d_name, ".")) && /* Ignore special . directory. */
+ (0 != strcmp(l_pDirent->d_name, "..")) && /* Ignore special .. directory. */
+ ('.' != l_pDirent->d_name[0])) { /* Ignore hidden files */
+ std::string l_extension = "/";
+ std::string l_fileName = f_path;
+ std::string l_destName = f_destinationName;
+ l_extension.append(l_pDirent->d_name);
+ l_fileName.append(l_extension);
+ l_destName.append(l_extension);
+ l_eFrameworkunifiedStatus = addToArchive(f_pTarInfo, l_fileName, l_destName,
+ static_cast<UI_8>(f_depth - 1));
+ }
+ }
+ closedir(l_pDir);
+ }
+
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return (l_eFrameworkunifiedStatus);
+}
+
+static SI_32 gzOpenArchive(PCHAR f_pcPathname, SI_32 f_siOflags,
+ SI_32 f_siMode) {
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+ SI_32 l_siFileDescriptor = -1;
+
+ if (f_pcPathname) {
+ PCHAR l_pcGzoflags;
+
+ switch (f_siOflags & O_ACCMODE) { // LCOV_EXCL_BR_LINE 200: only O_WRONLY be set
+ case O_WRONLY:
+ l_pcGzoflags = (PCHAR) "wb";
+ break;
+ // LCOV_EXCL_START 200: only O_WRONLY be set
+ case O_RDONLY:
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ l_pcGzoflags = (PCHAR) "rb";
+ break;
+ // LCOV_EXCL_STOP
+ case O_RDWR:
+ default:
+ return -1;
+ }
+ if (-1 == (l_siFileDescriptor = open(f_pcPathname, f_siOflags, f_siMode))) {
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return -1;
+ }
+
+ if ((f_siOflags & O_CREAT) && fchmod(l_siFileDescriptor, f_siMode)) {
+ close(l_siFileDescriptor);
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return -1;
+ }
+
+ g_gztype = gzdopen(l_siFileDescriptor, l_pcGzoflags);
+ if (!g_gztype) {
+ close(l_siFileDescriptor);
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return -1;
+ }
+ } else {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Source Path empty.");
+ }
+
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return (SI_32) l_siFileDescriptor;
+}
+
+static SI_32 gzCloseArchive() {
+ return gzclose(g_gztype);
+}
+
+static ssize_t gzWriteArchive(int fd, const void* buf, size_t count) {
+ return gzwrite(g_gztype, const_cast<void*>(buf), (unsigned int) count);
+}
+
+static ssize_t gzReadArchive(int fd, void* buf, size_t count) {
+ return gzread(g_gztype, buf, (unsigned int) count);
+}
+
+static EFrameworkunifiedStatus copyFile(std::string f_source, std::string f_destination) {
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+ EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
+ ssize_t l_nrd;
+ ssize_t l_nwr;
+ char l_buf[1024];
+
+ int l_if = open(f_source.c_str(), O_RDONLY | O_CLOEXEC);
+ if (-1 == l_if) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ "Error. Failed to open file: %s for reading.", f_source.c_str());
+ l_eStatus = eFrameworkunifiedStatusFail;
+ } else {
+ std::string l_tmpDest;
+ size_t l_pos = f_destination.find_last_of('/');
+
+ if (std::string::npos != l_pos) { // LCOV_EXCL_BR_LINE 6: there must be '/' in string f_destination
+ l_tmpDest = f_destination.substr(0, l_pos);
+ l_tmpDest.append("/");
+ l_tmpDest.append(LOGGER_TMP_FN);
+ if (unlink(l_tmpDest.c_str()) != 0) {
+ // always delete tmpLog, and create new tmpLog.
+ }
+ } else {
+ // LCOV_EXCL_START 6: there must be '/' in string f_destination
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ l_tmpDest = f_destination;
+ // LCOV_EXCL_STOP
+ }
+
+ int l_of = open(l_tmpDest.c_str(), O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC,
+ 0640);
+ if (-1 == l_of) { // LCOV_EXCL_BR_LINE 5: open's error case
+ // LCOV_EXCL_START 5: open's error case
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "dest open fail:%s,errno:%d,msg:%s",
+ l_tmpDest.c_str(), errno, strerror(errno));
+ l_eStatus = eFrameworkunifiedStatusFail;
+ // LCOV_EXCL_STOP
+ } else {
+ do {
+ l_nrd = read(l_if, l_buf, sizeof(l_buf));
+ if (l_nrd == -1) { // LCOV_EXCL_BR_LINE 5: read's error case
+ // LCOV_EXCL_START 5: read's error case
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "read fail:%s,errno:%d,msg:%s",
+ f_source.c_str(), errno, strerror(errno));
+ l_eStatus = eFrameworkunifiedStatusAccessError;
+ break;
+ // LCOV_EXCL_STOP
+ }
+ l_nwr = write(l_of, l_buf, l_nrd);
+ if (l_nwr == -1) { // LCOV_EXCL_BR_LINE 5: write's error case
+ // LCOV_EXCL_START 5: write's error case
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ if (ENOSPC == errno) { // LCOV_EXCL_BR_LINE 4: no space error case
+ // LCOV_EXCL_START 4: no space error case
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ "write fail(ENOSPC):%s,errno:%d,msg:%s", l_tmpDest.c_str(),
+ errno, strerror(errno));
+ l_eStatus = eFrameworkunifiedStatusErrNoEAGAIN;
+ // LCOV_EXCL_STOP
+ } else {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "write fail:%s,errno:%d,msg%s",
+ l_tmpDest.c_str(), errno, strerror(errno));
+ l_eStatus = eFrameworkunifiedStatusAccessError;
+ }
+ break;
+ // LCOV_EXCL_STOP
+ }
+ } while (l_nrd > 0);
+ fsync(l_of);
+ close(l_of);
+ }
+ close(l_if);
+
+ if (rename(l_tmpDest.c_str(), f_destination.c_str()) != 0) { // LCOV_EXCL_BR_LINE 5: rename's error case
+ // LCOV_EXCL_START 5: rename's error case
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "rename %s to %s fail,errno:%d,msg:%s",
+ l_tmpDest.c_str(), f_destination.c_str(), errno, strerror(errno));
+ // LCOV_EXCL_STOP
+ }
+
+ if (std::string::npos != l_pos) { // LCOV_EXCL_BR_LINE 6: there must be '/' in string f_destination
+ std::string l_destPath = f_destination.substr(0, l_pos);
+ SyncDir(l_destPath);
+ } else {
+ // LCOV_EXCL_START 6: there must be '/' in string f_destination
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "dest invalid:%s", f_destination.c_str());
+ // LCOV_EXCL_STOP
+ }
+ }
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return (l_eStatus);
+}
+
+static EFrameworkunifiedStatus copyDirectory (std::string f_source, std::string f_destination)
+{
+ DEB_LOGGERSERVICELOG(ZONE_FUNC, __FUNCTION__, "+");
+ EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
+ DIR * l_pDir = opendir(f_source.c_str());
+ if (l_pDir == NULL) {
+ DEB_LOGGERSERVICELOG(ZONE_ERR, __FUNCTION__, "Could not open directory: %s", f_source.c_str());
+ } else {
+ if (mkdir(f_destination.c_str(),0775) == -1) {
+ if (errno == EEXIST) {
+ DEB_LOGGERSERVICELOG(ZONE_FUNC, __FUNCTION__, "Directory: %s already exists.", f_destination.c_str());
+ } else {
+ DEB_LOGGERSERVICELOG(ZONE_ERR, __FUNCTION__, "Could not create directory: %s. Errno: %s", f_destination.c_str(),strerror(errno));
+ l_eStatus = eFrameworkunifiedStatusFail;
+ }
+ } else {
+ SyncDir(f_destination);
+ size_t l_pos = f_destination.find_last_of('/');
+ if (l_pos != std::string::npos) {
+ std::string l_destPath = f_destination.substr(0, l_pos);
+ SyncDir(l_destPath);
+ }
+ }
+
+ struct dirent l_pDirent;
+ struct dirent* next;
+ while (0 == readdir_r(l_pDir,&l_pDirent,&next) && next != NULL) {
+ if ( ( 0 != strcmp( l_pDirent.d_name, "." ) ) &&
+ ( 0 != strcmp( l_pDirent.d_name, ".." )) &&
+ ( 0 != strcmp( l_pDirent.d_name, "lost+found" )) &&
+ ( '.' != l_pDirent.d_name[0] ) ) {
+ std::string l_fileSource = f_source;
+ std::string l_fileDestination = f_destination;
+ l_fileSource.append("/");
+ l_fileSource.append(l_pDirent.d_name);
+ l_fileDestination.append("/");
+ l_fileDestination.append(l_pDirent.d_name);
+ l_eStatus = copyUntyped(l_fileSource,l_fileDestination);
+ }
+ }
+ closedir (l_pDir);
+ }
+ DEB_LOGGERSERVICELOG(ZONE_FUNC, __FUNCTION__, "-");
+ return l_eStatus;
+}
+
+static EFrameworkunifiedStatus copyUntyped (std::string f_source, std::string f_destination)
+{
+ DEB_LOGGERSERVICELOG(ZONE_FUNC, __FUNCTION__, "+");
+ EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
+ struct stat l_stat;
+ SI_8 l_statRetVal;
+ if (0 != access(f_source.c_str(), F_OK)) {
+ DEB_LOGGERSERVICELOG(ZONE_ERR,__FUNCTION__," Error. The specified file path and name does not exist: %s", f_source.c_str());
+ } else if (0 != (l_statRetVal = lstat(f_source.c_str(), &l_stat))) {
+ DEB_LOGGERSERVICELOG(ZONE_ERR,__FUNCTION__," Error. stat() for file or directory returned error: %s -> %d", f_source.c_str(), l_statRetVal);
+ } else if (0 != S_ISDIR(l_stat.st_mode)) {
+ l_eStatus = copyDirectory(f_source, f_destination);
+ } else if (0 != S_ISLNK(l_stat.st_mode)) {
+ l_eStatus = copyDirectory(f_source, f_destination);
+ } else if (0 != S_ISREG(l_stat.st_mode)) {
+ l_eStatus = copyFile(f_source, f_destination);
+ } else {
+ DEB_LOGGERSERVICELOG(ZONE_ERR,__FUNCTION__," Error. specified file may be a symbolic link or other non 'regular' type. File: %s, mode: 0x%04X.",f_source.c_str(),l_stat.st_mode);
+ }
+ DEB_LOGGERSERVICELOG(ZONE_FUNC, __FUNCTION__, "-");
+ return l_eStatus;
+}
+
+static EFrameworkunifiedStatus copyFileToAccOffOnDir(std::vector<LogInfo>& list, SS_STORELOGS_OPE_TYPE type)
+{
+ EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
+ EFrameworkunifiedStatus l_eFrameworkunifiedStatus = eFrameworkunifiedStatusOK;
+ std::string f_destination = LOGGERSERVICELOG_TMP_OUTPUT_PATH;
+ f_destination.append("/");
+ f_destination.append(ACCOFFON_DIR_NAME);
+ DIR * l_pDir = opendir(LOGGERSERVICELOG_TMP_OUTPUT_PATH);
+ if (l_pDir == NULL) {
+ DEB_LOGGERSERVICELOG(ZONE_ERR, __FUNCTION__, "Could not open directory: %s", LOGGERSERVICELOG_TMP_OUTPUT_PATH);
+ l_eStatus = eFrameworkunifiedStatusFail;
+ return l_eStatus;
+ } else {
+ closedir (l_pDir);
+ if (mkdir(f_destination.c_str(), 0775) == -1) {
+ DEB_LOGGERSERVICELOG(ZONE_ERR, __FUNCTION__, "Could not create directory: %s. Errno: %s", f_destination.c_str(),strerror(errno));
+ l_eStatus = eFrameworkunifiedStatusFail;
+ return l_eStatus;
+ }
+ } if (list.size() != 0) {
+ for (UI_32 j = 0; j < list.size(); j++) {
+ std::string dest_name = f_destination;
+ dest_name.append("/");
+ dest_name.append(list.at(j).dest_name);
+ l_eFrameworkunifiedStatus = copyUntyped(list.at(j).file_path, dest_name);
+ if (l_eFrameworkunifiedStatus != eFrameworkunifiedStatusOK) {
+ DEB_LOGGERSERVICELOG(ZONE_WARN, __FUNCTION__, " Error. File %s failed to archive.", list.at(j).file_path.c_str());
+ l_eStatus = l_eFrameworkunifiedStatus;
+ }
+ }
+ copyLoggerservicelogFile(f_destination);
+ }
+ return l_eStatus;
+}
+
+ELOGGERSERVICELOGTYPE QueryLoggerservicelogType(std::string f_logname) {
+// if (f_logname.find("_ILG_RESET.tar.gz") != std::string::npos
+ if (f_logname.find(SS_STORE_FILENAME_SYSILG_TERM) != std::string::npos) {
+ return eLoggerservicelogTypeSysAbnormal;
+ } else if (f_logname.find(SS_STORE_FILENAME__CWORD52__TERM) != std::string::npos) {
+ return eLoggerservicelogType_CWORD52_;
+ } else if (f_logname.find("_ILG_RESET.tar.gz") != std::string::npos
+
+ || f_logname.find("_ERR.tar.gz") != std::string::npos) {
+ return eLoggerservicelogTypeAbnormal;
+ } else if (f_logname.find("_GRP_RELAUNCH.tar.gz") != std::string::npos) {
+ return eLoggerservicelogTypeGrpRelaunch;
+ } else if (f_logname.find(".tar.gz") != std::string::npos) {
+ return eLoggerservicelogTypeNormal;
+ } else {
+ return eLoggerservicelogTypeOther;
+ }
+}
+
+void SyncDir(std::string f_dir_path) {
+ int fd = open(f_dir_path.c_str(), O_RDONLY | O_DIRECTORY | O_CLOEXEC);
+#define OPE_ERR_MSG "%s %s failed. errno:%d,msg:%s"
+ if (fd == -1) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, OPE_ERR_MSG, f_dir_path.c_str(), "open",
+ errno, strerror(errno));
+ } else {
+ if (fsync(fd) == -1) { // LCOV_EXCL_BR_LINE 5: fsync's error case
+ // LCOV_EXCL_START 5: fsync's error case
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, OPE_ERR_MSG, f_dir_path.c_str(), "fsync",
+ errno, strerror(errno));
+ // LCOV_EXCL_STOP
+ }
+ if (close(fd) == -1) { // LCOV_EXCL_BR_LINE 5: close's error case
+ // LCOV_EXCL_START 5: close's error case
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, OPE_ERR_MSG, f_dir_path.c_str(), "close",
+ errno, strerror(errno));
+ // LCOV_EXCL_STOP
+ }
+ }
+#undef OPE_ERR_MSG
+}
+
+// LCOV_EXCL_START 4: no space error case
+size_t deleteRequestLogs(std::string f_emmcpath, ELOGGERSERVICELOGTYPE f_reqtype,
+ size_t f_reqsize, ELOGGERSERVICELOGTYPE f_deltype) {
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+ DIR* l_dirp = NULL;
+ std::vector<std::string> vect;
+ std::vector<std::string>::iterator it;
+ UI_32 l_count = 0;
+ size_t l_totalsize = 0;
+
+ ELOGGERSERVICELOGTYPE filetype;
+
+
+ // create saved file list on eMMC
+ l_dirp = opendir(f_emmcpath.c_str());
+ if (l_dirp != NULL) {
+ struct dirent l_dirent;
+ struct dirent* next;
+ while (0 == readdir_r(l_dirp, &l_dirent, &next) && next != NULL) {
+ std::string l_filename = l_dirent.d_name;
+
+// if (QueryLoggerservicelogType(l_filename) == f_deltype) {
+// vect.push_back(l_filename);
+// }
+ if ((l_filename == ".") && (l_filename == "..")) {
+ continue;
+ }
+ filetype = QueryLoggerservicelogType(l_filename);
+ if (f_deltype == eLoggerservicelogTypeAbnormal) {
+ if ((filetype == eLoggerservicelogTypeAbnormal) || (filetype == eLoggerservicelogTypeSysAbnormal) ||
+ (filetype == eLoggerservicelogType_CWORD52_)) {
+ vect.push_back(l_filename);
+ }
+ } else if (filetype == f_deltype) {
+ vect.push_back(l_filename);
+ }
+
+ }
+ closedir(l_dirp);
+ } else {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " open failed eMMC path: %s",
+ f_emmcpath.c_str());
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return 0;
+ }
+
+ // get num of delete logs
+ std::sort(vect.begin(), vect.end());
+ for (it = vect.begin(); it != vect.end(); it++) {
+ l_count++;
+
+ std::string l_filename = *it;
+ struct stat st_buf;
+ std::string l_tmpstr = f_emmcpath;
+ l_tmpstr.append(l_filename.c_str());
+ if (stat(l_tmpstr.c_str(), &st_buf) != -1) {
+ l_totalsize += st_buf.st_size;
+ }
+
+ if (l_totalsize > f_reqsize) {
+ break;
+ }
+ }
+
+ // start delete logs
+ if ((l_totalsize > f_reqsize) || (f_reqtype == eLoggerservicelogTypeAbnormal)
+ || (f_reqtype == eLoggerservicelogTypeGrpRelaunch)) {
+ for (it = vect.begin(); it != vect.end() && l_count > 0; it++) {
+ l_count--;
+
+ std::string l_filename = *it;
+ std::string l_tmpstr = f_emmcpath;
+ l_tmpstr.append(l_filename.c_str());
+ if (unlink(l_tmpstr.c_str()) != 0) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " unlink failed %s:%d,msg:%s",
+ l_tmpstr.c_str(), errno, strerror(errno));
+ }
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " del-file=%s total=%d", l_tmpstr.c_str(),
+ l_totalsize);
+ }
+
+ if (f_reqtype == eLoggerservicelogTypeAbnormal) {
+ removeSameNumFiles(it, f_emmcpath, vect);
+ }
+
+ SyncDir(f_emmcpath);
+ } else {
+ l_totalsize = 0;
+ FRAMEWORKUNIFIEDLOG(
+ ZONE_INFO,
+ __FUNCTION__,
+ " nothing to delete logs req-type=%d del-logtype=%d total=%d, log_count=%d",
+ f_reqtype, f_deltype, l_totalsize, l_count);
+ }
+
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return l_totalsize;
+}
+// LCOV_EXCL_STOP
+
+// LCOV_EXCL_START 4: no space error case
+EFrameworkunifiedStatus forceDeleteOldLog(std::string f_archive_destination,
+ size_t f_req_size) {
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+ EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusFail;
+ std::string l_emmc_path;
+ size_t l_delsize = 0;
+ ELOGGERSERVICELOGTYPE l_logtype = eLoggerservicelogTypeOther;
+
+ size_t l_pos = f_archive_destination.find_last_of('/');
+ if (std::string::npos != l_pos) {
+ l_emmc_path = f_archive_destination.substr(0, l_pos);
+ l_emmc_path.append("/");
+ l_logtype = QueryLoggerservicelogType(
+ f_archive_destination.substr(l_pos + 1,
+ f_archive_destination.size() - l_pos + 1));
+
+ if ((l_logtype == eLoggerservicelogTypeSysAbnormal) || (l_logtype == eLoggerservicelogType_CWORD52_)) {
+ l_logtype = eLoggerservicelogTypeAbnormal;
+ }
+
+ }
+
+ if (l_logtype == eLoggerservicelogTypeOther) {
+ // not found
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Invalid Parameter. dest=%s",
+ f_archive_destination.c_str());
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return eFrameworkunifiedStatusFail;
+ }
+
+ // remove dirty-file if exist
+ if (unlink(f_archive_destination.c_str()) != 0) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " unlink failed %s:%d.",
+ f_archive_destination.c_str(), errno);
+ }
+
+ // delete normal log
+ l_delsize = deleteRequestLogs(l_emmc_path, l_logtype, f_req_size,
+ eLoggerservicelogTypeNormal);
+ if (l_delsize >= f_req_size) {
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__,
+ " delete normal logs success: req-size=%d, del-size=%d", f_req_size,
+ l_delsize);
+ l_eStatus = eFrameworkunifiedStatusOK;
+ } else if (l_logtype == eLoggerservicelogTypeAbnormal) {
+ // delete abnormal log if request type is abnormal
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__,
+ " continue delete abnormal logs: req-size=%d, del-size=%d",
+ f_req_size, l_delsize);
+ size_t l_tmpsize = f_req_size;
+ l_tmpsize -= l_delsize;
+ l_delsize = deleteRequestLogs(l_emmc_path, l_logtype, l_tmpsize,
+ eLoggerservicelogTypeAbnormal);
+ if (l_delsize >= l_tmpsize) {
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__,
+ " delete abnormal logs success: req-size=%d, del-size=%d",
+ f_req_size, l_delsize);
+ l_eStatus = eFrameworkunifiedStatusOK;
+ } else {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ " abnormal log delete not complete. req-size=%d, del-size=%d",
+ f_req_size, l_delsize);
+ }
+ } else if (l_logtype == eLoggerservicelogTypeGrpRelaunch) {
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__,
+ " continue delete group relaunch logs: req-size=%d, del-size=%d",
+ f_req_size, l_delsize);
+ size_t l_tmpsize = f_req_size;
+ l_tmpsize -= l_delsize;
+ l_delsize = deleteRequestLogs(l_emmc_path, l_logtype, l_tmpsize,
+ eLoggerservicelogTypeGrpRelaunch);
+ if (l_delsize >= l_tmpsize) {
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__,
+ " delete group relaunch logs success: req-size=%d, del-size=%d",
+ f_req_size, l_delsize);
+ l_eStatus = eFrameworkunifiedStatusOK;
+ } else {
+ FRAMEWORKUNIFIEDLOG(
+ ZONE_ERR, __FUNCTION__,
+ " group relaunch log delete not complete. req-size=%d, del-size=%d",
+ f_req_size, l_delsize);
+ }
+ } else {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ " normal log del not complete. req-size=%d, del-size=%d", f_req_size,
+ l_delsize);
+ }
+
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return l_eStatus;
+}
+// LCOV_EXCL_STOP
+
+///////////////////////////////////////////////////////////////////////
+/// Function SS_LoggerStoreDebugLogs
+///////////////////////////////////////////////////////////////////////
+EFrameworkunifiedStatus SS_LoggerStoreLogs(SS_STORELOGS_OPE_TYPE type) {
+ if (type < SS_STORELOGS_MAX) {
+ return storeLogs(type);
+ } else {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error. Bad enum number %d", type);
+ return eFrameworkunifiedStatusFail;
+ }
+}
+
+
+EFrameworkunifiedStatus SS_LoggerStoreLogs_deleteOldLogAbnrm(const std::string& log_path,
+ std::vector<std::string>& l_vector,
+ const std::string& f_archive_destination,
+ SI_32 max_num,
+ UI_32 abnrm_total) {
+ EFrameworkunifiedStatus l_eFrameworkunifiedStatus;
+ l_eFrameworkunifiedStatus = deleteOldLogAbnrm(log_path, l_vector, f_archive_destination, max_num, abnrm_total);
+ return l_eFrameworkunifiedStatus;
+}
+
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+/// IsDirectory
+/// Method to check if the entity is a directory.
+////////////////////////////////////////////////////////////////////////////////////////////////////
+static BOOL IsDirectory(std::string &f_cPath) { // NOLINT (runtime/references)
+ BOOL l_bReturn = FALSE;
+ struct stat st_buf;
+
+ if (-1 == stat(f_cPath.c_str(), &st_buf)) { // LCOV_EXCL_BR_LINE 5: stat's error case // NOLINT (runtime/references) // NOLINT[whitespace/line_length]
+ // LCOV_EXCL_START 5: stat's error case
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ "Error: stat failed for path/file %s, errno %d", f_cPath.c_str(),
+ errno);
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ // LCOV_EXCL_STOP
+ } else if (S_ISDIR(st_buf.st_mode)) {
+ l_bReturn = TRUE; // return true if f_cPath is a directory
+ }
+ return l_bReturn;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+/// RemoveDirectory
+/// Method to remove a directory.
+////////////////////////////////////////////////////////////////////////////////////////////////////
+static BOOL RemoveDirectory(std::string &f_cPath) { // NOLINT (runtime/references)
+ BOOL l_bReturn = FALSE;
+
+ if (RemoveSubDirectory(f_cPath)) { // LCOV_EXCL_BR_LINE 6: RemoveSubDirectory always return true
+ // delete the parent directory
+ if (0 == rmdir(f_cPath.c_str())) { // LCOV_EXCL_BR_LINE 5: rmdir's error case
+ l_bReturn = TRUE;
+ }
+ }
+ return l_bReturn;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+/// RemoveSubDirectory
+/// Method to remove a sub directory.
+////////////////////////////////////////////////////////////////////////////////////////////////////
+static BOOL RemoveSubDirectory(std::string &f_cPath) { // NOLINT (runtime/references)
+ BOOL l_bReturn = TRUE;
+
+ if (!f_cPath.empty()) { // LCOV_EXCL_BR_LINE 6: f_cPath can't be empty
+ std::string l_cFilePath = "";
+ struct dirent l_Dirent;
+ struct dirent* next;
+ DIR *l_pDir = NULL;
+
+ l_pDir = opendir(f_cPath.c_str());
+ if (NULL != l_pDir) { // LCOV_EXCL_BR_LINE 5: opendir's error case
+ if ('/' != f_cPath[f_cPath.length() - 1]) { // LCOV_EXCL_BR_LINE 6: there must be no '/'
+ f_cPath.append("/");
+ }
+
+ while (0 == readdir_r(l_pDir, &l_Dirent, &next) && next != NULL) {
+ if (0 != std::strcmp(l_Dirent.d_name, ".")
+ && 0 != std::strcmp(l_Dirent.d_name, "..")
+ && 0 != std::strcmp(l_Dirent.d_name, "lost+found")) {
+ l_cFilePath.assign(f_cPath);
+ l_cFilePath.append(l_Dirent.d_name); // concatenate the strings to get the complete f_cPath
+ if (TRUE == IsDirectory(l_cFilePath)) {
+ l_bReturn = RemoveDirectory(l_cFilePath);
+ } else {
+ // it's a file, we can use unlink
+ if (unlink(l_cFilePath.c_str()) == -1) { // LCOV_EXCL_BR_LINE 5: unlink's error case
+ // LCOV_EXCL_START 5: unlink's error case
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ l_bReturn = FALSE;
+ // LCOV_EXCL_STOP
+ }
+ }
+ }
+ }
+ closedir(l_pDir); // close the directory
+ SyncDir(f_cPath);
+ } else {
+ // LCOV_EXCL_START 5: opendir's error case
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "l_pDir is NULL");
+ // LCOV_EXCL_STOP
+ }
+ } else {
+ // LCOV_EXCL_START 6: f_cPath can't be empty
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Pathname empty.");
+ l_bReturn = FALSE;
+ // LCOV_EXCL_STOP
+ }
+ return l_bReturn;
+}
+
+static void CreateSaveFinFlag(SS_STORELOGS_OPE_TYPE type) {
+ if (type == SS_STORELOGS_INTERFACEUNIFIEDLOG) {
+ int fd;
+ fd = open(SS_LOGGER_SAVE_INTERFACEUNIFIEDLOG_FLAG,
+ O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC, 0640);
+ if (fd == -1) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error. Create %s. errno %d msg :%s",
+ SS_LOGGER_SAVE_INTERFACEUNIFIEDLOG_FLAG, errno, strerror(errno));
+ } else {
+ fsync(fd);
+ close(fd);
+ std::string l_flagPath = SS_LOGGER_SAVE_INTERFACEUNIFIEDLOG_FLAG;
+ size_t l_pos = l_flagPath.find_last_of('/');
+ if (std::string::npos != l_pos) { // LCOV_EXCL_BR_LINE 6: there must be '/' in l_flagPath
+ std::string l_dirPath = l_flagPath.substr(0, l_pos);
+ SyncDir(l_dirPath);
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "create saveflag finish.");
+ fprintf(stderr, "%s:Completed\n", __FUNCTION__);
+ }
+ }
+ }
+}
+
+static void deleteAccOffOnUntyped(std::string deletePath)
+{
+ struct stat l_stat;
+ SI_8 l_statRetVal;
+ if (0 != access(deletePath.c_str(), F_OK)) {
+ DEB_LOGGERSERVICELOG(ZONE_WARN, __FUNCTION__, "access error (%s)", deletePath.c_str());
+ } else if (0 != (l_statRetVal = lstat(deletePath.c_str(), &l_stat))) {
+ DEB_LOGGERSERVICELOG(ZONE_WARN, __FUNCTION__, "get stat error (%s)", deletePath.c_str());
+ } else if (0 != S_ISDIR(l_stat.st_mode)) {
+ deleteAccOffOnDir(deletePath);
+ } else if (0 != S_ISREG(l_stat.st_mode)) {
+ unlink(deletePath.c_str());
+ }
+}
+
+static void deleteAccOffOnDir(std::string deletePath)
+{
+ DIR * l_pDir = opendir(deletePath.c_str());
+ if (l_pDir != NULL) {
+ struct dirent l_pDirent;
+ struct dirent* next;
+ while (0 == readdir_r(l_pDir,&l_pDirent,&next) && next != NULL) {
+ if ( ( 0 != strcmp( l_pDirent.d_name, "." ) ) &&
+ ( 0 != strcmp( l_pDirent.d_name, ".." )) &&
+ ( 0 != strcmp( l_pDirent.d_name, "lost+found" )) &&
+ ( '.' != l_pDirent.d_name[0] ) ) {
+ std::string l_deletePath = deletePath;
+ l_deletePath.append("/");
+ l_deletePath.append(l_pDirent.d_name);
+ deleteAccOffOnUntyped(l_deletePath);
+ }
+ }
+ closedir (l_pDir);
+ }
+ RemoveDirectory(deletePath);
+}
+
+static EFrameworkunifiedStatus storeLogs(SS_STORELOGS_OPE_TYPE type) {
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+ EFrameworkunifiedStatus l_eFrameworkunifiedStatus = eFrameworkunifiedStatusOK;
+
+ std::string file_name;
+ std::vector<LogInfo> list;
+ std::vector<LoggerservicelogInfo> loggerservicelogList;
+ TAR* tar_info = NULL;
+ uint32_t time_info;
+ uint8_t status;
+ CfgInfo cfginfo;
+
+ UI_32 l_counter = INVALID_FILENUMBER;
+
+
+ // load ss_logger configuration file.
+ getConfigInfo(cfginfo);
+
+
+ if (type == SS_STORELOGS_SYS_ILLEGAL) {
+ if (getFileNumberFromTempArchive(l_counter) != eFrameworkunifiedStatusOK) {
+ // ------------------------------------ //
+ // no made ILG_RESET.tar.gz //
+ // when is abnormal logging count over. //
+ // ------------------------------------ //
+ return eFrameworkunifiedStatusOK;
+ }
+ }
+
+
+// Clock_getSystemTimeY2K38(&time_info, &status);
+
+// file_name = getFileName(cfginfo.output_path, time_info, type);
+//
+// // prepare log files for collectting
+// for (UI_32 i = 0; i < _countof(GetLogFuncTbl); i++) {
+// GetLogFuncTbl[i](type, list);
+// }
+ file_name = getFileName(cfginfo.output_path, time_info, type, l_counter);
+
+ if (type != SS_STORELOGS_SYS_ILLEGAL) {
+ // prepare log files for collectting
+ for (UI_32 i = 0; i < _countof(GetLogFuncTbl); i++) {
+ GetLogFuncTbl[i](type, list);
+ }
+ }
+
+ if (type == SS_STORELOGS_ACCOFFON) {
+ copyFileToAccOffOnDir(list, type);
+ DEB_LOGGERSERVICELOG(ZONE_FUNC, __FUNCTION__, "- : FrameworkunifiedStatus = %d", l_eFrameworkunifiedStatus);
+ return l_eFrameworkunifiedStatus;
+ } else if (type != SS_STORELOGS_ACCOFFON_PRESS) {
+ // loggerservicelogList used with clear buffer
+ getLoggerservicelogFile(type, list, loggerservicelogList);
+ }
+
+ // ---------------------------------------------------------------- //
+ // Warning!!! Logs by using FRAMEWORKUNIFIEDLOG macro, are not saved from here!! //
+ // You can saved logs by FRAMEWORKUNIFIEDLOG after finished to clear buffer. //
+ // ---------------------------------------------------------------- //
+
+ if (list.size() != 0) {
+ // delete old archive before create new one.
+ deleteOldEmmcLog(cfginfo, file_name, type);
+
+ l_eFrameworkunifiedStatus = openArchive(&tar_info, file_name);
+ if (l_eFrameworkunifiedStatus == eFrameworkunifiedStatusOK) {
+ if (type == SS_STORELOGS_ACCOFFON_PRESS) {
+ std::string collectPath;
+ collectPath = LOGGERSERVICELOG_TMP_OUTPUT_PATH;
+ collectPath.append("/");
+ collectPath.append(ACCOFFON_DIR_NAME);
+ if (0 != access(collectPath.c_str(), F_OK)) {
+ DEB_LOGGERSERVICELOG(ZONE_ERR,__FUNCTION__," Error. The specified file path and name does not exist: %s", collectPath.c_str());
+ l_eFrameworkunifiedStatus = eFrameworkunifiedStatusFail;
+ return l_eFrameworkunifiedStatus;
+ } else {
+ l_eFrameworkunifiedStatus = addAllFileToArchive(tar_info,collectPath);
+ }
+ } else {
+ for (UI_32 j = 0; j < list.size(); j++) {
+ l_eFrameworkunifiedStatus = addToArchive(tar_info, list.at(j).file_path, list.at(j).dest_name);
+ if(l_eFrameworkunifiedStatus != eFrameworkunifiedStatusOK) {
+ FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, " Error. File %s failed to archive.", list.at(j).file_path.c_str());
+ }
+ }
+ }
+
+// l_eFrameworkunifiedStatus = closeArchive(tar_info);
+ l_eFrameworkunifiedStatus = closeArchive(tar_info, type);
+
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "finish archiving logs(%d)", type);
+
+ // when finish archiving, clear frameworkunifiedlog buffer.
+ if (type == SS_STORELOGS_ACCOFFON_PRESS) {
+ deleteTmpAccOffOn((std::string)ACCOFFON_DIR_NAME);
+ DEB_LOGGERSERVICELOG(ZONE_FUNC, __FUNCTION__, "- : FrameworkunifiedStatus = %d", l_eFrameworkunifiedStatus);
+ return (l_eFrameworkunifiedStatus);
+ } else {
+ ClearLoggerservicelogBuffer(loggerservicelogList);
+ }
+
+ // create flag of archiving completed
+ CreateSaveFinFlag(type);
+
+ // -------------------------------------------- //
+ // You can save logs by FRAMEWORKUNIFIEDLOG macro from here. //
+ // -------------------------------------------- //
+ }
+
+ // remove temporary or unnecessary files.
+ for (UI_32 k = 0; k < list.size(); k++) {
+ if (list.at(k).tmp_file_delete == TRUE) {
+ struct stat l_stat;
+ if (0 != stat(list.at(k).file_path.c_str(), &l_stat)) {
+ FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, "Error. stat(%s) errno. %d",
+ list.at(k).file_path.c_str(), errno);
+ } else if (S_ISDIR(l_stat.st_mode)) {
+ RemoveDirectory(list.at(k).file_path);
+ } else {
+ if (0 != unlink(list.at(k).file_path.c_str())) { // LCOV_EXCL_BR_LINE 5: unlink's error case
+ // LCOV_EXCL_START 5: unlink's error case
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, " Error. unlink(%s) errno. %d",
+ list.at(k).file_path.c_str(), errno);
+ // LCOV_EXCL_STOP
+ }
+ }
+ }
+ }
+ }
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "- : FrameworkunifiedStatus = %d", l_eFrameworkunifiedStatus);
+ return (l_eFrameworkunifiedStatus);
+}
+
+static void getCommunicationlogFile(SS_STORELOGS_OPE_TYPE type,
+ std::vector<LogInfo>& list) { // NOLINT (runtime/references)
+
+ LogInfo log_info;
+
+ log_info.file_path = FRAMEWORKUNIFIEDLOG_RAMDISC_PATH;
+ log_info.file_path.append("/");
+ log_info.file_path.append(COMMUNICATION_DIR_NAME);
+ log_info.dest_name = COMMUNICATION_DIR_NAME;
+ log_info.tmp_file_delete = FALSE;
+ list.push_back(log_info);
+}
+
+static void getExternallogFile(SS_STORELOGS_OPE_TYPE type,
+ std::vector<LogInfo>& list) { // NOLINT (runtime/references)
+ EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
+ ExternalLogList ext_log;
+ memset(&ext_log, 0, sizeof(&ext_log));
+
+ CNSConfigReader *l_pReaderCfg = new CNSConfigReader();
+
+ if (NULL == l_pReaderCfg) { // LCOV_EXCL_BR_LINE 5: new's error case
+ // LCOV_EXCL_START 5: new's error case
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error. Unable to allocate CNSConfigReader object.");
+ // LCOV_EXCL_STOP
+ } else {
+ if (eFrameworkunifiedStatusOK != (l_eStatus = l_pReaderCfg->Parse(LOGGERSERVICELOG_CONFIG_PATH))) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error. l_pReaderCfg->Parse(%s) returned: 0x%X", LOGGERSERVICELOG_CONFIG_PATH);
+ } else if (eFrameworkunifiedStatusOK !=
+ (l_eStatus = l_pReaderCfg->GetInt("LOGGING.ExternalLogNum", ext_log.num))) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error. l_pReaderCfg->GetInt(LOGGING.ExternalLogNum)");
+ } else if (eFrameworkunifiedStatusOK !=
+ (l_eStatus = l_pReaderCfg->GetInt("LOGGING.ExternalLogMax", ext_log.max))) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error. l_pReaderCfg->GetInt(LOGGING.EmmcOutputMax)");
+ } else {
+ if (ext_log.num > 0) {
+ std::string str = "EXTERNAL_";
+ UI_32 num = 0;
+
+ if (ext_log.num <= ext_log.max) {
+ num = ext_log.num;
+ } else {
+ num = ext_log.max;
+ }
+
+ ext_log.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"), ext_log.p_info[i].dirname))) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error. l_pReaderCfg->GetString(EXTERNAL.OutputPath)");
+ } else if (eFrameworkunifiedStatusOK !=
+ (l_eStatus = l_pReaderCfg->GetString((query+".ExtLogPath"), ext_log.p_info[i].path))) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error. l_pReaderCfg->GetString(EXTERNAL.ExtLogPath)");
+ } else if (eFrameworkunifiedStatusOK !=
+ (l_eStatus = l_pReaderCfg->GetBool((query+".Remove"), ext_log.p_info[i].remove))) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error. l_pReaderCfg->GetBool(EXTERNAL.Remove)");
+ } else {
+ LogInfo log_info;
+ log_info.file_path = ext_log.p_info[i].path;
+ log_info.dest_name = ext_log.p_info[i].dirname;
+ log_info.tmp_file_delete = ext_log.p_info[i].remove;
+
+ list.push_back(log_info);
+ }
+ }
+
+ delete[] ext_log.p_info;
+
+ } else {
+ // None external log
+ }
+ }
+ delete l_pReaderCfg;
+ }
+}
+
+
+
+
+static void getLoggerservicelogFile(SS_STORELOGS_OPE_TYPE type,
+ std::vector<LogInfo>& list, // NOLINT (runtime/references)
+ std::vector<LoggerservicelogInfo>& loggerservicelogList) { // NOLINT (runtime/references)
+ EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
+ UI_32 l_DumpSize = 0;
+ std::string src_file_path;
+ std::string dst_file_path;
+ PCSTR file_name;
+ UI_32 file_num;
+ LogInfo log_info;
+ LoggerservicelogInfo loggerservicelog_info;
+
+ file_num = NSLogGetFrameworkunifiedlogFileTotalNum();
+ for (UI_32 cont = 0; cont < file_num; cont++) {
+ file_name = NSLogGetFrameworkunifiedlogFileName(cont);
+ if (file_name == NULL) {
+ break;
+ }
+ src_file_path = FRAMEWORKUNIFIEDLOG_RAMDISC_PATH;
+ src_file_path.append("/");
+ src_file_path.append(file_name);
+ dst_file_path = LOGGERSERVICELOG_TMP_OUTPUT_PATH;
+ dst_file_path.append("/");
+ dst_file_path.append(file_name);
+
+ int index;
+ index = NSLogGetFrameworkunifiedlogIndex(src_file_path.c_str());
+ CNSRingBuffer* l_pLoggerservicelog = new (std::nothrow) CNSRingBuffer(
+ src_file_path, 0, index + LOCK_NSLOG_ACCES_IF_1);
+ if (l_pLoggerservicelog == NULL) { // LCOV_EXCL_BR_LINE 5: new's error case
+ // LCOV_EXCL_START 5: new's error case
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ "Error: FRAMEWORKUNIFIEDLOG RingBuffer handle is NULL %s",
+ src_file_path.c_str());
+ continue;
+ // LCOV_EXCL_STOP
+ } else if (eFrameworkunifiedStatusOK != (l_eStatus = l_pLoggerservicelog->Open())) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ "Error: FRAMEWORKUNIFIEDLOG RingBuffer Open failed %s %d",
+ src_file_path.c_str(), l_eStatus);
+ } else {
+ if (eFrameworkunifiedStatusOK
+ != (l_eStatus = l_pLoggerservicelog->DumpToFile(dst_file_path.c_str(),
+ &l_DumpSize))) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ "Error: FRAMEWORKUNIFIEDLOG RingBuffer DumpToFile failed %s %d",
+ src_file_path.c_str(), l_eStatus);
+ } else {
+ log_info.file_path = dst_file_path;
+ log_info.dest_name = file_name;
+ log_info.tmp_file_delete = TRUE;
+ list.push_back(log_info);
+ // save frameworkunifiedlog-info for using clear frameworkunifiedlog buffer
+ loggerservicelog_info.path = src_file_path;
+ loggerservicelog_info.index = index;
+ loggerservicelogList.push_back(loggerservicelog_info);
+ }
+ (void) l_pLoggerservicelog->Close();
+ }
+ delete l_pLoggerservicelog;
+ }
+}
+
+static void copyLoggerservicelogFile(std::string distPath)
+{
+ EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
+ UI_32 l_DumpSize = 0;
+ std::string src_file_path;
+ std::string dst_file_path;
+ PCSTR file_name;
+ UI_32 file_num;
+
+ file_num = NSLogGetFrameworkunifiedlogFileTotalNum();
+
+ for (UI_32 cont = 0; cont < file_num; cont++) {
+ file_name = NSLogGetFrameworkunifiedlogFileName(cont);
+
+ if (file_name == NULL) {
+ break;
+ }
+
+ src_file_path = FRAMEWORKUNIFIEDLOG_RAMDISC_PATH;
+ src_file_path.append("/");
+ src_file_path.append(file_name);
+
+ dst_file_path = distPath;
+ dst_file_path.append("/");
+ dst_file_path.append(file_name);
+
+ int index;
+ index = NSLogGetFrameworkunifiedlogIndex(src_file_path.c_str());
+ CNSRingBuffer* l_pLoggerservicelog = new (std::nothrow)CNSRingBuffer(src_file_path,0,index+LOCK_NSLOG_ACCES_IF_1);
+ if (l_pLoggerservicelog == NULL) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error: FRAMEWORKUNIFIEDLOG RingBuffer handle is NULL %s", src_file_path.c_str());
+ continue;
+ } else if (eFrameworkunifiedStatusOK != (l_eStatus = l_pLoggerservicelog->Open())) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,"Error: FRAMEWORKUNIFIEDLOG RingBuffer Open failed %s %d", src_file_path.c_str(), l_eStatus);
+ } else {
+ if (eFrameworkunifiedStatusOK != (l_eStatus = l_pLoggerservicelog->DumpToFile(dst_file_path.c_str(), &l_DumpSize))) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,"Error: FRAMEWORKUNIFIEDLOG RingBuffer DumpToFile failed %s %d", src_file_path.c_str(), l_eStatus);
+ }
+ (void)l_pLoggerservicelog->Close();
+ }
+ delete l_pLoggerservicelog;
+ }
+}
+
+static void deleteTmpAccOffOn(std::string accOffOnDir)
+{
+ std::string l_tmpAccOffOnPath = LOGGERSERVICELOG_TMP_OUTPUT_PATH;
+ l_tmpAccOffOnPath.append("/");
+ l_tmpAccOffOnPath.append(accOffOnDir.c_str());
+ DIR * l_pDir = opendir(l_tmpAccOffOnPath.c_str());
+ if (l_pDir != NULL) {
+ struct dirent l_pDirent;
+ struct dirent* next;
+ while (0 == readdir_r(l_pDir,&l_pDirent,&next) && next != NULL) {
+ if ( ( 0 != strcmp( l_pDirent.d_name, "." ) ) &&
+ ( 0 != strcmp( l_pDirent.d_name, ".." )) &&
+ ( 0 != strcmp( l_pDirent.d_name, "lost+found" )) &&
+ ( '.' != l_pDirent.d_name[0] ) ) {
+ std::string l_deletePath = l_tmpAccOffOnPath;
+ l_deletePath.append("/");
+ l_deletePath.append(l_pDirent.d_name);
+ deleteAccOffOnUntyped(l_deletePath);
+ }
+ }
+ closedir (l_pDir);
+ }
+ RemoveDirectory(l_tmpAccOffOnPath);
+}
+
+static void ClearLoggerservicelogBuffer(std::vector<LoggerservicelogInfo> &loggerservicelogList) { // NOLINT (runtime/references)
+ EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
+ std::vector<LoggerservicelogInfo>::iterator ite = loggerservicelogList.begin();
+
+ if (ite == loggerservicelogList.end()) {
+ // target not found...
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "nothing to clear");
+ } else {
+ for (ite = loggerservicelogList.begin(); ite != loggerservicelogList.end(); ite++) {
+ CNSRingBuffer* l_pLoggerservicelog = new (std::nothrow) CNSRingBuffer(
+ ite->path.c_str(), 0, ite->index + LOCK_NSLOG_ACCES_IF_1);
+ if (l_pLoggerservicelog == NULL) { // LCOV_EXCL_BR_LINE 5: new's error case
+ // LCOV_EXCL_START 5: new's error case
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ "Error: FRAMEWORKUNIFIEDLOG RingBuffer handle is NULL %s", ite->path.c_str());
+ continue;
+ // LCOV_EXCL_STOP
+ } else if (eFrameworkunifiedStatusOK != (l_eStatus = l_pLoggerservicelog->Open())) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ "Error: FRAMEWORKUNIFIEDLOG RingBuffer Open failed %s %d", ite->path.c_str(),
+ l_eStatus);
+ } else {
+ if (eFrameworkunifiedStatusOK != (l_eStatus = l_pLoggerservicelog->ClearBuf())) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ "Error: FRAMEWORKUNIFIEDLOG RingBuffer ClearBuf failed %s %d",
+ ite->path.c_str(), l_eStatus);
+ }
+ (void) l_pLoggerservicelog->Close();
+ }
+ delete l_pLoggerservicelog;
+ }
+ }
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Completed");
+ fprintf(stderr, "%s:Completed\n", __FUNCTION__);
+}
+
+static void createKernelLog(SS_STORELOGS_KERNEL_LOG_TYPE type) {
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+ int len;
+ int fd;
+ char* buf;
+ ssize_t wr_len;
+
+ len = klogctl(SYSLOG_ACTION_SIZE_BUFFER, NULL, 0);
+ if (len < 0) { // LCOV_EXCL_BR_LINE 5: klogctl's error case
+ // LCOV_EXCL_START 5: klogctl's error case
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ "Error. Failed to get syslog buffer size: %d, %s", errno,
+ strerror(errno));
+ // LCOV_EXCL_STOP
+ } else {
+ buf = reinterpret_cast<char*>(malloc(len));
+ if (buf != NULL) { // LCOV_EXCL_BR_LINE 5: malloc's error case
+ len = klogctl(SYSLOG_ACTION_READ_ALL, buf, len);
+ if ((len < 0) || (len == 0)) { // LCOV_EXCL_BR_LINE 5: klogctl's error case
+ // LCOV_EXCL_START 5: klogctl's error case
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ "Error. Failed to read syslog buffer: %d, %s", errno,
+ strerror(errno));
+ // LCOV_EXCL_STOP
+ } else {
+ std::string file_put_path = "";
+
+ switch (type) {
+ case SS_STORELOGS_KERNEL_LOG:
+ file_put_path = LOGGERSERVICELOG_TMP_OUTPUT_PATH;
+ file_put_path.append("/");
+ file_put_path.append(KERNEL_LOG_FN);
+ fd = open(file_put_path.c_str(),
+ O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC, 0644);
+ break;
+ case SS_STORELOGS_KERNEL_BOOT_LOG:
+ file_put_path = FRAMEWORKUNIFIEDLOG_RAMDISC_PATH;
+ file_put_path.append("/");
+ file_put_path.append(KERNEL_BOOT_LOG_FN);
+ fd = open(file_put_path.c_str(),
+ O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC, 0644);
+ break;
+ default:
+ fd = -1;
+ break;
+ }
+
+ if (fd == -1) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ "Error. Failed to open file: %s: %d, %s",
+ file_put_path.c_str(), errno, strerror(errno));
+ } else {
+ wr_len = write(fd, buf, len);
+ if (wr_len == -1) { // LCOV_EXCL_BR_LINE 5: write's error case
+ // LCOV_EXCL_START 5: write's error case
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ " Error. File write failed. errno: %d, %s", errno,
+ strerror(errno));
+ // LCOV_EXCL_STOP
+ }
+ fsync(fd);
+ close(fd);
+ }
+ }
+ free(buf);
+ } else {
+ // LCOV_EXCL_START 5: malloc's error case
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Memory allocation Failed %s",
+ strerror(errno));
+ // LCOV_EXCL_STOP
+ }
+ }
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+}
+
+static void getKernellogFile(SS_STORELOGS_OPE_TYPE type,
+ std::vector<LogInfo>& list) { // NOLINT (runtime/references)
+ getLastKernelLog(list);
+
+ getKernelLog(list);
+
+ if (type != SS_STORELOGS_ACCOFFON) {
+ getKernelBootLog(type, list);
+ }
+}
+
+static void getLastKernelLog(std::vector<LogInfo>& list) { // NOLINT (runtime/references)
+ LogInfo log_info;
+
+ log_info.file_path = PSTORE_DIR_PATH;
+ log_info.dest_name = "kernellog";
+ log_info.tmp_file_delete = FALSE;
+ list.push_back(log_info);
+}
+
+static void getKernelLog(std::vector<LogInfo>& list) { // NOLINT (runtime/references)
+ createKernelLog(SS_STORELOGS_KERNEL_LOG);
+
+ LogInfo log_info;
+
+ std::string klog_path = LOGGERSERVICELOG_TMP_OUTPUT_PATH;
+ klog_path.append("/");
+ klog_path.append(KERNEL_LOG_FN);
+
+ if (0 == access(klog_path.c_str(), F_OK)) {
+ log_info.file_path = klog_path;
+ log_info.dest_name = KERNEL_LOG_FN;
+ log_info.tmp_file_delete = TRUE;
+ list.push_back(log_info);
+ } else {
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Info: %s not found.", klog_path.c_str());
+ }
+}
+
+static void getKernelBootLog(SS_STORELOGS_OPE_TYPE type,
+ std::vector<LogInfo>& list) { // NOLINT (runtime/references)
+ createKernelLog(SS_STORELOGS_KERNEL_BOOT_LOG);
+
+ LogInfo log_info;
+
+ std::string klog_path = FRAMEWORKUNIFIEDLOG_RAMDISC_PATH;
+ klog_path.append("/");
+ klog_path.append(KERNEL_BOOT_LOG_FN);
+
+ if (0 == access(klog_path.c_str(), F_OK)) {
+ std::string klog_out_path = LOGGERSERVICELOG_TMP_OUTPUT_PATH;
+ klog_out_path.append("/");
+ klog_out_path.append(KERNEL_BOOT_LOG_FN);
+
+ if (eFrameworkunifiedStatusOK == copyFile(klog_path.c_str(), klog_out_path.c_str())) { // LCOV_EXCL_BR_LINE 6: copyFile must return ok // NOLINT[whitespace/line_length]
+ log_info.file_path = klog_out_path;
+ log_info.dest_name = KERNEL_BOOT_LOG_FN;
+ log_info.tmp_file_delete = TRUE;
+ list.push_back(log_info);
+ } else {
+ // LCOV_EXCL_START 6: copyFile must return ok
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Info: copyFile src:%s dest:%s failed.",
+ klog_path.c_str(), klog_out_path.c_str());
+ // LCOV_EXCL_STOP
+ }
+ } else {
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Info: %s not found.", klog_path.c_str());
+ }
+}
+
+
+//static std::string getFileName(std::string &path, uint32_t f_time, // NOLINT (runtime/references)
+// SS_STORELOGS_OPE_TYPE type) {
+static std::string getFileName(std::string &path, uint32_t f_time,
+ SS_STORELOGS_OPE_TYPE type, UI_32 l_counter) {
+
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+ std::stringstream l_nameStream;
+
+// UI_32 l_counter = 0;
+ std::string l_time_str = "00000000_000000";
+ std::string l_ret;
+ char buffer[20];
+ struct tm l_time_tmp;
+
+
+// getEmmcCounter(path, l_counter);
+ if (l_counter == INVALID_FILENUMBER) {
+ l_counter = 0;
+ getEmmcCounter(path, l_counter);
+ }
+
+
+// CLOCK_RETURN clock_ret = Clock_getLocalTimeY2K38(&f_time, &l_time_tmp);
+// if (clock_ret == CLOCK_OK) {
+// if (0 != strftime(buffer, sizeof(buffer), "%Y%m%d_%H%M%S", &l_time_tmp)) {
+// l_time_str = buffer;
+// }
+// }
+
+// l_nameStream << std::setw(5) << std::setfill('0') << std::right << std::dec
+// << l_counter << '_';
+ l_nameStream << std::setw(FILENUMBER_DIGIT_NUM) << std::setfill('0') << std::right << std::dec
+ << l_counter << '_';
+
+
+ switch (type) {
+ case SS_STORELOGS_ILLEGAL:
+ l_nameStream << std::setw(15) << l_time_str << "_ILG_RESET.tar.gz";
+ break;
+ case SS_STORELOGS_INTERFACEUNIFIEDLOG:
+ l_nameStream << std::setw(15) << l_time_str << "_ACCOFF.tar.gz";
+ break;
+ case SS_STORELOGS_ACCOFFON:
+ case SS_STORELOGS_ACCOFFON_PRESS:
+ l_nameStream << std::setw(15) << l_time_str << "_ACCOFFON.tar.gz";
+ break;
+
+ case SS_STORELOGS_SYS_ILLEGAL:
+ l_nameStream << std::setw(15) << l_time_str << SS_STORE_FILENAME_SYSILG_TERM;
+ break;
+
+ default:
+ //Set the file name as usual for cases other than the anomaly log specification.
+ l_nameStream << std::setw(15) << l_time_str << ".tar.gz";
+ break;
+ }
+
+ l_ret = path;
+ l_ret.append("/");
+ l_ret.append(l_nameStream.str());
+
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return (l_ret);
+}
+
+static void getEmmcCounter(std::string &path, UI_32& f_counter) { // NOLINT (runtime/references)
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+ std::string l_checkFileName;
+ std::vector<UI_32> l_vector;
+ DIR *l_dirp;
+ struct dirent *l_direntp;
+ size_t l_pos;
+ UI_32 l_count;
+ UI_32 l_maxCount = 0;
+
+ l_dirp = opendir(path.c_str());
+ if (l_dirp != NULL) {
+ for (;;) {
+ l_direntp = readdir(l_dirp);
+ if (l_direntp == NULL) {
+ break;
+ }
+ l_checkFileName = l_direntp->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) {
+ 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);
+ }
+ l_maxCount++;
+
+// if (l_maxCount >= 100000u) {
+// l_maxCount = 1;
+ if (l_maxCount >= FILENUMBER_UPPER_LIMIT_OVER) {
+ l_maxCount = FILENUMBER_LOWER_LIMIT;
+
+ for (;;) {
+ std::vector<UI_32>::iterator find_itr = std::find(l_vector.begin(),
+ l_vector.end(),
+ l_maxCount);
+ if (find_itr == l_vector.end()) {
+ break;
+ }
+ l_maxCount++;
+ }
+ }
+ f_counter = l_maxCount;
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+}
+
+static void getConfigInfo(CfgInfo& f_cfginfo) { // NOLINT (runtime/references)
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+ EFrameworkunifiedStatus l_eStatus;
+
+ f_cfginfo.output_path = "";
+ f_cfginfo.output_max = 0;
+
+ CNSConfigReader *l_pReaderCfg = new CNSConfigReader();
+
+ if (NULL == l_pReaderCfg) { // LCOV_EXCL_BR_LINE 5: new's error case
+ // LCOV_EXCL_START 5: new's error case
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ " Error. Unable to allocate CNSConfigReader object.");
+ // LCOV_EXCL_STOP
+ } else {
+ if (eFrameworkunifiedStatusOK != (l_eStatus = l_pReaderCfg->Parse(LOGGERSERVICELOG_CONFIG_PATH))) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ " Error. l_pReaderCfg->Parse(%s) returned: 0x%X",
+ LOGGERSERVICELOG_CONFIG_PATH, l_eStatus);
+ } else if (eFrameworkunifiedStatusOK
+ != (l_eStatus = l_pReaderCfg->GetString("LOGGING.EmmcOutputPath",
+ f_cfginfo.output_path))) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ " Error. l_pReaderCfg->GetString(LOGGING.EmmcOutputPath)");
+ } else if (eFrameworkunifiedStatusOK
+ != (l_eStatus = l_pReaderCfg->GetInt("LOGGING.EmmcOutputMax",
+ f_cfginfo.output_max))) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ " Error. l_pReaderCfg->GetInt(LOGGING.EmmcOutputMax)");
+ } else if (eFrameworkunifiedStatusOK
+ != (l_eStatus = l_pReaderCfg->GetInt("LOGGING.EmmcOutputErrMax",
+ f_cfginfo.output_errmax))) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ " Error. l_pReaderCfg->GetInt(LOGGING.EmmcOutputErrMax)");
+ }
+ delete l_pReaderCfg;
+ }
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+}
+
+static EFrameworkunifiedStatus deleteOldLog(std::string log_path,
+ std::vector<std::string>& l_vector, // NOLINT (runtime/references)
+ std::string& f_archive_destination, // NOLINT (runtime/references)
+ UI_32 max_num) {
+ EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
+
+ size_t l_pos = f_archive_destination.find_last_of('/');
+
+ if (std::string::npos != l_pos) { // LCOV_EXCL_BR_LINE 6: '/' must exist in f_archive_destination
+ std::sort(l_vector.begin(), l_vector.end());
+ std::vector<std::string>::iterator itr = l_vector.begin();
+ for (UI_32 i = static_cast<UI_32>(l_vector.size()); (max_num - 1) < i; i--, itr++) {
+ if (itr == l_vector.end()) { // LCOV_EXCL_BR_LINE 6: itr can't be l_vector.end()
+ // LCOV_EXCL_START 6: itr can't be l_vector.end()
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ break;
+ // LCOV_EXCL_STOP
+ }
+ std::string l_FilePath = log_path;
+ std::string l_FileName = *itr;
+ l_FilePath.append("/");
+ l_FilePath.append(l_FileName.c_str());
+ if (0 != unlink(l_FilePath.c_str())) {
+ l_eStatus = eFrameworkunifiedStatusAccessError;
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error. delete old log file %s:%d.",
+ l_FilePath.c_str(), errno);
+ }
+ }
+ SyncDir(log_path);
+ } else {
+ // LCOV_EXCL_START 6: '/' must exist in f_archive_destination
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ l_eStatus = eFrameworkunifiedStatusFail;
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error. delete target not found. %s",
+ f_archive_destination.c_str());
+ // LCOV_EXCL_STOP
+ }
+ return l_eStatus;
+}
+
+
+static EFrameworkunifiedStatus getFileNumber(const std::string &filename,UI_32 &number) {
+ char buf[16];
+ size_t pos;
+ size_t offset;
+ size_t length;
+ UI_32 temp_value;
+
+ offset = filename.find_last_of(PATHNAME_SEPARATOR) + 1;
+ pos = filename.find_first_of('_', offset);
+ length = pos-offset;
+ if (std::string::npos == pos) {
+ return eFrameworkunifiedStatusInvldParam;
+ } else if (sizeof(buf) <= length) {
+ return eFrameworkunifiedStatusInvldParam;
+ }
+
+ char *endptr;
+ int error_number;
+
+ memcpy(buf, filename.c_str() + offset, length);
+ buf[length] = '\x0';
+
+ errno = EOK;
+ temp_value = strtol(buf, &endptr, 10);
+ error_number = errno;
+ if ((error_number != EOK) || (*endptr != '\x0')) {
+ return eFrameworkunifiedStatusInvldParam;
+ }
+ number = temp_value;
+ return eFrameworkunifiedStatusOK;
+}
+
+static bool compareFileNumber(UI_32 filename1_number, const std::string &filename2) {
+ EFrameworkunifiedStatus l_eStatus;
+ bool result;
+ UI_32 filename2_number;
+
+ l_eStatus = getFileNumber(filename2, filename2_number);
+ if (l_eStatus != eFrameworkunifiedStatusOK) {
+ return false;
+ }
+ result = (filename1_number == filename2_number);
+ return result;
+}
+
+static EFrameworkunifiedStatus removeFiles(const std::string &log_path, std::vector<std::string> &l_vector,
+ size_t begin_pos, size_t end_pos) {
+ std::string l_FilePath;
+ size_t i;
+ int result;
+ EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
+ EFrameworkunifiedStatus l_ePartStatus = eFrameworkunifiedStatusOK;
+ l_FilePath.reserve(SSLOGGER_PATHNAME);
+ for (i = begin_pos; i < end_pos; i++) {
+ l_FilePath = log_path + PATHNAME_SEPARATOR_STR + l_vector[i];
+ result = unlink(l_FilePath.c_str());
+ if (0 != result) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error. unlink() filename = %s ,errno = %d.", l_FilePath.c_str(), errno);
+ l_ePartStatus = eFrameworkunifiedStatusAccessError;
+ if (l_ePartStatus != eFrameworkunifiedStatusOK) {
+ l_eStatus = l_ePartStatus;
+ }
+ }
+ }
+ return l_eStatus;
+}
+
+static EFrameworkunifiedStatus removeSameNumFiles(std::vector<std::string>::iterator &itr, const std::string &log_path,
+ std::vector<std::string> &l_vector) {
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+ if (l_vector.begin() == itr) { // LCOV_EXCL_BR_LINE 4: itr is l_vector.begin() only when no space error case
+ // LCOV_EXCL_START 4: itr is l_vector.begin() only when no space error case
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return eFrameworkunifiedStatusOK;
+ // LCOV_EXCL_STOP
+ }
+ std::string &removed_filename = *(itr - 1);
+ UI_32 removed_filenumber;
+ if (getFileNumber(removed_filename, removed_filenumber) != eFrameworkunifiedStatusOK) { // LCOV_EXCL_BR_LINE 6: double check, must return ok // NOLINT[whitespace/line_length]
+ // LCOV_EXCL_START 6: double check, must return ok
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, " Warning. Type mismatch filename. = %s", removed_filename.c_str());
+ return eFrameworkunifiedStatusOK;
+ // LCOV_EXCL_STOP
+ }
+
+ std::string l_FilePath;
+ EFrameworkunifiedStatus l_ePartStatus = eFrameworkunifiedStatusOK;
+ EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
+ int result;
+ for (;itr < l_vector.end(); itr++) {
+ const std::string &exist_filename = (*itr);
+ if (compareFileNumber(removed_filenumber, exist_filename) == true) {
+ l_FilePath = log_path + PATHNAME_SEPARATOR_STR + exist_filename;
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " Remove file = %s.", l_FilePath.c_str());
+ result = unlink(l_FilePath.c_str());
+ if (0 != result) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error. unlink() filename = %s , errno = %d.", l_FilePath.c_str(), errno);
+ l_ePartStatus = eFrameworkunifiedStatusAccessError;
+ if (l_ePartStatus != eFrameworkunifiedStatusOK) {
+ l_eStatus = l_ePartStatus;
+ }
+ }
+ } else {
+ break;
+ }
+ }
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return l_eStatus;
+}
+
+static EFrameworkunifiedStatus deleteOldLogAbnrm(const std::string& log_path, std::vector<std::string>& l_vector,
+ const std::string& f_archive_destination, SI_32 max_num, UI_32 abnrm_total) {
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+ size_t l_pos = f_archive_destination.find_last_of(PATHNAME_SEPARATOR);
+ if (std::string::npos == l_pos) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error. delete target not found. %s", f_archive_destination.c_str());
+ return eFrameworkunifiedStatusFail;
+ }
+ if (l_vector.size() == 0) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error. empty array.");
+ return eFrameworkunifiedStatusFail;
+ }
+ //FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " max_num = %d , vect_abnrm.size() = %d", max_num, vect_abnrm.size());
+
+ size_t i;
+ EFrameworkunifiedStatus l_ePartStatus = eFrameworkunifiedStatusOK;
+ EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
+ size_t end_pos = l_vector.size();
+ SI_32 abnrm_count = 0;
+ UI_32 exist_filenumber;
+ ELOGGERSERVICELOGTYPE filetype;
+
+ max_num = abnrm_total - max_num + 1;
+ std::sort(l_vector.begin(), l_vector.end());
+ for (i = 0; i < end_pos; i++) {
+ const std::string &exist_filename = l_vector[i];
+ if (getFileNumber(exist_filename, exist_filenumber) != eFrameworkunifiedStatusOK) {
+ continue;
+ }
+ filetype = QueryLoggerservicelogType(exist_filename);
+ if (filetype == eLoggerservicelogTypeAbnormal) {
+ abnrm_count++;
+ if (max_num <= abnrm_count) {
+ end_pos = i + 1;
+ break;
+ }
+ }
+ }
+ l_ePartStatus = removeFiles(log_path, l_vector, 0, end_pos);
+ if (l_ePartStatus != eFrameworkunifiedStatusOK) {
+ l_eStatus = l_ePartStatus;
+ }
+ if (end_pos < l_vector.size()) {
+ std::vector<std::string>::iterator itr = l_vector.begin() + end_pos;
+ l_ePartStatus = removeSameNumFiles(itr, log_path, l_vector);
+ if (l_ePartStatus != eFrameworkunifiedStatusOK) {
+ l_eStatus = l_ePartStatus;
+ }
+ }
+ SyncDir(log_path);
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return l_eStatus;
+}
+
+
+static EFrameworkunifiedStatus deleteOldEmmcLog(CfgInfo& f_cfginfo, // NOLINT (runtime/references)
+ std::string& f_archive_destination, // NOLINT (runtime/references)
+ SS_STORELOGS_OPE_TYPE type) {
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
+ DIR *l_dirp = NULL;
+ struct dirent *l_direntp = NULL;
+ std::vector<std::string> vect_abnrm;
+ std::vector<std::string> vect_nrm;
+ std::vector<std::string> vect_rlnc;
+ std::string l_emmc_path = f_cfginfo.output_path;
+ EFrameworkunifiedStatus l_eStatus = eFrameworkunifiedStatusOK;
+
+ UI_32 abnrm_count = 0;
+
+ if (SS_STORELOGS_SYS_ILLEGAL == type) {
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return eFrameworkunifiedStatusOK;
+ }
+
+
+ l_dirp = opendir(l_emmc_path.c_str());
+ if (l_dirp != NULL) {
+ while ((l_direntp = readdir(l_dirp)) != NULL) {
+ std::string l_findFileName = l_direntp->d_name;
+
+// if ((std::string::npos != l_findFileName.find("_ILG_RESET.tar.gz"))
+// || (std::string::npos != l_findFileName.find("_ERR.tar.gz"))) {
+ if ((l_findFileName == ".") || (l_findFileName == "..")) {
+ continue;
+ } else if (std::string::npos != l_findFileName.find(SS_STORE_FILENAME_SYSILG_TERM)) {
+ vect_abnrm.push_back(l_findFileName);
+ } else if (std::string::npos != l_findFileName.find(SS_STORE_FILENAME__CWORD52__TERM)) {
+ vect_abnrm.push_back(l_findFileName);
+ } else if((std::string::npos != l_findFileName.find("_ILG_RESET.tar.gz")) ||
+ (std::string::npos != l_findFileName.find("_ERR.tar.gz"))) {
+
+ vect_abnrm.push_back(l_findFileName);
+
+ abnrm_count++;
+
+ } else if (std::string::npos
+ != l_findFileName.find("_GRP_RELAUNCH.tar.gz")) {
+ vect_rlnc.push_back(l_findFileName);
+ } else if (std::string::npos != l_findFileName.find(".tar.gz")) {
+ vect_nrm.push_back(l_findFileName);
+ }
+ }
+ closedir(l_dirp);
+ }
+
+ if (SS_STORELOGS_ILLEGAL == type) {
+ if ((UI_32) f_cfginfo.output_errmax <= vect_abnrm.size()) {
+ l_eStatus = deleteOldLog(l_emmc_path, vect_abnrm, f_archive_destination,
+ (UI_32) f_cfginfo.output_errmax);
+ }
+ } else {
+ if ((UI_32) f_cfginfo.output_max <= vect_nrm.size()) {
+ l_eStatus = deleteOldLog(l_emmc_path, vect_nrm, f_archive_destination,
+ (UI_32) f_cfginfo.output_max);
+ }
+ }
+ FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
+ return l_eStatus;
+}
Code Review / staging / basesystem.git / blobdiff