dlt_common.h

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_common.h                                                  **
**                                                                            **
**  TARGET    : linux                                                         **
**                                                                            **
**  PROJECT   : DLT                                                           **
**                                                                            **
**  AUTHOR    : Alexander Wenzel Alexander.AW.Wenzel@bmw.de                   **
**              Markus Klein                                                  **
**                                                                            **
**  PURPOSE   :                                                               **
**                                                                            **
**  REMARKS   :                                                               **
**                                                                            **
**  PLATFORM DEPENDANT [yes/no]: yes                                          **
**                                                                            **
**  TO BE CHANGED BY USER [yes/no]: no                                        **
**                                                                            **
*******************************************************************************/

/*******************************************************************************
**                      Author Identity                                       **
********************************************************************************
**                                                                            **
** Initials     Name                       Company                            **
** --------     -------------------------  ---------------------------------- **
**  aw          Alexander Wenzel           BMW                                **
**  mk          Markus Klein               Fraunhofer ESK                     **
*******************************************************************************/

/*******************************************************************************
**                      Revision Control History                              **
*******************************************************************************/

/*
 * $LastChangedRevision: 1670 $
 * $LastChangedDate: 2011-04-08 15:12:06 +0200 (Fr, 08. Apr 2011) $
 * $LastChangedBy$
 Initials    Date         Comment
 aw          13.01.2010   initial
 */
#ifndef DLT_COMMON_H
#define DLT_COMMON_H

#include <stdio.h>
#include <linux/limits.h>

#if !defined(_MSC_VER)
#include <unistd.h>
#include <time.h>
#endif

#if !defined (__WIN32__) && !defined(_MSC_VER)
#include <termios.h>
#endif

#include "dlt_types.h"
#include "dlt_protocol.h"

#if !defined (PACKED)
#define PACKED __attribute__((aligned(1),packed))
#endif

#if defined (__MSDOS__) || defined (_MSC_VER)
/* set instead /Zp8 flag in Visual C++ configuration */
#undef PACKED
#define PACKED
#endif

/*
 * Macros to swap the byte order.
 */
#define DLT_SWAP_64(value) ((((uint64_t)DLT_SWAP_32((value)&0xffffffffull))<<32) | (DLT_SWAP_32((value)>>32)))

#define DLT_SWAP_16(value) ((((value) >> 8)&0xff) | (((value) << 8)&0xff00))
#define DLT_SWAP_32(value) ((((value) >> 24)&0xff) | (((value) << 8)&0xff0000) | (((value) >> 8)&0xff00) | (((value) << 24)&0xff000000))

/* Set Big Endian and Little Endian to a initial value, if not defined */
#if !defined __USE_BSD
#ifndef LITTLE_ENDIAN
#define LITTLE_ENDIAN 1234
#endif

#ifndef BIG_ENDIAN
#define BIG_ENDIAN    4321
#endif
#endif /* __USE_BSD */

/* If byte order is not defined, default to little endian */
#if !defined __USE_BSD
#ifndef BYTE_ORDER
#define BYTE_ORDER LITTLE_ENDIAN
#endif
#endif /* __USE_BSD */

/* Check for byte-order */
#if (BYTE_ORDER==BIG_ENDIAN)
/* #warning "Big Endian Architecture!" */
#define DLT_HTOBE_16(x) ((x))
#define DLT_HTOLE_16(x) DLT_SWAP_16((x))
#define DLT_BETOH_16(x) ((x))
#define DLT_LETOH_16(x) DLT_SWAP_16((x))

#define DLT_HTOBE_32(x) ((x))
#define DLT_HTOLE_32(x) DLT_SWAP_32((x))
#define DLT_BETOH_32(x) ((x))
#define DLT_LETOH_32(x) DLT_SWAP_32((x))

