dlt_filetransfer.c

Go to the documentation of this file.

/*
 * @licence app begin@
 * SPDX license identifier: MPL-2.0
 *
 * Copyright (C) 2011-2015, BMW AG
 *
 * This file is part of GENIVI Project DLT - Diagnostic Log and Trace.
 *
 * This Source Code Form is subject to the terms of the
 * Mozilla Public License (MPL), v. 2.0.
 * If a copy of the MPL was not distributed with this file,
 * You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * For further information see http://www.genivi.org/.
 * @licence end@
 */

/*******************************************************************************
**                                                                            **
**  SRC-MODULE: dlt-test-client.c                                             **
**                                                                            **
**  TARGET    : linux                                                         **
**                                                                            **
**  PROJECT   : DLT                                                           **
**                                                                            **
**  AUTHOR    : Alexander Wenzel Alexander.AW.Wenzel@bmw.de                   **
**                                                                            **
**  PURPOSE   :                                                               **
**                                                                            **
**  REMARKS   :                                                               **
**                                                                            **
**  PLATFORM DEPENDANT [yes/no]: yes                                          **
**                                                                            **
**  TO BE CHANGED BY USER [yes/no]: no                                        **
**                                                                            **
*******************************************************************************/

/*******************************************************************************
**                      Author Identity                                       **
********************************************************************************
**                                                                            **
** Initials     Name                       Company                            **
** --------     -------------------------  ---------------------------------- **
**  aw          Alexander Wenzel           BMW                                **
*******************************************************************************/

#include <errno.h>
#include <stdio.h>
#include <string.h>
#include "dlt_filetransfer.h"
#include "dlt_common.h"

#define BUFFER_SIZE 1024

#define MIN_TIMEOUT 20


#define DLT_FILETRANSFER_TRANSFER_ALL_PACKAGES INT_MAX


unsigned char buffer[BUFFER_SIZE];



uint32_t getFilesize(const char* file, int *ok){
    struct stat st;

    if ( -1 == stat(file, &st))
    {
        //we can only return 0, as the value is unsigned
        *ok = 0;
        return 0;
    }
    *ok = 1;
    return (uint32_t)st.st_size;
}

void stringHash(const char* str, uint32_t *hash )
{
    if (!str || !hash)
        return;
   unsigned int len = strlen(str);

   unsigned int i = 0;
   if (len <= 0){
    return;
   }

   for(i = 0; i < len;  i++)
   {
      *hash = 53 * *hash  + str[i];
   }

}



uint32_t getFileSerialNumber(const char* file, int *ok){
    struct stat st;
    uint32_t ret;
    if ( -1 == stat(file, &st))
    {
        *ok = 0;
        ret = 0;
    }
    else
    {
        *ok = 1;
        ret = st.st_ino;
        ret = ret << (sizeof(ret)*8)/2;
        ret |= st.st_size;
        ret ^= st.st_ctime;
        stringHash(file, &ret);
    }
    return ret;
}


time_t getFileCreationDate(const char* file,int *ok){
    struct stat st;
    if (-1 == stat(file, &st))
    {
        *ok = 0;
        return 0;
    }
    *ok = 1;
    return st.st_ctime;
}


char* getFileCreationDate2(const char* file,int *ok){
    struct stat st;
    if (-1 == stat(file, &st))
    {
        *ok = 0;
        return 0;
    }
    *ok = 1;
    struct tm  *ts= localtime(&st.st_ctime);
    return asctime(ts);
}


int isFile (const char* file)
{
    struct stat   st;
    return (stat (file, &st) == 0);
}


void doTimeout(int timeout)
{
    usleep(timeout * 1000);
}


int checkUserBufferForFreeSpace()
{
    int total_size, used_size;

    dlt_user_check_buffer(&total_size, &used_size);

    if((total_size - used_size) < (total_size/2))
    {
        return -1;
    }
    return 1;
}


int doRemoveFile(const char*filename){
    return remove( filename);
}

