offline trace: supported trace file name configuration based on index

Changes made for trace file name configuration based on index and
made it configurable from dlt.conf file. Using this configuration
one can select either timestamp based or index based log file creation
for offline trace.

Signed-off-by: Manikandan C <Manikandan.Chockalingam@in.bosch.com>

1 files changed, 164 insertions, 10 deletions

diff --git a/src/shared/dlt_offline_trace.c b/src/shared/dlt_offline_trace.c
index c4d3f6b..b2e5612 100644
--- a/src/shared/dlt_offline_trace.c
+++ b/src/shared/dlt_offline_trace.c
@@ -65,21 +65,175 @@
 
 #include <dlt_offline_trace.h>
 
+unsigned int dlt_offline_trace_storage_dir_info(char *path, char *file_name, char *newest, char *oldest)
+{
+    int i = 0;
+    unsigned int num = 0;
+    int cnt = 0;
+    struct dirent **files = {0};
+    char *tmp_old = NULL;
+    char *tmp_new = NULL;
+
+    if (path == NULL || file_name == NULL || newest == NULL || oldest == NULL)
+    {
+        printf("dlt_offline_trace_storage_dir_info: Invalid parameter(s)");
+        return 0;
+    }
+
+    cnt = scandir(path, &files, NULL, alphasort);
+
+    if (cnt < 0)
+    {
+        return 0;
+    }
+
+    for (i = 0; i < cnt; i++)
+    {
+        int len = 0;
+        len = strlen(file_name);
+        if ((strncmp(files[i]->d_name, file_name, len) == 0) && (files[i]->d_name[len] == '.'))
+        {
+            num++;
+
+            if (tmp_old == NULL || (strlen(tmp_old) >= strlen(files[i]->d_name)))
+            {
+                if (tmp_old == NULL)
+                {
+                    tmp_old = files[i]->d_name;
+                }
+                /* when file name is smaller, it is older */
+                else if (strlen(tmp_old) > strlen(files[i]->d_name))
+                {
+                    tmp_old = files[i]->d_name;
+                }
+                else /* filename is equal, do a string compare */
+                {
+                    if (strcmp(tmp_old, files[i]->d_name) > 0)
+                        tmp_old = files[i]->d_name;
+                }
+            }
+
+            if (tmp_new == NULL || (strlen(tmp_new) <= strlen(files[i]->d_name)))
+            {
+                if (tmp_new == NULL)
+                {
+                    tmp_new = files[i]->d_name;
+                }
+                /* when file name is longer, it is younger */
+                else if (strlen(tmp_new) < strlen(files[i]->d_name))
+                {
+                    tmp_new = files[i]->d_name;
+                }
+                else
+                {
+                    if (strcmp(tmp_new, files[i]->d_name) < 0)
+                    {
+                        tmp_new = files[i]->d_name;
+                    }
+                }
+            }
+        }
+    }
+
+    if (num > 0)
+    {
+        if (tmp_old != NULL)
+        {
+            if (strlen(tmp_old) < DLT_OFFLINETRACE_FILENAME_MAX_SIZE)
+            {
+                strncpy(oldest, tmp_old, DLT_OFFLINETRACE_FILENAME_MAX_SIZE);
+            }
+        }
+        if (tmp_new != NULL)
+        {
+            if (strlen(tmp_old) < DLT_OFFLINETRACE_FILENAME_MAX_SIZE)
+            {
+                strncpy(newest, tmp_new, DLT_OFFLINETRACE_FILENAME_MAX_SIZE);
+            }
+        }
+    }
+
+    /* free scandir result */
+    for (i = 0; i < cnt; i++)
+    {
+        free(files[i]);
+    }
+    free(files);
+
+    return num;
+}
+
+void dlt_offline_trace_file_name(char *log_file_name, char *name, unsigned int idx)
+{
+    char file_index[11]; // UINT_MAX = 4294967295 -> 10 digits
+    sprintf(file_index, "%010u", idx);
+
+    // create log file name
+    memset(log_file_name, 0, DLT_OFFLINETRACE_FILENAME_MAX_SIZE * sizeof(char));
+    strncat(log_file_name, name,sizeof(DLT_OFFLINETRACE_FILENAME_BASE));
+    strncat(log_file_name, DLT_OFFLINETRACE_FILENAME_DELI,sizeof(DLT_OFFLINETRACE_FILENAME_DELI));
+    strncat(log_file_name, file_index,sizeof(file_index));
+    strncat(log_file_name, DLT_OFFLINETRACE_FILENAME_EXT,sizeof(DLT_OFFLINETRACE_FILENAME_EXT));
+}
+
+unsigned int dlt_offline_trace_get_idx_of_log_file(char *file)
+{
+    const char d[2] = ".";
+    char *token;
+    unsigned int idx = 0;
+
+    if (file[0] == '\0')
+    {
+        return 0;
+    }
+
+    token = strtok(file, d);
+    /* we are interested in 2. token because of log file name */
+    token = strtok(NULL, d);
+
+    if (token != NULL)
+    {
+        idx = strtol(token, NULL, 10);
+    }
+    else
+    {
+        idx = 0;
+    }
+    return idx;
+}
+
+
 DltReturnValue dlt_offline_trace_create_new_file(DltOfflineTrace *trace) {
     time_t t;
     struct tm *tmp;
     char outstr[200];
+    char newest[DLT_OFFLINETRACE_FILENAME_MAX_SIZE] = {0};
+    char oldest[DLT_OFFLINETRACE_FILENAME_MAX_SIZE] = {0};
+    unsigned int idx = 0;
 
     /* set filename */
-    t = time(NULL);
-    tmp = localtime(&t);
-    if (NULL == tmp) {
-        printf("dlt_offline_trace_create_new_file: pointer to tmp is NULL!");
-        return DLT_RETURN_ERROR;
+    if(trace->filenameTimestampBased)
+    {
+        t = time(NULL);
+        tmp = localtime(&t);
+        if (NULL == tmp) {
+            printf("dlt_offline_trace_create_new_file: pointer to tmp is NULL!");
+            return DLT_RETURN_ERROR;
+        }
+        if (strftime(outstr, sizeof(outstr),"%Y%m%d_%H%M%S", tmp) == 0) {
+        }
+        snprintf(trace->filename, NAME_MAX + 1, "%s/dlt_offlinetrace_%s.dlt", trace->directory, outstr);
     }
-    if (strftime(outstr, sizeof(outstr),"%Y%m%d_%H%M%S", tmp) == 0) {
+    else
+    {
+        /* targeting newest file, ignoring number of files in dir returned */
+        dlt_offline_trace_storage_dir_info(trace->directory, DLT_OFFLINETRACE_FILENAME_BASE, newest, oldest);
+        idx = dlt_offline_trace_get_idx_of_log_file(newest) + 1;
+
+        dlt_offline_trace_file_name(outstr, DLT_OFFLINETRACE_FILENAME_BASE, idx);
+        snprintf(trace->filename, NAME_MAX + 1, "%s/%s", trace->directory, outstr);
     }
-    snprintf(trace->filename,NAME_MAX + 1,"%s/dlt_offlinetrace_%s.dlt",trace->directory,outstr);
+
 
     /* open DLT output file */
     trace->ohandle = open(trace->filename,O_WRONLY|O_CREAT, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH); /* mode: wb */
@@ -144,7 +298,7 @@ int dlt_offline_trace_delete_oldest_file(DltOfflineTrace *trace) {
     /* go through all dlt files in directory */
     DIR *dir = opendir(trace->directory);
     while ((dp=readdir(dir)) != NULL) {
-        if(strstr(dp->d_name,".dlt")) {
+        if(strstr(dp->d_name,DLT_OFFLINETRACE_FILENAME_TO_COMPARE)) {
             int res = snprintf(filename, sizeof(filename), "%s/%s",trace->directory,dp->d_name);
                 // if the total length of the string is greater than the buffer, silently forget it.
                 // snprintf: a return value of size  or more means that the output was truncated
@@ -197,14 +351,14 @@ DltReturnValue dlt_offline_trace_check_size(DltOfflineTrace *trace) {
     return DLT_RETURN_OK; /* OK */
 }
 
-DltReturnValue dlt_offline_trace_init(DltOfflineTrace *trace,const char *directory,int fileSize,int maxSize) {
+DltReturnValue dlt_offline_trace_init(DltOfflineTrace *trace,const char *directory,int fileSize,int maxSize,int filenameTimestampBased) {
 
     /* init parameters */
     strncpy(trace->directory,directory,NAME_MAX);
     trace->directory[NAME_MAX]=0;
     trace->fileSize = fileSize;
     trace->maxSize = maxSize;
-
+    trace->filenameTimestampBased = filenameTimestampBased;
     /* check complete offlien trace size, remove old logs if needed */
     dlt_offline_trace_check_size(trace);