#define DLT_HTOBE_64(x) ((x))
#define DLT_HTOLE_64(x) DLT_SWAP_64((x))
#define DLT_BETOH_64(x) ((x))
#define DLT_LETOH_64(x) DLT_SWAP_64((x))
#else
/* #warning "Litte Endian Architecture!" */
#define DLT_HTOBE_16(x) DLT_SWAP_16((x))
#define DLT_HTOLE_16(x) ((x))
#define DLT_BETOH_16(x) DLT_SWAP_16((x))
#define DLT_LETOH_16(x) ((x))

#define DLT_HTOBE_32(x) DLT_SWAP_32((x))
#define DLT_HTOLE_32(x) ((x))
#define DLT_BETOH_32(x) DLT_SWAP_32((x))
#define DLT_LETOH_32(x) ((x))

#define DLT_HTOBE_64(x) DLT_SWAP_64((x))
#define DLT_HTOLE_64(x) ((x))
#define DLT_BETOH_64(x) DLT_SWAP_64((x))
#define DLT_LETOH_64(x) ((x))
#endif

#define DLT_ENDIAN_GET_16(htyp,x) ((((htyp) & DLT_HTYP_MSBF)>0)?DLT_BETOH_16(x):DLT_LETOH_16(x))
#define DLT_ENDIAN_GET_32(htyp,x) ((((htyp) & DLT_HTYP_MSBF)>0)?DLT_BETOH_32(x):DLT_LETOH_32(x))
#define DLT_ENDIAN_GET_64(htyp,x) ((((htyp) & DLT_HTYP_MSBF)>0)?DLT_BETOH_64(x):DLT_LETOH_64(x))

#if defined (__WIN32__) || defined (_MSC_VER)
#define LOG_EMERG     0
#define LOG_ALERT     1
#define LOG_CRIT      2
#define LOG_ERR       3
#define LOG_WARNING   4
#define LOG_NOTICE    5
#define LOG_INFO      6
#define LOG_DEBUG     7

#define LOG_PID     0x01
#define LOG_DAEMON  (3<<3)
#endif

enum {
    DLT_LOG_TO_CONSOLE=0,
    DLT_LOG_TO_SYSLOG=1,
    DLT_LOG_TO_FILE=2,
    DLT_LOG_DROPPED=3
};

#define DLT_DAEMON_TCP_PORT 3490


/* Initial value for file descriptor */
#define DLT_FD_INIT -1

/* Minimum value for a file descriptor except the POSIX Standards: stdin=0, stdout=1, stderr=2 */
#define DLT_FD_MINIMUM 3

#define DLT_ID_SIZE 4

#define DLT_SIZE_WEID DLT_ID_SIZE
#define DLT_SIZE_WSID (sizeof(uint32_t))
#define DLT_SIZE_WTMS (sizeof(uint32_t))

#define DLT_STANDARD_HEADER_EXTRA_SIZE(htyp) ( (DLT_IS_HTYP_WEID(htyp) ? DLT_SIZE_WEID : 0) + (DLT_IS_HTYP_WSID(htyp) ? DLT_SIZE_WSID : 0) + (DLT_IS_HTYP_WTMS(htyp) ? DLT_SIZE_WTMS : 0) )


#if defined (__MSDOS__) || defined (_MSC_VER)
#define __func__ __FUNCTION__
#endif

#define PRINT_FUNCTION_VERBOSE(_verbose)  \
{ \
    static char _strbuf[255]; \
    \
    if(_verbose) \
    { \
        snprintf(_strbuf, 255, "%s()\n",__func__); \
        dlt_log(LOG_INFO, _strbuf); \
    } \
}

#ifndef NULL
#define NULL (char*)0
#endif

#define DLT_MSG_IS_CONTROL(MSG)          ((DLT_IS_HTYP_UEH((MSG)->standardheader->htyp)) && \
        (DLT_GET_MSIN_MSTP((MSG)->extendedheader->msin)==DLT_TYPE_CONTROL))

#define DLT_MSG_IS_CONTROL_REQUEST(MSG)  ((DLT_IS_HTYP_UEH((MSG)->standardheader->htyp)) && \
        (DLT_GET_MSIN_MSTP((MSG)->extendedheader->msin)==DLT_TYPE_CONTROL) && \
        (DLT_GET_MSIN_MTIN((MSG)->extendedheader->msin)==DLT_CONTROL_REQUEST))