void dlt_user_log_file_errorMessage(DltContext *fileContext, const char *filename, int errorCode){

    if(errno != ENOENT)
    {
        int ok = 0;
        uint32_t fserial = getFileSerialNumber(filename,&ok);
        if (!ok)
            DLT_LOG(*fileContext,DLT_LOG_ERROR,DLT_STRING("dlt_user_log_file_errorMessage, error in getFileSerialNumber for: "),DLT_STRING(filename));
        uint32_t fsize = getFilesize(filename,&ok);
        if (!ok)
            DLT_LOG(*fileContext,DLT_LOG_ERROR,DLT_STRING("dlt_user_log_file_errorMessage, error in getFilesize for: "),DLT_STRING(filename));
        char *fcreationdate = getFileCreationDate2(filename,&ok);
        if (!ok)
            DLT_LOG(*fileContext,DLT_LOG_ERROR,DLT_STRING("dlt_user_log_file_errorMessage, error in getFilesize for: "),DLT_STRING(filename));

        int package_count = dlt_user_log_file_packagesCount(fileContext,filename);

        DLT_LOG(*fileContext,DLT_LOG_ERROR,
            DLT_STRING("FLER"),
            DLT_INT(errorCode),
            DLT_INT(-errno),
            DLT_UINT(fserial),
            DLT_STRING(filename),
            DLT_UINT(fsize),
            DLT_STRING(fcreationdate),
            DLT_INT(package_count),
            DLT_UINT(BUFFER_SIZE),
            DLT_STRING("FLER")
        );
    } else {
        DLT_LOG(*fileContext,DLT_LOG_ERROR,
            DLT_STRING("FLER"),
            DLT_INT(errorCode),
            DLT_INT(-errno),
            DLT_STRING(filename),
            DLT_STRING("FLER")
        );
    }
}




int dlt_user_log_file_infoAbout(DltContext *fileContext, const char *filename){

    if(isFile(filename))
    {
        int ok;

        uint32_t fsize = getFilesize(filename,&ok);
        if (!ok)
            DLT_LOG(*fileContext,DLT_LOG_ERROR,DLT_STRING("dlt_user_log_file_infoAbout, Error getting size of file:"),DLT_STRING(filename));

        uint32_t fserialnumber = getFileSerialNumber(filename,&ok);
        if (!ok)
            DLT_LOG(*fileContext,DLT_LOG_ERROR,DLT_STRING("dlt_user_log_file_infoAbout, Error getting serial number of file:"),DLT_STRING(filename));


        char *creationdate = getFileCreationDate2(filename,&ok);
        if (!ok)
            DLT_LOG(*fileContext,DLT_LOG_ERROR,DLT_STRING("dlt_user_log_file_infoAbout, Error getting creation date of file:"),DLT_STRING(filename));

        DLT_LOG(*fileContext,DLT_LOG_INFO,
            DLT_STRING("FLIF"),
            DLT_STRING("file serialnumber"),DLT_UINT(fserialnumber),
            DLT_STRING("filename"),DLT_STRING(filename),
            DLT_STRING("file size in bytes"),DLT_UINT(fsize),
            DLT_STRING("file creation date"),DLT_STRING(creationdate),
            DLT_STRING("number of packages"),DLT_UINT(dlt_user_log_file_packagesCount(fileContext, filename)),
            DLT_STRING("FLIF")
        );
        return 0;
    } else {
        dlt_user_log_file_errorMessage(fileContext,filename,DLT_FILETRANSFER_ERROR_INFO_ABOUT);
        return DLT_FILETRANSFER_ERROR_INFO_ABOUT;
    }
}


int dlt_user_log_file_complete(DltContext *fileContext, const char *filename, int deleteFlag, int timeout)
{
    if(!isFile(filename))
    {
        dlt_user_log_file_errorMessage(fileContext,filename, DLT_FILETRANSFER_ERROR_FILE_COMPLETE);
        return DLT_FILETRANSFER_ERROR_FILE_COMPLETE;
    }

    if(dlt_user_log_file_header(fileContext,filename) != 0)
    {
        return DLT_FILETRANSFER_ERROR_FILE_COMPLETE1;
    }

    if(dlt_user_log_file_data(fileContext, filename,DLT_FILETRANSFER_TRANSFER_ALL_PACKAGES,timeout) != 0)
    {
        return DLT_FILETRANSFER_ERROR_FILE_COMPLETE2;
    }

    if(dlt_user_log_file_end(fileContext,filename, deleteFlag) != 0)
    {
        return DLT_FILETRANSFER_ERROR_FILE_COMPLETE3;
    }

    return 0;
}


int dlt_user_log_file_packagesCount(DltContext *fileContext, const char *filename){
    int packages;
    uint32_t filesize;

    if(isFile(filename))
    {
        packages = 1;
        int ok;
        filesize = getFilesize(filename,&ok);
        if (!ok){
            DLT_LOG(*fileContext,DLT_LOG_ERROR,DLT_STRING("Error in: dlt_user_log_file_packagesCount, isFile"),DLT_STRING(filename),DLT_INT(DLT_FILETRANSFER_ERROR_PACKAGE_COUNT));
            return -1;
        }
        if(filesize < BUFFER_SIZE)
        {
            return packages;
        }
        else
        {
            packages = filesize/BUFFER_SIZE;

            if(filesize%BUFFER_SIZE == 0)
            {
                return packages;
            }
            else
            {
                return packages+1;
            }
        }
    } else {
        DLT_LOG(*fileContext,DLT_LOG_ERROR,DLT_STRING("Error in: dlt_user_log_file_packagesCount, !isFile"),DLT_STRING(filename),DLT_INT(DLT_FILETRANSFER_ERROR_PACKAGE_COUNT));
        return -1;
    }
}


int dlt_user_log_file_header_alias(DltContext *fileContext,const char *filename, const char *alias){

    if(isFile(filename))
    {
        int ok;

        uint32_t fserialnumber = getFileSerialNumber(filename,&ok);
        if (!ok)
            DLT_LOG(*fileContext,DLT_LOG_ERROR,DLT_STRING("dlt_user_log_file_header_alias, Error getting serial number of file:"),DLT_STRING(filename));

        uint32_t fsize = getFilesize(filename,&ok);
        if (!ok)
            DLT_LOG(*fileContext,DLT_LOG_ERROR,DLT_STRING("dlt_user_log_file_header_alias, Error getting size of file:"),DLT_STRING(filename));

        char *fcreationdate = getFileCreationDate2(filename,&ok);
        if (!ok)
            DLT_LOG(*fileContext,DLT_LOG_ERROR,DLT_STRING("dlt_user_log_file_header_alias, Error getting creation date of file:"),DLT_STRING(filename));



        DLT_LOG(*fileContext,DLT_LOG_INFO,
                DLT_STRING("FLST"),
                DLT_UINT(fserialnumber),
                DLT_STRING(alias),
                DLT_UINT(fsize),
                DLT_STRING(fcreationdate);
                DLT_UINT(dlt_user_log_file_packagesCount(fileContext,filename)),
                DLT_UINT(BUFFER_SIZE),
                DLT_STRING("FLST")
                );

        return 0;
    }
    else
    {
        dlt_user_log_file_errorMessage(fileContext,filename, DLT_FILETRANSFER_ERROR_FILE_HEAD);
        return DLT_FILETRANSFER_ERROR_FILE_HEAD;
    }
}


int dlt_user_log_file_header(DltContext *fileContext,const char *filename){

    if(isFile(filename))
    {
        int ok;

        uint32_t fserialnumber = getFileSerialNumber(filename,&ok);
        if (!ok)
            DLT_LOG(*fileContext,DLT_LOG_ERROR,DLT_STRING("dlt_user_log_file_header, Error getting serial number of file:"),DLT_STRING(filename));

        uint32_t fsize = getFilesize(filename,&ok);
        if (!ok)
            DLT_LOG(*fileContext,DLT_LOG_ERROR,DLT_STRING("dlt_user_log_file_header, Error getting size of file:"),DLT_STRING(filename));

        char *fcreationdate = getFileCreationDate2(filename,&ok);
        if (!ok)
            DLT_LOG(*fileContext,DLT_LOG_ERROR,DLT_STRING("dlt_user_log_file_header, Error getting creation date of file:"),DLT_STRING(filename));




        DLT_LOG(*fileContext,DLT_LOG_INFO,
                    DLT_STRING("FLST"),
                    DLT_UINT(fserialnumber),
                    DLT_STRING(filename),
                    DLT_UINT(fsize),
                    DLT_STRING(fcreationdate);
                    DLT_UINT(dlt_user_log_file_packagesCount(fileContext,filename)),
                    DLT_UINT(BUFFER_SIZE),
                    DLT_STRING("FLST")
                );

        return 0;
    }
    else
    {
        dlt_user_log_file_errorMessage(fileContext,filename, DLT_FILETRANSFER_ERROR_FILE_HEAD);
        return DLT_FILETRANSFER_ERROR_FILE_HEAD;
    }
}