#define DLT_MSG_IS_CONTROL_RESPONSE(MSG) ((DLT_IS_HTYP_UEH((MSG)->standardheader->htyp)) && \
        (DLT_GET_MSIN_MSTP((MSG)->extendedheader->msin)==DLT_TYPE_CONTROL) && \
        (DLT_GET_MSIN_MTIN((MSG)->extendedheader->msin)==DLT_CONTROL_RESPONSE))

#define DLT_MSG_IS_CONTROL_TIME(MSG)     ((DLT_IS_HTYP_UEH((MSG)->standardheader->htyp)) && \
        (DLT_GET_MSIN_MSTP((MSG)->extendedheader->msin)==DLT_TYPE_CONTROL) && \
        (DLT_GET_MSIN_MTIN((MSG)->extendedheader->msin)==DLT_CONTROL_TIME))

#define DLT_MSG_IS_NW_TRACE(MSG)         ((DLT_IS_HTYP_UEH((MSG)->standardheader->htyp)) && \
        (DLT_GET_MSIN_MSTP((MSG)->extendedheader->msin)==DLT_TYPE_NW_TRACE))

#define DLT_MSG_IS_TRACE_MOST(MSG)       ((DLT_IS_HTYP_UEH((MSG)->standardheader->htyp)) && \
        (DLT_GET_MSIN_MSTP((MSG)->extendedheader->msin)==DLT_TYPE_NW_TRACE) && \
        (DLT_GET_MSIN_MTIN((MSG)->extendedheader->msin)==DLT_NW_TRACE_MOST))

#define DLT_MSG_IS_NONVERBOSE(MSG)       (!(DLT_IS_HTYP_UEH((MSG)->standardheader->htyp)) || \
        ((DLT_IS_HTYP_UEH((MSG)->standardheader->htyp)) && (!(DLT_IS_MSIN_VERB((MSG)->extendedheader->msin)))))

/*

 * Definitions of DLT message buffer overflow
 */
#define DLT_MESSAGE_BUFFER_NO_OVERFLOW     0x00 
#define DLT_MESSAGE_BUFFER_OVERFLOW        0x01 
/*
 * Definition of DLT output variants
 */
#define DLT_OUTPUT_HEX              1
#define DLT_OUTPUT_ASCII            2
#define DLT_OUTPUT_MIXED_FOR_PLAIN  3
#define DLT_OUTPUT_MIXED_FOR_HTML   4
#define DLT_OUTPUT_ASCII_LIMITED    5

#define DLT_FILTER_MAX 30 
#define DLT_MSG_READ_VALUE(dst,src,length,type) \
{ \
    if((length<0) || ((length)<((int32_t)sizeof(type)))) \
    { length = -1; } \
    else \
    { dst = *((type*)src);src+=sizeof(type);length-=sizeof(type); } \
}

#define DLT_MSG_READ_ID(dst,src,length) \
{ \
    if((length<0) || ((length)<DLT_ID_SIZE)) \
    { length = -1; } \
    else \
    { memcpy(dst,src,DLT_ID_SIZE);src+=DLT_ID_SIZE;length-=DLT_ID_SIZE; } \
}

#define DLT_MSG_READ_STRING(dst,src,maxlength,length) \
{ \
    if(((maxlength)<0) || ((length)<0) || ((maxlength)<(length))) \
    { maxlength = -1; } \
    else \
    { memcpy(dst,src,length);dlt_clean_string(dst,length);dst[length]=0; \
        src+=length;maxlength-=length; } \
}

#define DLT_MSG_READ_NULL(src,maxlength,length) \
{ \
    if(((maxlength)<0) || ((length)<0) || ((maxlength)<(length))) \
    { length = -1; } \
    else \
    { src+=length;maxlength-=length; } \
}

#define DLT_HEADER_SHOW_NONE       0x0000
#define DLT_HEADER_SHOW_TIME       0x0001
#define DLT_HEADER_SHOW_TMSTP      0x0002
#define DLT_HEADER_SHOW_MSGCNT     0x0004
#define DLT_HEADER_SHOW_ECUID      0x0008
#define DLT_HEADER_SHOW_APID       0x0010
#define DLT_HEADER_SHOW_CTID       0x0020
#define DLT_HEADER_SHOW_MSGTYPE    0x0040
#define DLT_HEADER_SHOW_MSGSUBTYPE 0x0080
#define DLT_HEADER_SHOW_VNVSTATUS  0x0100
#define DLT_HEADER_SHOW_NOARG      0x0200
#define DLT_HEADER_SHOW_ALL        0xFFFF

/* dlt_receiver_check_and_get flags */
#define DLT_RCV_NONE        0
#define DLT_RCV_SKIP_HEADER (1 << 0)
#define DLT_RCV_REMOVE      (1 << 1)

#define DLT_MOUNT_PATH_MAX  1024

#define DLT_ENTRY_MAX 100

#ifndef DLT_UNIT_TESTS
#define STATIC static
#else
#define STATIC
#endif

extern const char dltSerialHeader[DLT_ID_SIZE];

extern char dltSerialHeaderChar[DLT_ID_SIZE];

extern char dltFifoBaseDir[PATH_MAX + 1];

typedef char ID4[DLT_ID_SIZE];

typedef struct
{
    char pattern[DLT_ID_SIZE]; 
    uint32_t seconds;          
    int32_t microseconds;      
    char ecu[DLT_ID_SIZE];     
} PACKED DltStorageHeader;

typedef struct
{
    uint8_t htyp;           
    uint8_t mcnt;           
    uint16_t len;           
} PACKED DltStandardHeader;

typedef struct
{
    char ecu[DLT_ID_SIZE];       
    uint32_t seid;               
    uint32_t tmsp;               
} PACKED DltStandardHeaderExtra;

typedef struct
{
    uint8_t msin;              
    uint8_t noar;              
    char apid[DLT_ID_SIZE];    
    char ctid[DLT_ID_SIZE];    
} PACKED DltExtendedHeader;

typedef struct sDltMessage
{
    /* flags */
    int8_t found_serialheader;

    /* offsets */
    int32_t resync_offset;

    /* size parameters */
    int32_t headersize;    
    int32_t datasize;      
    /* buffer for current loaded message */
    uint8_t headerbuffer[sizeof(DltStorageHeader)+
        sizeof(DltStandardHeader)+sizeof(DltStandardHeaderExtra)+sizeof(DltExtendedHeader)]; 
    uint8_t *databuffer;         
    int32_t databuffersize;

    /* header values of current loaded message */
    DltStorageHeader       *storageheader;  
    DltStandardHeader      *standardheader; 
    DltStandardHeaderExtra headerextra;     
    DltExtendedHeader      *extendedheader; 
} DltMessage;

typedef struct
{
    uint32_t service_id;            
    uint8_t options;                
    char apid[DLT_ID_SIZE];         
    char ctid[DLT_ID_SIZE];         
    char com[DLT_ID_SIZE];          
} PACKED DltServiceGetLogInfoRequest;

typedef struct
{

    uint32_t service_id;            
    char apid[DLT_ID_SIZE];         
    char ctid[DLT_ID_SIZE];         
    uint8_t log_level;              
    char com[DLT_ID_SIZE];          
} PACKED DltServiceSetLogLevel;

typedef struct
{
    uint32_t service_id;                
    uint8_t log_level;                  
    char com[DLT_ID_SIZE];              
} PACKED DltServiceSetDefaultLogLevel;

typedef struct
{
    uint32_t service_id;            
    uint8_t new_status;             
} PACKED DltServiceSetVerboseMode;

typedef struct
{
    uint32_t service_id;            
    char com[DLT_ID_SIZE];          
    uint8_t new_status;             
} PACKED DltServiceSetCommunicationInterfaceStatus;