int dlt_user_log_file_data(DltContext *fileContext,const char *filename, int packageToTransfer, int timeout){
    FILE *file;
    int pkgNumber;
    uint32_t readBytes;

    if(isFile(filename))
    {

        file = fopen (filename,"rb");
        if (file == NULL)
        {
            dlt_user_log_file_errorMessage(fileContext,filename,DLT_FILETRANSFER_ERROR_FILE_DATA);
            return DLT_FILETRANSFER_ERROR_FILE_DATA;
        }

        if( (packageToTransfer != DLT_FILETRANSFER_TRANSFER_ALL_PACKAGES && packageToTransfer > dlt_user_log_file_packagesCount(fileContext,filename)) || packageToTransfer <= 0)
        {
            DLT_LOG(*fileContext,DLT_LOG_ERROR,
                DLT_STRING("Error at dlt_user_log_file_data: packageToTransfer out of scope"),
                DLT_STRING("packageToTransfer:"),
                DLT_UINT(packageToTransfer),
                DLT_STRING("numberOfMaximalPackages:"),
                DLT_UINT(dlt_user_log_file_packagesCount(fileContext,filename)),
                DLT_STRING("for File:"),
                DLT_STRING(filename)
            );
            fclose(file);
            return DLT_FILETRANSFER_ERROR_FILE_DATA;
        }

        readBytes = 0;

        if(packageToTransfer != DLT_FILETRANSFER_TRANSFER_ALL_PACKAGES)
        {
//                If a single package should be transferred. The user has to check that the free space in the user buffer > 50%
//                if(checkUserBufferForFreeSpace()<0)
//                    return DLT_FILETRANSFER_ERROR_FILE_DATA_USER_BUFFER_FAILED;

                if ( 0 != fseek ( file , (packageToTransfer-1)*BUFFER_SIZE , SEEK_SET ) )
                {
                        DLT_LOG(*fileContext,DLT_LOG_ERROR,
                        DLT_STRING("failed to fseek in file: "),
                        DLT_STRING(filename),
                        DLT_STRING("ferror:"),
                        DLT_INT(ferror(file))
                    );

                    fclose (file);
                    return -1;

                }
                readBytes = fread(buffer, sizeof(char), BUFFER_SIZE, file);
                int ok;

                uint32_t fserial = getFileSerialNumber(filename,&ok);

                if (1 != ok)
                {
                    DLT_LOG(*fileContext,DLT_LOG_ERROR,
                    DLT_STRING("failed to get FileSerialNumber for: "),
                    DLT_STRING(filename));
                }

                DLT_LOG(*fileContext,DLT_LOG_INFO,
                DLT_STRING("FLDA"),
                DLT_UINT(fserial),
                DLT_UINT(packageToTransfer),
                DLT_RAW(buffer,readBytes),
                DLT_STRING("FLDA")
                );

                doTimeout(timeout);

        } else {
            pkgNumber = 0;
            while( !feof( file ) )
            {
//                If the complete file should be transferred, the user buffer will be checked.
//                If free space < 50% the package won't be transferred.
                if(checkUserBufferForFreeSpace()>0)
                {
                    pkgNumber++;
                    readBytes = fread(buffer, sizeof(char), BUFFER_SIZE, file);
                    int ok;

                    uint32_t fserial = getFileSerialNumber(filename,&ok);

                    if (1 != ok)
                    {
                        DLT_LOG(*fileContext,DLT_LOG_ERROR,
                        DLT_STRING("failed to get FileSerialNumber for: "),
                        DLT_STRING(filename));
                    }

                    DLT_LOG(*fileContext,DLT_LOG_INFO,
                            DLT_STRING("FLDA"),
                            DLT_UINT(fserial),
                            DLT_UINT(pkgNumber),
                            DLT_RAW(buffer,readBytes),
                            DLT_STRING("FLDA")
                    );
                }
                doTimeout(timeout);
            }
        }

        fclose(file);

        return 0;

    } else {
        dlt_user_log_file_errorMessage(fileContext,filename,DLT_FILETRANSFER_ERROR_FILE_DATA);
        return DLT_FILETRANSFER_ERROR_FILE_DATA;
    }

}

int dlt_user_log_file_end(DltContext *fileContext,const char *filename,int deleteFlag){

    if(isFile(filename))
    {

        int ok;
        uint32_t fserial = getFileSerialNumber(filename,&ok);

        if (1 != ok)
        {
            DLT_LOG(*fileContext,DLT_LOG_ERROR,
            DLT_STRING("failed to get FileSerialNumber for: "),
            DLT_STRING(filename));
        }

        DLT_LOG(*fileContext,DLT_LOG_INFO,
                DLT_STRING("FLFI"),
                DLT_UINT(fserial),
                DLT_STRING("FLFI")
        );

        if(deleteFlag){
                if( doRemoveFile(filename) != 0 ){
                    dlt_user_log_file_errorMessage(fileContext,filename,DLT_FILETRANSFER_ERROR_FILE_END);
                    return -1;
                }
        }

        return 0;
    }else{
        dlt_user_log_file_errorMessage(fileContext,filename,DLT_FILETRANSFER_ERROR_FILE_END);
        return DLT_FILETRANSFER_ERROR_FILE_END;
    }
}