typedef struct
{
    uint32_t service_id;            
    char com[DLT_ID_SIZE];          
    uint32_t max_bandwidth;         
} PACKED DltServiceSetCommunicationMaximumBandwidth;

typedef struct
{
    uint32_t service_id;            
    uint8_t status;                 
} PACKED DltServiceResponse;

typedef struct
{
    uint32_t service_id;            
    uint8_t status;                 
    uint8_t log_level;              
} PACKED DltServiceGetDefaultLogLevelResponse;

typedef struct
{
    uint32_t service_id;            
    uint8_t status;                 
    uint8_t overflow;               
    uint32_t overflow_counter;      
} PACKED DltServiceMessageBufferOverflowResponse;

typedef struct
{
    uint32_t service_id;            
} PACKED DltServiceGetSoftwareVersion;

typedef struct
{
    uint32_t service_id;            
    uint8_t  status;                
    uint32_t length;                
    /*char [] payload;*/
} PACKED DltServiceGetSoftwareVersionResponse;

typedef struct
{
    uint32_t service_id;            
    uint8_t status;                 
    char apid[DLT_ID_SIZE];         
    char ctid[DLT_ID_SIZE];         
    char comid[DLT_ID_SIZE];        
} PACKED DltServiceUnregisterContext;

typedef struct
{
    uint32_t service_id;            
    uint8_t status;                 
    uint8_t state;                  
    char comid[DLT_ID_SIZE];        
} PACKED DltServiceConnectionInfo;

typedef struct
{
    uint32_t service_id;            
    uint8_t status;                 
    int32_t timezone;               
    uint8_t isdst;                  
} PACKED DltServiceTimezone;

typedef struct
{
    uint32_t service_id;            
    uint8_t status;                 
} PACKED DltServiceMarker;

/***
 * The structure of the DLT Service Offline Logstorage
 */
typedef struct
{
    uint32_t service_id;                  
    char mount_point[DLT_MOUNT_PATH_MAX]; 
    uint8_t connection_type;              
    char comid[DLT_ID_SIZE];              
} PACKED DltServiceOfflineLogstorage;

typedef struct
{
    uint32_t service_id;                      
    uint8_t status;                           
    char name[DLT_ENTRY_MAX];                 
    uint32_t level;                           
    uint32_t client_mask;                     
    uint32_t ctrl_mask;                       
    char injections[DLT_ENTRY_MAX];           
} PACKED DltServiceGetCurrentFilterInfo;

typedef struct
{
    uint32_t service_id;            
    uint32_t connection_status;     
    char node_id[DLT_ID_SIZE];      
} PACKED DltServicePassiveNodeConnect;

typedef struct
{
    uint32_t service_id;                       
    uint8_t status;                            
    uint32_t num_connections;                  
    uint8_t connection_status[DLT_ENTRY_MAX];  
    char node_id[DLT_ENTRY_MAX];               
} PACKED DltServicePassiveNodeConnectionInfo;

typedef struct
{
    char apid[DLT_FILTER_MAX][DLT_ID_SIZE]; 
    char ctid[DLT_FILTER_MAX][DLT_ID_SIZE]; 
    int  counter;                           
} DltFilter;

typedef struct sDltFile
{
    /* file handle and index for fast access */
    FILE *handle;      
    long *index;       
    /* size parameters */
    int32_t counter;       
    int32_t counter_total; 
    int32_t position;      
    long file_length;      
    long file_position;    
    /* error counters */
    int32_t error_messages; 
    /* filter parameters */
    DltFilter *filter;      
    int32_t filter_counter; 
    /* current loaded message */
    DltMessage msg;     
} DltFile;

typedef struct
{
    int32_t lastBytesRcvd;    
    int32_t bytesRcvd;        
    int32_t totalBytesRcvd;   
    char *buffer;         
    char *buf;            
    int fd;               
    int32_t buffersize;       
} DltReceiver;

typedef struct
{
    unsigned char* shm; /* pointer to beginning of shared memory */
    int        size;    /* size of data area in shared memory */
    unsigned char* mem; /* pointer to data area in shared memory */

    uint32_t    min_size;  
    uint32_t    max_size;  
    uint32_t    step_size; 
} DltBuffer;

typedef struct
{
    int write;
    int read;
    int count;
} DltBufferHead;

#define DLT_BUFFER_HEAD "SHM"

typedef struct
{
    char head[4];
    unsigned char status;
    int size;
} DltBufferBlockHead;

#define DLT_MESSAGE_ERROR_OK       0
#define DLT_MESSAGE_ERROR_UNKNOWN -1
#define DLT_MESSAGE_ERROR_SIZE    -2
#define DLT_MESSAGE_ERROR_CONTENT -3

#ifdef __cplusplus
extern "C"
{
#endif

    void dlt_print_hex(uint8_t *ptr,int size);
    DltReturnValue dlt_print_hex_string(char *text,int textlength,uint8_t *ptr,int size);
    DltReturnValue dlt_print_mixed_string(char *text,int textlength,uint8_t *ptr,int size,int html);
    DltReturnValue dlt_print_char_string(char **text,int textlength,uint8_t *ptr,int size);

    void dlt_print_id(char *text,const char *id);

    void dlt_set_id(char *id,const char *text);

    void dlt_clean_string(char *text,int length);

    DltReturnValue dlt_filter_init(DltFilter *filter,int verbose);
    DltReturnValue dlt_filter_free(DltFilter *filter,int verbose);
    DltReturnValue dlt_filter_load(DltFilter *filter,const char *filename,int verbose);
    DltReturnValue dlt_filter_save(DltFilter *filter,const char *filename,int verbose);
    int dlt_filter_find(DltFilter *filter,const char *apid,const char *ctid, int verbose);
    DltReturnValue dlt_filter_add(DltFilter *filter,const char *apid,const char *ctid,int verbose);
    DltReturnValue dlt_filter_delete(DltFilter *filter,const char *apid,const char *ctid,int verbose);

    DltReturnValue dlt_message_init(DltMessage *msg,int verbose);
    DltReturnValue dlt_message_free(DltMessage *msg,int verbose);
    DltReturnValue dlt_message_header(DltMessage *msg,char *text,int textlength,int verbose);
    DltReturnValue dlt_message_header_flags(DltMessage *msg,char *text,int textlength,int flags, int verbose);
    DltReturnValue dlt_message_payload(DltMessage *msg,char *text,int textlength,int type,int verbose);
    DltReturnValue dlt_message_filter_check(DltMessage *msg,DltFilter *filter,int verbose);

    int dlt_message_read(DltMessage *msg,uint8_t *buffer,unsigned int length,int resync,int verbose);

    DltReturnValue dlt_message_get_extraparameters(DltMessage *msg,int verbose);

    DltReturnValue dlt_message_set_extraparameters(DltMessage *msg,int verbose);

    DltReturnValue dlt_file_init(DltFile *file,int verbose);
    DltReturnValue dlt_file_set_filter(DltFile *file,DltFilter *filter,int verbose);
    DltReturnValue dlt_file_open(DltFile *file,const char *filename,int verbose);
    DltReturnValue dlt_file_read(DltFile *file,int verbose);
    DltReturnValue dlt_file_read_raw(DltFile *file,int resync,int verbose);
    DltReturnValue dlt_file_close(DltFile *file,int verbose);
    DltReturnValue dlt_file_read_header(DltFile *file,int verbose);
    DltReturnValue dlt_file_read_header_raw(DltFile *file,int resync,int verbose);
    DltReturnValue dlt_file_read_header_extended(DltFile *file, int verbose);
    DltReturnValue dlt_file_read_data(DltFile *file, int verbose);
    DltReturnValue dlt_file_message(DltFile *file,int index,int verbose);
    DltReturnValue dlt_file_free(DltFile *file,int verbose);

    void dlt_log_set_filename(const char *filename);
    void dlt_log_set_level(int level);
    void dlt_log_init(int mode);
    DltReturnValue dlt_log(int prio, char *s);
    DltReturnValue dlt_vlog(int prio, const char *format, ...);
    DltReturnValue dlt_vnlog(int prio, size_t size, const char *format, ...);
    void dlt_log_free(void);

    DltReturnValue dlt_receiver_init(DltReceiver *receiver,int _fd, int _buffersize);
    DltReturnValue dlt_receiver_free(DltReceiver *receiver);
    int dlt_receiver_receive_socket(DltReceiver *receiver);
    int dlt_receiver_receive_fd(DltReceiver *receiver);
    DltReturnValue dlt_receiver_remove(DltReceiver *receiver,int size);
    DltReturnValue dlt_receiver_move_to_begin(DltReceiver *receiver);

    int dlt_receiver_check_and_get(DltReceiver *receiver,
                                   void *dest,
                                   unsigned int to_get,
                                   unsigned int skip_header);

    DltReturnValue dlt_set_storageheader(DltStorageHeader *storageheader, const char *ecu);
    DltReturnValue dlt_check_storageheader(DltStorageHeader *storageheader);


    DltReturnValue dlt_buffer_init_static_server(DltBuffer *buf, const unsigned char *ptr, uint32_t size);

    DltReturnValue dlt_buffer_init_static_client(DltBuffer *buf, const unsigned char *ptr, uint32_t size);

    DltReturnValue dlt_buffer_init_dynamic(DltBuffer *buf, uint32_t min_size, uint32_t max_size,uint32_t step_size);

    DltReturnValue dlt_buffer_free_static(DltBuffer *buf);

    DltReturnValue dlt_buffer_free_dynamic(DltBuffer *buf);

    DltReturnValue dlt_buffer_push(DltBuffer *buf,const unsigned char *data,unsigned int size);

    DltReturnValue dlt_buffer_push3(DltBuffer *buf,const unsigned char *data1,unsigned int size1,const unsigned char *data2,unsigned int size2,const unsigned char *data3,unsigned int size3);

    int dlt_buffer_pull(DltBuffer *buf,unsigned char *data, int max_size);

    int dlt_buffer_copy(DltBuffer *buf,unsigned char *data, int max_size);

    int dlt_buffer_remove(DltBuffer *buf);

    void dlt_buffer_info(DltBuffer *buf);

    void dlt_buffer_status(DltBuffer *buf);

    uint32_t dlt_buffer_get_total_size(DltBuffer *buf);

    int dlt_buffer_get_used_size(DltBuffer *buf);

    int dlt_buffer_get_message_count(DltBuffer *buf);

#if !defined (__WIN32__)

    DltReturnValue dlt_setup_serial(int fd, speed_t speed);

    speed_t dlt_convert_serial_speed(int baudrate);

    void dlt_get_version(char *buf, size_t size);

    void dlt_get_major_version(char *buf, size_t size);

    void dlt_get_minor_version(char *buf, size_t size);

#endif

    /* Function prototypes which should be used only internally */
    /*                                                          */

    DltReturnValue dlt_init_common(void);

    uint32_t dlt_uptime(void);

    DltReturnValue dlt_message_print_header(DltMessage *message, char *text, uint32_t size, int verbose);

    DltReturnValue dlt_message_print_hex(DltMessage *message, char *text, uint32_t size, int verbose);

    DltReturnValue dlt_message_print_ascii(DltMessage *message, char *text, uint32_t size, int verbose);

    DltReturnValue dlt_message_print_mixed_plain(DltMessage *message, char *text, uint32_t size, int verbose);

    DltReturnValue dlt_message_print_mixed_html(DltMessage *message, char *text, uint32_t size, int verbose);

    DltReturnValue dlt_message_argument_print(DltMessage *msg,uint32_t type_info,uint8_t **ptr,int32_t *datalength,char *text,int textlength,int byteLength,int verbose);

    void dlt_check_envvar();

    int dlt_mkdir_recursive(const char *dir);

#ifdef __cplusplus
}
#endif

#endif /* DLT_COMMON_H */