src/shared/dlt_common.c

   1 /**
   2  * @licence app begin@
   3  * Copyright (C) 2012-2014  BMW AG
   4  *
   5  * This file is part of GENIVI Project Dlt - Diagnostic Log and Trace console apps.
   6  *
   7  * Contributions are licensed to the GENIVI Alliance under one or more
   8  * Contribution License Agreements.
   9  *
  10  * \copyright
  11  * This Source Code Form is subject to the terms of the
  12  * Mozilla Public License, v. 2.0. If a  copy of the MPL was not distributed with
  13  * this file, You can obtain one at http://mozilla.org/MPL/2.0/.
  14  *
  15  * \author
  16  * Alexander Wenzel <alexander.aw.wenzel@bmw.de>
  17  * Markus Klein <Markus.Klein@esk.fraunhofer.de>
  18  * Mikko Rapeli <mikko.rapeli@bmw.de>
  19  *
  20  * \file dlt_common.c
  21  * For further information see http://www.genivi.org/.
  22  * @licence end@
  23  */
  24
  25 #include <stdio.h>
  26 #include <stdlib.h> /* for malloc(), free() */
  27 #include <string.h> /* for strlen(), memcmp(), memmove() */
  28 #include <time.h>   /* for localtime(), strftime() */
  29 #include <limits.h> /* for NAME_MAX */
  30
  31 #include "dlt_common.h"
  32 #include "dlt_common_cfg.h"
  33
  34 #include "dlt_version.h"
  35
  36 #if defined (__WIN32__) || defined (_MSC_VER)
  37 #include <winsock2.h> /* for socket(), connect(), send(), and recv() */
  38 #else
  39 #include <sys/socket.h> /* for socket(), connect(), send(), and recv() */
  40 #include <syslog.h>
  41 #include <time.h> /* for clock_gettime() */
  42 #endif
  43
  44 #if defined (_MSC_VER)
  45 #include <io.h>
  46 #else
  47 #include <unistd.h>     /* for read(), close() */
  48 #include <sys/time.h>   /* for gettimeofday() */
  49 #endif
  50
  51 #if defined (__MSDOS__) || defined (_MSC_VER)
  52 #pragma warning(disable : 4996) /* Switch off C4996 warnings */
  53 #include <windows.h>
  54 #include <winbase.h>
  55 #endif
  56
  57 static char str[DLT_COMMON_BUFFER_LENGTH];
  58
  59 const char dltSerialHeader[DLT_ID_SIZE] = { 'D','L','S',1 };
  60 char dltSerialHeaderChar[DLT_ID_SIZE] = { 'D','L','S',1 };
  61
  62 /* internal logging parameters */
  63 static int logging_mode = DLT_LOG_TO_CONSOLE;
  64 static int logging_level = 6;
  65 static char logging_filename[NAME_MAX + 1] = "";
  66 static FILE *logging_handle = 0;
  67
  68 char *message_type[] = {"log","app_trace","nw_trace","control","","","",""};
  69 char *log_info[] = {"","fatal","error","warn","info","debug","verbose","","","","","","","","",""};
  70 char *trace_type[] = {"","variable","func_in","func_out","state","vfb","","","","","","","","","",""};
  71 char *nw_trace_type[] = {"","ipc","can","flexray","most","vfb","","","","","","","","","",""};
  72 char *control_type[] = {"","request","response","time","","","","","","","","","","","",""};
  73 static char *service_id[] = {"","set_log_level","set_trace_status","get_log_info","get_default_log_level","store_config","reset_to_factory_default",
  74                              "set_com_interface_status","set_com_interface_max_bandwidth","set_verbose_mode","set_message_filtering","set_timing_packets",
  75                              "get_local_time","use_ecu_id","use_session_id","use_timestamp","use_extended_header","set_default_log_level","set_default_trace_status",
  76                              "get_software_version","message_buffer_overflow"
  77                             };
  78 static char *return_type[] = {"ok","not_supported","error","","","","","","no_matching_context_id"};
  79
  80 /* internal function definitions */
  81 int dlt_buffer_get(DltBuffer *buf,unsigned char *data, int max_size,int delete);
  82 int dlt_buffer_reset(DltBuffer *buf);
  83 int dlt_buffer_increase_size(DltBuffer *buf);
  84 int dlt_buffer_minimize_size(DltBuffer *buf);
  85 void dlt_buffer_write_block(DltBuffer *buf,int *write, const unsigned char *data,unsigned int size);
  86 void dlt_buffer_read_block(DltBuffer *buf,int *read,unsigned char *data,unsigned int size);
  87
  88 void dlt_print_hex(uint8_t *ptr,int size)
  89 {
  90     int num;
  91
  92     if (ptr==0)
  93     {
  94         return;
  95     }
  96
  97     for (num=0;num<size;num++)
  98     {
  99         if (num>0)
 100         {
 101             printf(" ");
 102         }
 103
 104         printf("%.2x",((uint8_t*)ptr)[num]);
 105     }
 106 }
 107
 108 int dlt_print_hex_string(char *text,int textlength,uint8_t *ptr,int size)
 109 {
 110     int num;
 111
 112     if ((ptr==0) || (text==0) || (textlength<=0) || (size<0))
 113     {
 114         return -1;
 115     }
 116
 117     /* Length 3: AB_ , A is first digit of hex number, B is second digit of hex number, _ is space */
 118     if (textlength<(size*3))
 119     {
 120         dlt_log(LOG_ERR, "String does not fit binary data!\n");
 121         return -1;
 122     }
 123
 124     for (num=0;num<size;num++)
 125     {
 126         if (num>0)
 127         {
 128             snprintf(text,2," ");
 129             text++;
 130         }
 131
 132         snprintf(text,3,"%.2x",((uint8_t*)ptr)[num]);
 133         text+=2; /* 2 chars */
 134     }
 135
 136     return 0;
 137 }
 138
 139 int dlt_print_mixed_string(char *text,int textlength,uint8_t *ptr,int size,int html)
 140 {
 141     int required_size = 0;
 142     int lines, rest, i;
 143
 144     if ((ptr==0) || (text==0) || (textlength<=0) || (size<0))
 145     {
 146         return -1;
 147     }
 148
 149     /* Check maximum required size and do a length check */
 150     if (html==0)
 151     {
 152         required_size=(DLT_COMMON_HEX_LINELEN+(2*DLT_COMMON_HEX_CHARS+(DLT_COMMON_HEX_CHARS-1))+DLT_COMMON_CHARLEN+DLT_COMMON_HEX_CHARS+DLT_COMMON_CHARLEN) *
 153                       ((size/DLT_COMMON_HEX_CHARS) + 1);
 154         /* Example: (8 chars line number + (2*16 chars + 15 spaces) + space + 16 ascii chars + CR) *
 155            ((size/16) lines + extra line for the rest) */
 156     }
 157     else
 158     {
 159         required_size=(DLT_COMMON_HEX_LINELEN+(2*DLT_COMMON_HEX_CHARS+(DLT_COMMON_HEX_CHARS-1))+DLT_COMMON_CHARLEN+DLT_COMMON_HEX_CHARS+4*DLT_COMMON_CHARLEN) *
 160                       ((size/DLT_COMMON_HEX_CHARS) + 1);
 161         /* Example: (8 chars line number + (2*16 chars + 15 spaces) + space + 16 ascii chars + 4 [HTML CR: <BR>]) *
 162            ((size/16) lines + extra line for the rest) */
 163     }
 164
 165     if (textlength<required_size)
 166     {
 167         snprintf(str,DLT_COMMON_BUFFER_LENGTH, "String does not fit mixed data (available=%d, required=%d) !\n", textlength, required_size);
 168         dlt_log(LOG_ERR, str);
 169         return -1;
 170     }
 171
 172     /* print full lines */
 173     for (lines=0; lines< (size / DLT_COMMON_HEX_CHARS); lines++)
 174     {
 175         /* Line number */
 176         snprintf(text,DLT_COMMON_HEX_LINELEN+1,"%.6x: ",lines * DLT_COMMON_HEX_CHARS);
 177         text+=DLT_COMMON_HEX_LINELEN; /* 'XXXXXX: ' */
 178
 179         /* Hex-Output */
 180         /* It is not required to decrement textlength, as it was already checked, that
 181            there is enough space for the complete output */
 182         dlt_print_hex_string(text,textlength,(uint8_t*)(ptr+(lines*DLT_COMMON_HEX_CHARS)),DLT_COMMON_HEX_CHARS);
 183         text+=((2*DLT_COMMON_HEX_CHARS)+(DLT_COMMON_HEX_CHARS-1)); /* 32 characters + 15 spaces */
 184
 185         snprintf(text,2," ");
 186         text+=DLT_COMMON_CHARLEN;
 187
 188         /* Char-Output */
 189         /* It is not required to decrement textlength, as it was already checked, that
 190            there is enough space for the complete output */
 191         dlt_print_char_string(&text,textlength,(uint8_t*)(ptr+(lines*DLT_COMMON_HEX_CHARS)),DLT_COMMON_HEX_CHARS);
 192
 193         if (html==0)
 194         {
 195             snprintf(text,2,"\n");
 196             text+=DLT_COMMON_CHARLEN;
 197         }
 198         else
 199         {
 200             snprintf(text,5,"<BR>");
 201             text+=(4*DLT_COMMON_CHARLEN);
 202         }
 203     }
 204
 205     /* print partial line */
 206     rest = size % DLT_COMMON_HEX_CHARS;
 207
 208     if (rest>0)
 209     {
 210         /* Line number */
 211         snprintf(text,9,"%.6x: ", (size / DLT_COMMON_HEX_CHARS) * DLT_COMMON_HEX_CHARS);
 212         text+=DLT_COMMON_HEX_LINELEN; /* 'XXXXXX: ' */
 213
 214         /* Hex-Output */
 215         /* It is not required to decrement textlength, as it was already checked, that
 216            there is enough space for the complete output */
 217         dlt_print_hex_string(text,textlength,(uint8_t*)(ptr+ ((size / DLT_COMMON_HEX_CHARS) * DLT_COMMON_HEX_CHARS)),rest);
 218         text+=2*rest+(rest-1);
 219
 220         for (i=0;i<(DLT_COMMON_HEX_CHARS-rest);i++)
 221         {
 222             snprintf(text,4," xx");
 223             text+=(3*DLT_COMMON_CHARLEN);
 224         }
 225
 226         snprintf(text,2," ");
 227         text+=DLT_COMMON_CHARLEN;
 228
 229         /* Char-Output */
 230         /* It is not required to decrement textlength, as it was already checked, that
 231            there is enough space for the complete output */
 232         dlt_print_char_string(&text,textlength,(uint8_t*)(ptr+ ((size / DLT_COMMON_HEX_CHARS) * DLT_COMMON_HEX_CHARS)),rest);
 233     }
 234
 235     return 0;
 236 }
 237
 238 int dlt_print_char_string(char **text,int textlength,uint8_t *ptr,int size)
 239 {
 240     int num;
 241
 242     if (text==0)
 243     {
 244         return -1;
 245     }
 246
 247     if ((ptr==0) || (*text==0) || (textlength<=0) || (size<0))
 248     {
 249         return -1;
 250     }
 251
 252     if (textlength< size)
 253     {
 254         dlt_log(LOG_ERR, "String does not fit character data!\n");
 255         return -1;
 256     }
 257
 258     for (num=0;num<size;num++)
 259     {
 260         if ( (((char*)ptr)[num]<DLT_COMMON_ASCII_CHAR_SPACE) || (((char*)ptr)[num]>DLT_COMMON_ASCII_CHAR_TILDE) )
 261         {
 262             snprintf(*text,2,".");
 263         }
 264         else
 265         {
 266             /* replace < with . */
 267             if (((char*)ptr)[num]!=DLT_COMMON_ASCII_CHAR_LT)
 268             {
 269                 snprintf(*text,2,"%c",((char *)ptr)[num]);
 270             }
 271             else
 272             {
 273                 snprintf(*text,2,".");
 274             }
 275         }
 276         (*text)++;
 277     }
 278
 279     return 0;
 280 }
 281
 282 void dlt_print_id(char *text,const char *id)
 283 {
 284     int i, len;
 285
 286     if (text==0)
 287     {
 288         return;
 289     }
 290
 291     /* Initialize text */
 292     for (i=0; i<DLT_ID_SIZE; i++)
 293     {
 294         text[i]='-';
 295     }
 296
 297     text[DLT_ID_SIZE] = 0;
 298
 299     len = ((strlen(id)<=DLT_ID_SIZE)?strlen(id):DLT_ID_SIZE);
 300
 301     /* Check id*/
 302     for (i=0; i<len; i++)
 303         text[i] = id[i];
 304 }
 305
 306 void dlt_set_id(char *id,const char *text)
 307 {
 308     id[0] = 0;
 309     id[1] = 0;
 310     id[2] = 0;
 311     id[3] = 0;
 312
 313     if (text==0)
 314     {
 315         return;
 316     }
 317
 318     if (text[0]!=0)
 319     {
 320         id[0] = text[0];
 321     }
 322     else
 323     {
 324         return;
 325     }
 326
 327     if (text[1]!=0)
 328     {
 329         id[1] = text[1];
 330     }
 331     else
 332     {
 333         return;
 334     }
 335
 336     if (text[2]!=0)
 337     {
 338         id[2] = text[2];
 339     }
 340     else
 341     {
 342         return;
 343     }
 344
 345     if (text[3]!=0)
 346     {
 347         id[3] = text[3];
 348     }
 349     else
 350     {
 351         return;
 352     }
 353 }
 354
 355 void dlt_clean_string(char *text,int length)
 356 {
 357     int num;
 358
 359     if (text==0)
 360     {
 361         return;
 362     }
 363
 364     for (num=0;num<length;num++)
 365     {
 366         if (text[num]=='\r' || text[num]=='\n')
 367         {
 368             text[num] = ' ';
 369         }
 370     }
 371 }
 372
 373 int dlt_filter_init(DltFilter *filter,int verbose)
 374 {
 375     PRINT_FUNCTION_VERBOSE(verbose);
 376
 377     if (filter==0)
 378     {
 379         return -1;
 380     }
 381
 382     filter->counter = 0;
 383
 384     return 0;
 385 }
 386
 387 int dlt_filter_free(DltFilter *filter,int verbose)
 388 {
 389     PRINT_FUNCTION_VERBOSE(verbose);
 390
 391     if (filter==0)
 392     {
 393         return -1;
 394     }
 395
 396     return 0;
 397 }
 398
 399 int dlt_filter_load(DltFilter *filter,const char *filename,int verbose)
 400 {
 401     FILE *handle;
 402     char str1[DLT_COMMON_BUFFER_LENGTH];
 403     char apid[DLT_ID_SIZE],ctid[DLT_ID_SIZE];
 404
 405     PRINT_FUNCTION_VERBOSE(verbose);
 406
 407     if (filter==0)
 408     {
 409         return -1;
 410     }
 411
 412     handle = fopen(filename,"r");
 413     if (handle == 0)
 414     {
 415         snprintf(str,DLT_COMMON_BUFFER_LENGTH,"Filter file %s cannot be opened!\n",filename);
 416         dlt_log(LOG_ERR, str);
 417         return -1;
 418     }
 419
 420     /* Reset filters */
 421     filter->counter=0;
 422
 423     while (!feof(handle))
 424     {
 425         str1[0]=0;
 426         if (fscanf(handle,"%s",str1)!=1)
 427         {
 428             break;
 429         }
 430         if (str1[0]==0)
 431         {
 432             break;
 433         }
 434         printf(" %s",str1);
 435         if (strcmp(str1,"----")==0)
 436         {
 437             dlt_set_id(apid,"");
 438         }
 439         else
 440         {
 441             dlt_set_id(apid,str1);
 442         }
 443
 444         str1[0]=0;
 445         if (fscanf(handle,"%s",str1)!=1)
 446         {
 447             break;
 448         }
 449         if (str1[0]==0)
 450         {
 451             break;
 452         }
 453         printf(" %s\r\n",str1);
 454         if (strcmp(str1,"----")==0)
 455         {
 456             dlt_set_id(ctid,"");
 457         }
 458         else
 459         {
 460             dlt_set_id(ctid,str1);
 461         }
 462
 463         if (filter->counter<DLT_FILTER_MAX)
 464         {
 465             dlt_filter_add(filter,apid,ctid,verbose);
 466         }
 467         else
 468         {
 469             snprintf(str,DLT_COMMON_BUFFER_LENGTH, "Maximum number (%d) of allowed filters reached!\n", DLT_FILTER_MAX);
 470             dlt_log(LOG_ERR, str);
 471             return 0;
 472         }
 473     }
 474
 475     fclose(handle);
 476
 477     return 0;
 478 }
 479
 480 int dlt_filter_save(DltFilter *filter,const char *filename,int verbose)
 481 {
 482     FILE *handle;
 483     int num;
 484     char buf[DLT_COMMON_BUFFER_LENGTH];
 485
 486     PRINT_FUNCTION_VERBOSE(verbose);
 487
 488     if (filter==0)
 489     {
 490         return -1;
 491     }
 492
 493     handle = fopen(filename,"w");
 494     if (handle == 0)
 495     {
 496         snprintf(str,DLT_COMMON_BUFFER_LENGTH,"Filter file %s cannot be opened!\n",filename);
 497         dlt_log(LOG_ERR, str);
 498         return -1;
 499     }
 500
 501     for (num=0;num<filter->counter;num++)
 502     {
 503         if (filter->apid[num][0]==0)
 504         {
 505             fprintf(handle,"---- ");
 506         }
 507         else
 508         {
 509             dlt_print_id(buf,filter->apid[num]);
 510             fprintf(handle,"%s ",buf);
 511         }
 512         if (filter->ctid[num][0]==0)
 513         {
 514             fprintf(handle,"---- ");
 515         }
 516         else
 517         {
 518             dlt_print_id(buf,filter->ctid[num]);
 519             fprintf(handle,"%s ",buf);
 520         }
 521     }
 522
 523     fclose(handle);
 524
 525     return 0;
 526 }
 527
 528 int dlt_filter_find(DltFilter *filter,const char *apid,const char *ctid, int verbose)
 529 {
 530     int num;
 531
 532     PRINT_FUNCTION_VERBOSE(verbose);
 533
 534     if ((filter==0) || (apid==0))
 535     {
 536         return -1;
 537     }
 538
 539     for (num=0; num<filter->counter; num++)
 540     {
 541         if (memcmp(filter->apid[num],apid,DLT_ID_SIZE)==0)
 542         {
 543             /* apid matches, now check for ctid */
 544             if (ctid==0)
 545             {
 546                 /* check if empty ctid matches */
 547                 //if (memcmp(filter->ctid[num],"",DLT_ID_SIZE)==0)//coverity complains here about Out-of-bounds access.
 548                 char empty_ctid[DLT_ID_SIZE]="";
 549                 if (memcmp(filter->ctid[num],empty_ctid,DLT_ID_SIZE)==0)
 550                 {
 551                     return num;
 552                 }
 553             }
 554             else
 555             {
 556                 if (memcmp(filter->ctid[num],ctid,DLT_ID_SIZE)==0)
 557                 {
 558                     return num;
 559                 }
 560             }
 561         }
 562     }
 563
 564     return -1; /* Not found */
 565 }
 566
 567 int dlt_filter_add(DltFilter *filter,const char *apid,const char *ctid, int verbose)
 568 {
 569     PRINT_FUNCTION_VERBOSE(verbose);
 570
 571     if ((filter==0) || (apid==0))
 572     {
 573         return -1;
 574     }
 575
 576     if (filter->counter >= DLT_FILTER_MAX)
 577     {
 578         dlt_log(LOG_ERR, "Maximum numbers of allowed filters reached!\n");
 579         return -1;
 580     }
 581
 582     /* add each filter (apid, ctid) only once to filter array */
 583     if (dlt_filter_find(filter,apid,ctid,verbose)<0)
 584     {
 585         /* filter not found, so add it to filter array */
 586         if (filter->counter<DLT_FILTER_MAX)
 587         {
 588             dlt_set_id(filter->apid[filter->counter],apid);
 589             dlt_set_id(filter->ctid[filter->counter],(ctid?ctid:""));
 590
 591             filter->counter++;
 592
 593             return 0;
 594         }
 595     }
 596
 597     return -1;
 598 }
 599
 600 int dlt_filter_delete(DltFilter *filter,const char *apid,const char *ctid, int verbose)
 601 {
 602     int j,k;
 603     int found=0;
 604
 605     PRINT_FUNCTION_VERBOSE(verbose);
 606
 607     if ((filter==0) || (apid==0))
 608     {
 609         return -1;
 610     }
 611
 612     if (filter->counter>0)
 613     {
 614         /* Get first occurence of apid and ctid in filter array */
 615         for (j=0; j<filter->counter; j++)
 616         {
 617             if ((memcmp(filter->apid[j],apid,DLT_ID_SIZE)==0) &&
 618                 (memcmp(filter->ctid[j],ctid,DLT_ID_SIZE)==0)
 619                )
 620
 621             {
 622                 found=1;
 623                 break;
 624             }
 625         }
 626
 627         if (found)
 628         {
 629             /* j is index */
 630             /* Copy from j+1 til end to j til end-1 */
 631
 632             dlt_set_id(filter->apid[j],"");
 633             dlt_set_id(filter->ctid[j],"");
 634
 635             for (k=j; k<(filter->counter-1); k++)
 636             {
 637                 dlt_set_id(filter->apid[k],filter->apid[k+1]);
 638                 dlt_set_id(filter->ctid[k],filter->ctid[k+1]);
 639             }
 640
 641             filter->counter--;
 642             return 0;
 643         }
 644     }
 645
 646     return -1;
 647 }
 648
 649 int dlt_message_init(DltMessage *msg,int verbose)
 650 {
 651     PRINT_FUNCTION_VERBOSE(verbose);
 652
 653     if (msg==0)
 654     {
 655         return -1;
 656     }
 657
 658     /* initalise structure parameters */
 659     msg->headersize = 0;
 660     msg->datasize = 0;
 661
 662     msg->databuffer = 0;
 663     msg->databuffersize = 0;
 664
 665     msg->storageheader = 0;
 666     msg->standardheader = 0;
 667     msg->extendedheader = 0;
 668
 669     msg->found_serialheader = 0;
 670
 671     return 0;
 672 }
 673
 674 int dlt_message_free(DltMessage *msg,int verbose)
 675 {
 676     PRINT_FUNCTION_VERBOSE(verbose);
 677
 678     if (msg==0)
 679     {
 680         return -1;
 681     }
 682     /* delete databuffer if exists */
 683     if (msg->databuffer)
 684     {
 685         free(msg->databuffer);
 686         msg->databuffer = 0;
 687         msg->databuffersize = 0;
 688     }
 689
 690     return 0;
 691 }
 692
 693 int dlt_message_header(DltMessage *msg,char *text,int textlength,int verbose)
 694 {
 695     return dlt_message_header_flags(msg,text,textlength,DLT_HEADER_SHOW_ALL,verbose);
 696 }
 697
 698 int dlt_message_header_flags(DltMessage *msg,char *text,int textlength,int flags, int verbose)
 699 {
 700     struct tm * timeinfo;
 701     char buffer [DLT_COMMON_BUFFER_LENGTH];
 702
 703     PRINT_FUNCTION_VERBOSE(verbose);
 704
 705     if ((msg==0) || (text==0) || (textlength<=0))
 706     {
 707         return -1;
 708     }
 709
 710     if ((flags<DLT_HEADER_SHOW_NONE) || (flags>DLT_HEADER_SHOW_ALL))
 711     {
 712         return -1;
 713     }
 714
 715     text[0] = 0;
 716
 717     if ((flags & DLT_HEADER_SHOW_TIME) == DLT_HEADER_SHOW_TIME)
 718     {
 719         /* print received time */
 720         time_t tt = msg->storageheader->seconds;
 721         timeinfo = localtime (&tt);
 722
 723         if (timeinfo!=0)
 724         {
 725             strftime (buffer,sizeof(buffer),"%Y/%m/%d %H:%M:%S",timeinfo);
 726             snprintf(text,textlength,"%s.%.6d ",buffer,msg->storageheader->microseconds);
 727         }
 728     }
 729
 730     if ((flags & DLT_HEADER_SHOW_TMSTP) == DLT_HEADER_SHOW_TMSTP)
 731     {
 732         /* print timestamp if available */
 733         if ( DLT_IS_HTYP_WTMS(msg->standardheader->htyp) )
 734         {
 735             snprintf(text+strlen(text),textlength-strlen(text),"%10u ",msg->headerextra.tmsp);
 736         }
 737         else
 738         {
 739             snprintf(text+strlen(text),textlength-strlen(text),"---------- ");
 740         }
 741     }
 742
 743     if ((flags & DLT_HEADER_SHOW_MSGCNT) == DLT_HEADER_SHOW_MSGCNT)
 744     {
 745         /* print message counter */
 746         snprintf(text+strlen(text),textlength-strlen(text),"%.3d ",msg->standardheader->mcnt);
 747     }
 748
 749     if ((flags & DLT_HEADER_SHOW_ECUID) == DLT_HEADER_SHOW_ECUID)
 750     {
 751         /* print ecu id, use header extra if available, else storage header value */
 752         if ( DLT_IS_HTYP_WEID(msg->standardheader->htyp) )
 753         {
 754             dlt_print_id(text+strlen(text),msg->headerextra.ecu);
 755         }
 756         else
 757         {
 758             dlt_print_id(text+strlen(text),msg->storageheader->ecu);
 759         }
 760     }
 761
 762     /* print app id and context id if extended header available, else '----' */#
 763     if ((flags & DLT_HEADER_SHOW_APID) == DLT_HEADER_SHOW_APID)
 764     {
 765         snprintf(text+strlen(text),textlength-strlen(text)," ");
 766         if ((DLT_IS_HTYP_UEH(msg->standardheader->htyp)) && (msg->extendedheader->apid[0]!=0))
 767         {
 768             dlt_print_id(text+strlen(text),msg->extendedheader->apid);
 769         }
 770         else
 771         {
 772             snprintf(text+strlen(text),textlength-strlen(text),"----");
 773         }
 774
 775         snprintf(text+strlen(text),textlength-strlen(text)," ");
 776     }
 777
 778     if ((flags & DLT_HEADER_SHOW_CTID) == DLT_HEADER_SHOW_CTID)
 779     {
 780         if ((DLT_IS_HTYP_UEH(msg->standardheader->htyp)) && (msg->extendedheader->ctid[0]!=0))
 781         {
 782             dlt_print_id(text+strlen(text),msg->extendedheader->ctid);
 783         }
 784         else
 785         {
 786             snprintf(text+strlen(text),textlength-strlen(text),"----");
 787         }
 788
 789         snprintf(text+strlen(text),textlength-strlen(text)," ");
 790     }
 791
 792     /* print info about message type and length */
 793     if (DLT_IS_HTYP_UEH(msg->standardheader->htyp))
 794     {
 795         if ((flags & DLT_HEADER_SHOW_MSGTYPE) == DLT_HEADER_SHOW_MSGTYPE)
 796         {
 797             snprintf(text+strlen(text),textlength-strlen(text),"%s",message_type[DLT_GET_MSIN_MSTP(msg->extendedheader->msin)]);
 798             snprintf(text+strlen(text),textlength-strlen(text)," ");
 799         }
 800
 801         if ((flags & DLT_HEADER_SHOW_MSGSUBTYPE) == DLT_HEADER_SHOW_MSGSUBTYPE)
 802         {
 803             if ((DLT_GET_MSIN_MSTP(msg->extendedheader->msin))==DLT_TYPE_LOG)
 804             {
 805                 snprintf(text+strlen(text),textlength-strlen(text),"%s",log_info[DLT_GET_MSIN_MTIN(msg->extendedheader->msin)]);
 806             }
 807
 808             if ((DLT_GET_MSIN_MSTP(msg->extendedheader->msin))==DLT_TYPE_APP_TRACE)
 809             {
 810                 snprintf(text+strlen(text),textlength-strlen(text),"%s",trace_type[DLT_GET_MSIN_MTIN(msg->extendedheader->msin)]);
 811             }
 812
 813             if ((DLT_GET_MSIN_MSTP(msg->extendedheader->msin))==DLT_TYPE_NW_TRACE)
 814             {
 815                 snprintf(text+strlen(text),textlength-strlen(text),"%s",nw_trace_type[DLT_GET_MSIN_MTIN(msg->extendedheader->msin)]);
 816             }
 817
 818             if ((DLT_GET_MSIN_MSTP(msg->extendedheader->msin))==DLT_TYPE_CONTROL)
 819             {
 820                 snprintf(text+strlen(text),textlength-strlen(text),"%s",control_type[DLT_GET_MSIN_MTIN(msg->extendedheader->msin)]);
 821             }
 822
 823             snprintf(text+strlen(text),textlength-strlen(text)," ");
 824         }
 825
 826         if ((flags & DLT_HEADER_SHOW_VNVSTATUS) == DLT_HEADER_SHOW_VNVSTATUS)
 827         {
 828             /* print verbose status pf message */
 829             if (DLT_IS_MSIN_VERB(msg->extendedheader->msin))
 830             {
 831                 snprintf(text+strlen(text),textlength-strlen(text),"V");
 832             }
 833             else
 834             {
 835                 snprintf(text+strlen(text),textlength-strlen(text),"N");
 836             }
 837
 838             snprintf(text+strlen(text),textlength-strlen(text)," ");
 839         }
 840
 841         if ((flags & DLT_HEADER_SHOW_NOARG) == DLT_HEADER_SHOW_NOARG)
 842         {
 843             /* print number of arguments */
 844             snprintf(text+strlen(text),textlength-strlen(text),"%d", msg->extendedheader->noar);
 845         }
 846
 847     }
 848     else
 849     {
 850         if ((flags & DLT_HEADER_SHOW_MSGTYPE) == DLT_HEADER_SHOW_MSGTYPE)
 851         {
 852             snprintf(text+strlen(text),textlength-strlen(text),"--- ");
 853         }
 854
 855         if ((flags & DLT_HEADER_SHOW_MSGSUBTYPE) == DLT_HEADER_SHOW_MSGSUBTYPE)
 856         {
 857             snprintf(text+strlen(text),textlength-strlen(text),"--- ");
 858         }
 859
 860         if ((flags & DLT_HEADER_SHOW_VNVSTATUS) == DLT_HEADER_SHOW_VNVSTATUS)
 861         {
 862             snprintf(text+strlen(text),textlength-strlen(text),"N ");
 863         }
 864
 865         if ((flags & DLT_HEADER_SHOW_NOARG) == DLT_HEADER_SHOW_NOARG)
 866         {
 867             snprintf(text+strlen(text),textlength-strlen(text),"-");
 868         }
 869     }
 870
 871     return 0;
 872 }
 873
 874 int dlt_message_payload(DltMessage *msg,char *text,int textlength,int type,int verbose)
 875 {
 876     uint32_t id=0,id_tmp=0;
 877     uint8_t retval=0;
 878
 879     uint8_t *ptr;
 880     int32_t datalength;
 881
 882     /* Pointer to ptr and datalength */
 883     uint8_t **pptr;
 884     int32_t *pdatalength;
 885
 886     int ret=0;
 887
 888     int num;
 889     uint32_t type_info=0,type_info_tmp=0;
 890
 891     PRINT_FUNCTION_VERBOSE(verbose);
 892
 893     if ((msg==0) || (text==0))
 894     {
 895         return -1;
 896     }
 897
 898     if (textlength<=0)
 899     {
 900         dlt_log(LOG_ERR, "String does not fit binary data!\n");
 901         return -1;
 902     }
 903
 904     /* start with empty string */
 905     text[0] = 0;
 906
 907     /* print payload only as hex */
 908     if (type==DLT_OUTPUT_HEX)
 909     {
 910         return dlt_print_hex_string(text,textlength,msg->databuffer,msg->datasize);
 911     }
 912
 913     /* print payload as mixed */
 914     if (type==DLT_OUTPUT_MIXED_FOR_PLAIN)
 915     {
 916         return dlt_print_mixed_string(text,textlength,msg->databuffer,msg->datasize,0);
 917     }
 918
 919     if (type==DLT_OUTPUT_MIXED_FOR_HTML)
 920     {
 921         return dlt_print_mixed_string(text,textlength,msg->databuffer,msg->datasize,1);
 922     }
 923
 924     ptr = msg->databuffer;
 925     datalength = msg->datasize;
 926
 927     /* Pointer to ptr and datalength */
 928     pptr = &ptr;
 929     pdatalength = &datalength;
 930
 931     /* non-verbose mode */
 932
 933     /* print payload as hex */
 934     if (DLT_MSG_IS_NONVERBOSE(msg))
 935     {
 936
 937         DLT_MSG_READ_VALUE(id_tmp,ptr,datalength,uint32_t);
 938         id=DLT_ENDIAN_GET_32(msg->standardheader->htyp, id_tmp);
 939
 940         if (textlength<((datalength*3)+20))
 941         {
 942             dlt_log(LOG_ERR, "String does not fit binary data!\n");
 943             return -1;
 944         }
 945
 946         /* process message id / service id */
 947         if (DLT_MSG_IS_CONTROL(msg))
 948         {
 949             if (id > 0 && id <= DLT_SERVICE_ID_MESSAGE_BUFFER_OVERFLOW)
 950             {
 951                 snprintf(text+strlen(text),textlength-strlen(text),"%s",service_id[id]); /* service id */
 952             }
 953             else
 954             {
 955                 if (!(DLT_MSG_IS_CONTROL_TIME(msg)))
 956                 {
 957                     snprintf(text+strlen(text),textlength-strlen(text),"service(%u)",id); /* service id */
 958                 }
 959             }
 960
 961             if (datalength>0)
 962             {
 963                 snprintf(text+strlen(text),textlength-strlen(text),", ");
 964             }
 965         }
 966         else
 967         {
 968             snprintf(text+strlen(text),textlength-strlen(text),"%u, ",id); /* message id */
 969         }
 970
 971         /* process return value */
 972         if (DLT_MSG_IS_CONTROL_RESPONSE(msg))
 973         {
 974             if (datalength>0)
 975             {
 976                 DLT_MSG_READ_VALUE(retval,ptr,datalength,uint8_t); /* No endian conversion necessary */
 977                 if ( (retval<3) || (retval==8))
 978                 {
 979                     snprintf(text+strlen(text),textlength-strlen(text),"%s",return_type[retval]);
 980                 }
 981                 else
 982                 {
 983                     snprintf(text+strlen(text),textlength-strlen(text),"%.2x",retval);
 984                 }
 985
 986                 if (datalength>=1)
 987                 {
 988                     snprintf(text+strlen(text),textlength-strlen(text),", ");
 989                 }
 990             }
 991         }
 992
 993         if (type==DLT_OUTPUT_ASCII_LIMITED)
 994         {
 995             ret=dlt_print_hex_string(text+strlen(text),textlength-strlen(text),ptr,
 996                                      (datalength>DLT_COMMON_ASCII_LIMIT_MAX_CHARS?DLT_COMMON_ASCII_LIMIT_MAX_CHARS:datalength));
 997             if ((datalength>DLT_COMMON_ASCII_LIMIT_MAX_CHARS) &&
 998                     ((textlength-strlen(text))>4))
 999             {
1000                 snprintf(text+strlen(text),textlength-strlen(text)," ...");
1001             }
1002         }
1003         else
1004         {
1005             ret=dlt_print_hex_string(text+strlen(text),textlength-strlen(text),ptr,datalength);
1006         }
1007
1008         return ret;
1009     }
1010
1011     /* At this point, it is ensured that a extended header is available */
1012
1013     /* verbose mode */
1014     type_info=0;
1015     type_info_tmp=0;
1016
1017     for (num=0;num<(int)(msg->extendedheader->noar);num++)
1018     {
1019         if (num!=0)
1020         {
1021             snprintf(text+strlen(text),textlength-strlen(text)," ");
1022         }
1023
1024         /* first read the type info of the argument */
1025         DLT_MSG_READ_VALUE(type_info_tmp,ptr,datalength,uint32_t);
1026         type_info=DLT_ENDIAN_GET_32(msg->standardheader->htyp, type_info_tmp);
1027
1028         /* print out argument */
1029         if (dlt_message_argument_print(msg, type_info, pptr, pdatalength, text, textlength, -1, 0)==-1)
1030         {
1031             return -1;
1032         }
1033     }
1034
1035     return 0;
1036 }
1037
1038 int dlt_message_filter_check(DltMessage *msg,DltFilter *filter,int verbose)
1039 {
1040     /* check the filters if message is used */
1041     int num;
1042     int found = 0;
1043
1044     PRINT_FUNCTION_VERBOSE(verbose);
1045
1046     if ((msg==0) || (filter==0))
1047     {
1048         return -1;
1049     }
1050
1051     if ((filter->counter==0) || (!(DLT_IS_HTYP_UEH(msg->standardheader->htyp))))
1052     {
1053         /* no filter is set, or no extended header is available, so do as filter is matching */
1054         return 1;
1055     }
1056
1057     for (num=0;num<filter->counter;num++)
1058     {
1059         /* check each filter if it matches */
1060         if ((DLT_IS_HTYP_UEH(msg->standardheader->htyp)) &&
1061                 (filter->apid[num][0]==0 || memcmp(filter->apid[num],msg->extendedheader->apid,DLT_ID_SIZE)==0) &&
1062                 (filter->ctid[num][0]==0 || memcmp(filter->ctid[num],msg->extendedheader->ctid,DLT_ID_SIZE)==0) )
1063         {
1064             found = 1;
1065             break;
1066         }
1067     }
1068
1069     return found;
1070 }
1071
1072 int dlt_message_read(DltMessage *msg,uint8_t *buffer,unsigned int length,int resync, int verbose)
1073 {
1074     int extra_size = 0;
1075
1076     PRINT_FUNCTION_VERBOSE(verbose);
1077
1078     if ((msg==0) || (buffer==0) || (length<=0))
1079     {
1080         return DLT_MESSAGE_ERROR_UNKNOWN;
1081     }
1082
1083     /* initialize resync_offset */
1084     msg->resync_offset=0;
1085
1086     /* check if message contains serial header, smaller than standard header */
1087     if (length<sizeof(dltSerialHeader))
1088     {
1089         /* dlt_log(LOG_ERR, "Length smaller than serial header!\n"); */
1090         return DLT_MESSAGE_ERROR_SIZE;
1091     }
1092
1093     if (memcmp(buffer,dltSerialHeader,sizeof(dltSerialHeader)) == 0)
1094     {
1095         /* serial header found */
1096         msg->found_serialheader = 1;
1097         buffer += sizeof(dltSerialHeader);
1098         length -= sizeof(dltSerialHeader);
1099     }
1100     else
1101     {
1102         /* serial header not found */
1103         msg->found_serialheader = 0;
1104         if (resync)
1105         {
1106             /* resync if necessary */
1107             msg->resync_offset=0;
1108
1109             do
1110             {
1111                 if (memcmp(buffer+msg->resync_offset,dltSerialHeader,sizeof(dltSerialHeader)) == 0)
1112                 {
1113                     /* serial header found */
1114                     msg->found_serialheader = 1;
1115                     buffer += sizeof(dltSerialHeader);
1116                     length -= sizeof(dltSerialHeader);
1117                     break;
1118                 }
1119
1120                 msg->resync_offset++;
1121             }
1122             while ((sizeof(dltSerialHeader)+msg->resync_offset)<=length);
1123
1124             /* Set new start offset */
1125             if (msg->resync_offset>0)
1126             {
1127                 /* Resyncing connection */
1128                 buffer+=msg->resync_offset;
1129                 length-=msg->resync_offset;
1130             }
1131         }
1132     }
1133
1134     /* check that standard header fits buffer */
1135     if (length<sizeof(DltStandardHeader))
1136     {
1137         /* dlt_log(LOG_ERR, "Length smaller than standard header!\n"); */
1138         return DLT_MESSAGE_ERROR_SIZE;
1139     }
1140     memcpy(msg->headerbuffer+sizeof(DltStorageHeader),buffer,sizeof(DltStandardHeader));
1141
1142     /* set ptrs to structures */
1143     msg->storageheader = (DltStorageHeader*) msg->headerbuffer;
1144     msg->standardheader = (DltStandardHeader*) (msg->headerbuffer + sizeof(DltStorageHeader));
1145
1146     /* calculate complete size of headers */
1147     extra_size = DLT_STANDARD_HEADER_EXTRA_SIZE(msg->standardheader->htyp)+(DLT_IS_HTYP_UEH(msg->standardheader->htyp) ? sizeof(DltExtendedHeader) : 0);
1148     msg->headersize = sizeof(DltStorageHeader) + sizeof(DltStandardHeader) + extra_size;
1149     msg->datasize =  DLT_BETOH_16(msg->standardheader->len) - (msg->headersize - sizeof(DltStorageHeader));
1150
1151     if (verbose)
1152     {
1153         snprintf(str,DLT_COMMON_BUFFER_LENGTH,"Buffer length: %d\n",length);
1154         dlt_log(LOG_INFO, str);
1155     }
1156     if (verbose)
1157     {
1158         snprintf(str,DLT_COMMON_BUFFER_LENGTH,"Header Size: %d\n",msg->headersize);
1159         dlt_log(LOG_INFO, str);
1160     }
1161     if (verbose)
1162     {
1163         snprintf(str,DLT_COMMON_BUFFER_LENGTH,"Data Size: %d\n",msg->datasize);
1164         dlt_log(LOG_INFO, str);
1165     }
1166
1167     /* check data size */
1168     if (msg->datasize < 0)
1169     {
1170         snprintf(str,DLT_COMMON_BUFFER_LENGTH,"Plausibility check failed. Complete message size too short (%d)!\n",msg->datasize);
1171         dlt_log(LOG_ERR, str);
1172         return DLT_MESSAGE_ERROR_CONTENT;
1173     }
1174
1175     /* load standard header extra parameters and Extended header if used */
1176     if (extra_size>0)
1177     {
1178         if (length  < (msg->headersize - sizeof(DltStorageHeader)))
1179         {
1180             return DLT_MESSAGE_ERROR_SIZE;
1181         }
1182
1183         memcpy(msg->headerbuffer+sizeof(DltStorageHeader)+sizeof(DltStandardHeader),buffer+sizeof(DltStandardHeader),extra_size);
1184
1185         /* set extended header ptr and get standard header extra parameters */
1186         if (DLT_IS_HTYP_UEH(msg->standardheader->htyp))
1187         {
1188             msg->extendedheader = (DltExtendedHeader*) (msg->headerbuffer + sizeof(DltStorageHeader) + sizeof(DltStandardHeader) +
1189                                   DLT_STANDARD_HEADER_EXTRA_SIZE(msg->standardheader->htyp));
1190         }
1191         else
1192         {
1193             msg->extendedheader = 0;
1194         }
1195
1196         dlt_message_get_extraparameters(msg,verbose);
1197     }
1198
1199     /* check if payload fits length */
1200     if (length  < (msg->headersize - sizeof(DltStorageHeader) + msg->datasize))
1201     {
1202         /* dlt_log(LOG_ERR,"length does not fit!\n"); */
1203         return DLT_MESSAGE_ERROR_SIZE;
1204     }
1205
1206     /* free last used memory for buffer */
1207     if (msg->databuffer)
1208     {
1209         if (msg->datasize>msg->databuffersize){
1210                 free(msg->databuffer);
1211                 msg->databuffer=(uint8_t *)malloc(msg->datasize);
1212                 msg->databuffersize = msg->datasize;
1213         }
1214     }else{
1215         /* get new memory for buffer */
1216         msg->databuffer = (uint8_t *)malloc(msg->datasize);
1217         msg->databuffersize = msg->datasize;
1218     }
1219     if (msg->databuffer == 0)
1220     {
1221         snprintf(str,DLT_COMMON_BUFFER_LENGTH,"Cannot allocate memory for payload buffer of size %d!\n",msg->datasize);
1222         dlt_log(LOG_ERR, str);
1223         return DLT_MESSAGE_ERROR_UNKNOWN;
1224     }
1225
1226     /* load payload data from buffer */
1227     memcpy(msg->databuffer,buffer+(msg->headersize-sizeof(DltStorageHeader)),msg->datasize);
1228
1229     return DLT_MESSAGE_ERROR_OK;
1230 }
1231
1232 int dlt_message_get_extraparameters(DltMessage *msg,int verbose)
1233 {
1234     PRINT_FUNCTION_VERBOSE(verbose);
1235
1236     if (msg==0)
1237     {
1238         return -1;
1239     }
1240
1241     if (DLT_IS_HTYP_WEID(msg->standardheader->htyp))
1242     {
1243         memcpy(msg->headerextra.ecu,msg->headerbuffer + sizeof(DltStorageHeader) + sizeof(DltStandardHeader),DLT_ID_SIZE);
1244     }
1245
1246     if (DLT_IS_HTYP_WSID(msg->standardheader->htyp))
1247     {
1248         memcpy(&(msg->headerextra.seid),msg->headerbuffer + sizeof(DltStorageHeader) + sizeof(DltStandardHeader)
1249                + (DLT_IS_HTYP_WEID(msg->standardheader->htyp) ? DLT_SIZE_WEID : 0), DLT_SIZE_WSID);
1250         msg->headerextra.seid = DLT_BETOH_32(msg->headerextra.seid);
1251     }
1252
1253     if (DLT_IS_HTYP_WTMS(msg->standardheader->htyp))
1254     {
1255         memcpy(&(msg->headerextra.tmsp),msg->headerbuffer + sizeof(DltStorageHeader) + sizeof(DltStandardHeader)
1256                + (DLT_IS_HTYP_WEID(msg->standardheader->htyp) ? DLT_SIZE_WEID : 0)
1257                + (DLT_IS_HTYP_WSID(msg->standardheader->htyp) ? DLT_SIZE_WSID : 0),DLT_SIZE_WTMS);
1258         msg->headerextra.tmsp = DLT_BETOH_32(msg->headerextra.tmsp);
1259     }
1260
1261     return 0;
1262 }
1263
1264 int dlt_message_set_extraparameters(DltMessage *msg,int verbose)
1265 {
1266     PRINT_FUNCTION_VERBOSE(verbose);
1267
1268     if (msg==0)
1269     {
1270         return -1;
1271     }
1272
1273     if (DLT_IS_HTYP_WEID(msg->standardheader->htyp))
1274     {
1275         memcpy(msg->headerbuffer + sizeof(DltStorageHeader) + sizeof(DltStandardHeader),msg->headerextra.ecu,DLT_ID_SIZE);
1276     }
1277
1278     if (DLT_IS_HTYP_WSID(msg->standardheader->htyp))
1279     {
1280         msg->headerextra.seid = DLT_HTOBE_32(msg->headerextra.seid);
1281         memcpy(msg->headerbuffer + sizeof(DltStorageHeader) + sizeof(DltStandardHeader)
1282                + (DLT_IS_HTYP_WEID(msg->standardheader->htyp) ? DLT_SIZE_WEID : 0), &(msg->headerextra.seid),DLT_SIZE_WSID);
1283     }
1284
1285     if (DLT_IS_HTYP_WTMS(msg->standardheader->htyp))
1286     {
1287         msg->headerextra.tmsp = DLT_HTOBE_32(msg->headerextra.tmsp);
1288         memcpy(msg->headerbuffer + sizeof(DltStorageHeader) + sizeof(DltStandardHeader)
1289                + (DLT_IS_HTYP_WEID(msg->standardheader->htyp) ? DLT_SIZE_WEID : 0)
1290                + (DLT_IS_HTYP_WSID(msg->standardheader->htyp) ? DLT_SIZE_WSID : 0), &(msg->headerextra.tmsp),DLT_SIZE_WTMS);
1291     }
1292
1293     return 0;
1294 }
1295
1296 int dlt_file_init(DltFile *file,int verbose)
1297 {
1298     PRINT_FUNCTION_VERBOSE(verbose);
1299
1300     if (file==0)
1301     {
1302         return -1;
1303     }
1304
1305     /* initalise structure parameters */
1306     file->handle = 0;
1307     file->counter = 0;
1308     file->counter_total = 0;
1309     file->index = 0;
1310
1311     file->filter = 0;
1312     file->filter_counter = 0;
1313     file->file_position = 0;
1314
1315     file->position = 0;
1316
1317     file->error_messages = 0;
1318
1319     return dlt_message_init(&(file->msg),verbose);
1320 }
1321
1322 int dlt_file_set_filter(DltFile *file,DltFilter *filter,int verbose)
1323 {
1324     PRINT_FUNCTION_VERBOSE(verbose);
1325
1326     if (file==0)
1327     {
1328         return -1;
1329     }
1330
1331     /* set filter */
1332     file->filter = filter;
1333
1334     return 0;
1335 }
1336
1337 int dlt_file_read_header(DltFile *file,int verbose)
1338 {
1339     PRINT_FUNCTION_VERBOSE(verbose);
1340
1341     if (file==0)
1342     {
1343         return -1;
1344     }
1345
1346     /* load header from file */
1347     if (fread(file->msg.headerbuffer,sizeof(DltStorageHeader)+sizeof(DltStandardHeader),1,file->handle)!=1)
1348     {
1349         if (!feof(file->handle))
1350         {
1351             dlt_log(LOG_ERR, "Cannot read header from file!\n");
1352         }
1353         return -1;
1354     }
1355
1356     /* set ptrs to structures */
1357     file->msg.storageheader = (DltStorageHeader*) file->msg.headerbuffer;
1358     file->msg.standardheader = (DltStandardHeader*) (file->msg.headerbuffer + sizeof(DltStorageHeader));
1359
1360     /* check id of storage header */
1361     if (dlt_check_storageheader(file->msg.storageheader)==0)
1362     {
1363         dlt_log(LOG_ERR, "DLT storage header pattern not found!\n");
1364         return -1;
1365     }
1366
1367     /* calculate complete size of headers */
1368     file->msg.headersize = sizeof(DltStorageHeader) + sizeof(DltStandardHeader) +
1369                            DLT_STANDARD_HEADER_EXTRA_SIZE(file->msg.standardheader->htyp) + (DLT_IS_HTYP_UEH(file->msg.standardheader->htyp) ? sizeof(DltExtendedHeader) : 0);
1370     file->msg.datasize = DLT_BETOH_16(file->msg.standardheader->len) + sizeof(DltStorageHeader) - file->msg.headersize;
1371     if (verbose)
1372     {
1373         snprintf(str,DLT_COMMON_BUFFER_LENGTH,"Header Size: %d\n",file->msg.headersize);
1374         dlt_log(LOG_INFO, str);
1375     }
1376     if (verbose)
1377     {
1378         snprintf(str,DLT_COMMON_BUFFER_LENGTH,"Data Size: %d\n",file->msg.datasize);
1379         dlt_log(LOG_INFO, str);
1380     }
1381
1382     /* check data size */
1383     if (file->msg.datasize < 0)
1384     {
1385         snprintf(str,DLT_COMMON_BUFFER_LENGTH,"Plausibility check failed. Complete message size too short! (%d)\n", file->msg.datasize);
1386         dlt_log(LOG_ERR, str);
1387         return -1;
1388     }
1389
1390     return 0;
1391 }
1392
1393 int dlt_file_read_header_raw(DltFile *file,int resync,int verbose)
1394 {
1395     char dltSerialHeaderBuffer[DLT_ID_SIZE];
1396
1397     PRINT_FUNCTION_VERBOSE(verbose);
1398
1399     if (file==0)
1400     {
1401         return -1;
1402     }
1403
1404     /* check if serial header exists, ignore if found */
1405     if (fread(dltSerialHeaderBuffer,sizeof(dltSerialHeaderBuffer),1,file->handle)!=1)
1406     {
1407         /* cannot read serial header, not enough data available in file */
1408         if (!feof(file->handle))
1409         {
1410             dlt_log(LOG_ERR, "Cannot read header from file!\n");
1411         }
1412         return -1;
1413     }
1414     if (memcmp(dltSerialHeaderBuffer,dltSerialHeader,sizeof(dltSerialHeader)) == 0)
1415     {
1416         /* serial header found */
1417         /* nothing to do continue reading */
1418
1419     }
1420     else
1421     {
1422         /* serial header not found */
1423         if(resync)
1424         {
1425             /* increase error counter */
1426             file->error_messages++;
1427
1428             /* resync to serial header */
1429             do
1430             {
1431                 memmove(dltSerialHeaderBuffer,dltSerialHeaderBuffer+1,sizeof(dltSerialHeader)-1);
1432                 if (fread(dltSerialHeaderBuffer+3,1,1,file->handle)!=1)
1433                 {
1434                     /* cannot read any data, perhaps end of file reached */
1435                     return -1;
1436                 }
1437                 if (memcmp(dltSerialHeaderBuffer,dltSerialHeader,sizeof(dltSerialHeader)) == 0)
1438                 {
1439                     /* serial header synchronised */
1440                     break;
1441                 }
1442             } while(1);
1443         }
1444         else
1445         {
1446             /* go back to last file position */
1447             if (0 != fseek(file->handle,file->file_position,SEEK_SET))
1448                 return -1;
1449         }
1450     }
1451
1452     /* load header from file */
1453     if (fread(file->msg.headerbuffer+sizeof(DltStorageHeader),sizeof(DltStandardHeader),1,file->handle)!=1)
1454     {
1455         if (!feof(file->handle))
1456         {
1457             dlt_log(LOG_ERR, "Cannot read header from file!\n");
1458         }
1459         return -1;
1460     }
1461
1462     /* set ptrs to structures */
1463     file->msg.storageheader = (DltStorageHeader*) file->msg.headerbuffer; // this points now to a empty storage header (filled with '0')
1464     file->msg.standardheader = (DltStandardHeader*) (file->msg.headerbuffer + sizeof(DltStorageHeader));
1465
1466     /* Skip storage header field, fill this field with '0' */
1467     memset(file->msg.storageheader,0,sizeof(DltStorageHeader));
1468
1469     /* Set storage header */
1470     dlt_set_storageheader(file->msg.storageheader,DLT_COMMON_DUMMY_ECUID);
1471
1472     /* no check for storage header id*/
1473
1474     /* calculate complete size of headers */
1475     file->msg.headersize = sizeof(DltStorageHeader) + sizeof(DltStandardHeader) +
1476                            DLT_STANDARD_HEADER_EXTRA_SIZE(file->msg.standardheader->htyp) + (DLT_IS_HTYP_UEH(file->msg.standardheader->htyp) ? sizeof(DltExtendedHeader) : 0);
1477     file->msg.datasize = DLT_BETOH_16(file->msg.standardheader->len) + sizeof(DltStorageHeader) - file->msg.headersize;
1478     if (verbose)
1479     {
1480         snprintf(str,DLT_COMMON_BUFFER_LENGTH,"Header Size: %d\n",file->msg.headersize);
1481         dlt_log(LOG_INFO, str);
1482     }
1483     if (verbose)
1484     {
1485         snprintf(str,DLT_COMMON_BUFFER_LENGTH,"Data Size: %d\n",file->msg.datasize);
1486         dlt_log(LOG_INFO, str);
1487     }
1488
1489     /* check data size */
1490     if (file->msg.datasize < 0)
1491     {
1492         snprintf(str,DLT_COMMON_BUFFER_LENGTH,"Plausibility check failed. Complete message size too short! (%d)\n", file->msg.datasize);
1493         dlt_log(LOG_ERR, str);
1494         return -1;
1495     }
1496
1497     return 0;
1498 }
1499
1500 int dlt_file_read_header_extended(DltFile *file, int verbose)
1501 {
1502     PRINT_FUNCTION_VERBOSE(verbose);
1503
1504     if (file==0)
1505     {
1506         return -1;
1507     }
1508
1509     /* load standard header extra parameters if used */
1510     if (DLT_STANDARD_HEADER_EXTRA_SIZE(file->msg.standardheader->htyp))
1511     {
1512         if (fread(file->msg.headerbuffer+sizeof(DltStorageHeader)+sizeof(DltStandardHeader),
1513                   DLT_STANDARD_HEADER_EXTRA_SIZE(file->msg.standardheader->htyp),
1514                   1,file->handle)!=1)
1515         {
1516             dlt_log(LOG_ERR, "Cannot read standard header extra parameters from file!\n");
1517             return -1;
1518         }
1519
1520         dlt_message_get_extraparameters(&(file->msg),verbose);
1521     }
1522
1523     /* load Extended header if used */
1524     if (DLT_IS_HTYP_UEH(file->msg.standardheader->htyp)==0)
1525     {
1526         /* there is nothing to be loaded */
1527         return 0;
1528     }
1529
1530     if (fread(file->msg.headerbuffer+sizeof(DltStorageHeader)+sizeof(DltStandardHeader)+DLT_STANDARD_HEADER_EXTRA_SIZE(file->msg.standardheader->htyp),
1531               (DLT_IS_HTYP_UEH(file->msg.standardheader->htyp) ? sizeof(DltExtendedHeader) : 0),
1532               1,file->handle)!=1)
1533     {
1534         dlt_log(LOG_ERR, "Cannot read extended header from file!\n");
1535         return -1;
1536     }
1537
1538     /* set extended header ptr */
1539     if (DLT_IS_HTYP_UEH(file->msg.standardheader->htyp))
1540     {
1541         file->msg.extendedheader = (DltExtendedHeader*) (file->msg.headerbuffer + sizeof(DltStorageHeader) + sizeof(DltStandardHeader) +
1542                                    DLT_STANDARD_HEADER_EXTRA_SIZE(file->msg.standardheader->htyp));
1543     }
1544     else
1545     {
1546         file->msg.extendedheader = 0;
1547     }
1548
1549     return 0;
1550 }
1551
1552 int dlt_file_read_data(DltFile *file, int verbose)
1553 {
1554     PRINT_FUNCTION_VERBOSE(verbose);
1555
1556     if (file==0)
1557     {
1558         return -1;
1559     }
1560
1561     /* free last used memory for buffer */
1562     if (file->msg.databuffer && (file->msg.databuffersize < file->msg.datasize))
1563     {
1564         free(file->msg.databuffer);
1565         file->msg.databuffer=0;
1566     }
1567
1568     if (file->msg.databuffer == 0){
1569         /* get new memory for buffer */
1570         file->msg.databuffer = (uint8_t *)malloc(file->msg.datasize);
1571         file->msg.databuffersize = file->msg.datasize;
1572     }
1573
1574     if (file->msg.databuffer == 0)
1575     {
1576         snprintf(str,DLT_COMMON_BUFFER_LENGTH,"Cannot allocate memory for payload buffer of size %d!\n",file->msg.datasize);
1577         dlt_log(LOG_ERR, str);
1578         return -1;
1579     }
1580
1581     /* load payload data from file */
1582     if (fread(file->msg.databuffer,file->msg.datasize,1,file->handle)!=1)
1583     {
1584         if (file->msg.datasize!=0)
1585         {
1586             snprintf(str,DLT_COMMON_BUFFER_LENGTH,"Cannot read payload data from file of size %d!\n",file->msg.datasize);
1587             dlt_log(LOG_ERR, str);
1588             return -1;
1589         }
1590     }
1591
1592     return 0;
1593 }
1594
1595 int dlt_file_open(DltFile *file,const char *filename,int verbose)
1596 {
1597     PRINT_FUNCTION_VERBOSE(verbose);
1598
1599     if (file==0)
1600     {
1601         return -1;
1602     }
1603
1604     /* reset counters */
1605     file->counter = 0;
1606     file->counter_total = 0;
1607     file->position = 0;
1608     file->file_position = 0;
1609     file->file_length = 0;
1610     file->error_messages = 0;
1611
1612     if (file->handle)
1613     {
1614         fclose(file->handle);
1615     }
1616
1617     /* open dlt file */
1618     file->handle = fopen(filename,"rb");
1619     if (file->handle == 0)
1620     {
1621         snprintf(str, DLT_COMMON_BUFFER_LENGTH - 1 ,"File %s cannot be opened!\n",filename);
1622
1623         dlt_log(LOG_ERR, str);
1624         return -1;
1625     }
1626
1627     if (0 != fseek(file->handle,0,SEEK_END))
1628     {
1629         snprintf(str,DLT_COMMON_BUFFER_LENGTH,"dlt_file_open: Seek failed to 0,SEEK_END");
1630         dlt_log(LOG_ERR, str);
1631         return -1;
1632     }
1633     file->file_length = ftell(file->handle);
1634
1635     if (0 != fseek(file->handle,0,SEEK_SET))
1636     {
1637         snprintf(str,DLT_COMMON_BUFFER_LENGTH,"dlt_file_open: Seek failed to 0,SEEK_SET");
1638         dlt_log(LOG_ERR, str);
1639         return -1;
1640     }
1641
1642     if (verbose)
1643     {
1644         /* print file length */
1645         snprintf(str,DLT_COMMON_BUFFER_LENGTH,"File is %lu bytes long\n",file->file_length);
1646         dlt_log(LOG_INFO, str);
1647     }
1648     return 0;
1649 }
1650
1651 int dlt_file_read(DltFile *file,int verbose)
1652 {
1653     long *ptr;
1654     int found = 0;
1655
1656     if (verbose)
1657     {
1658         snprintf(str,DLT_COMMON_BUFFER_LENGTH,"%s: Message %d:\n",__func__, file->counter_total);
1659         dlt_log(LOG_INFO, str);
1660     }
1661
1662     if (file==0)
1663     {
1664         return -1;
1665     }
1666
1667     /* allocate new memory for index if number of messages exceeds a multiple of DLT_COMMON_INDEX_ALLOC (e.g.: 1000) */
1668     if (file->counter % DLT_COMMON_INDEX_ALLOC == 0)
1669     {
1670         ptr = (long *) malloc(((file->counter/DLT_COMMON_INDEX_ALLOC) + 1) * DLT_COMMON_INDEX_ALLOC * sizeof(long));
1671
1672         if (ptr==0)
1673         {
1674             return -1;
1675         }
1676
1677         if (file->index)
1678         {
1679             memcpy(ptr,file->index,file->counter * sizeof(long));
1680             free(file->index);
1681         }
1682         file->index = ptr;
1683     }
1684
1685     /* set to end of last succesful read message, because of conflicting calls to dlt_file_read and dlt_file_message */
1686     if (0 !=  fseek(file->handle,file->file_position,SEEK_SET))
1687     {
1688         snprintf(str,DLT_COMMON_BUFFER_LENGTH,"Seek failed to file_position %ld \n",file->file_position);
1689         dlt_log(LOG_ERR, str);
1690         return -1;
1691     }
1692
1693     /* get file position at start of DLT message */
1694     if (verbose)
1695     {
1696         snprintf(str,DLT_COMMON_BUFFER_LENGTH,"Position in file: %ld\n",file->file_position);
1697         dlt_log(LOG_INFO, str);
1698     }
1699
1700     /* read header */
1701     if (dlt_file_read_header(file,verbose)<0)
1702     {
1703         /* go back to last position in file */
1704         fseek(file->handle,file->file_position,SEEK_SET);
1705         return -1;
1706     }
1707
1708     if (file->filter)
1709     {
1710         /* read the extended header if filter is enabled and extended header exists */
1711         if (dlt_file_read_header_extended(file, verbose)<0)
1712         {
1713             /* go back to last position in file */
1714             if (0 != fseek(file->handle,file->file_position,SEEK_SET))
1715             {
1716                 snprintf(str,DLT_COMMON_BUFFER_LENGTH,"Seek to last file pos failed!\n");
1717                 dlt_log(LOG_ERR, str);
1718             }
1719             return-1;
1720         }
1721
1722         /* check the filters if message is used */
1723         if (dlt_message_filter_check(&(file->msg),file->filter,verbose) == 1)
1724         {
1725             /* filter matched, consequently store current message */
1726             /* store index pointer to message position in DLT file */
1727             file->index[file->counter] = file->file_position;
1728             file->counter++;
1729             file->position = file->counter - 1;
1730
1731             found = 1;
1732         }
1733
1734         /* skip payload data */
1735         if (fseek(file->handle,file->msg.datasize,SEEK_CUR)!=0)
1736         {
1737             /* go back to last position in file */
1738             snprintf(str,DLT_COMMON_BUFFER_LENGTH,"Seek failed to skip payload data of size %d!\n",file->msg.datasize);
1739             dlt_log(LOG_ERR, str);
1740
1741             if (0 != fseek(file->handle,file->file_position,SEEK_SET))
1742             {
1743                 snprintf(str,DLT_COMMON_BUFFER_LENGTH,"Seek back also failed!\n");
1744                 dlt_log(LOG_ERR, str);
1745             }
1746
1747             return -1;
1748         }
1749     }
1750     else
1751     {
1752         /* filter is disabled */
1753         /* skip additional header parameters and payload data */
1754         if (fseek(file->handle,file->msg.headersize - sizeof(DltStorageHeader) - sizeof(DltStandardHeader) + file->msg.datasize,SEEK_CUR))
1755         {
1756
1757             snprintf(str,DLT_COMMON_BUFFER_LENGTH,"Seek failed to skip extra header and payload data from file of size %d!\n",
1758                     file->msg.headersize - sizeof(DltStorageHeader) - sizeof(DltStandardHeader) + file->msg.datasize);
1759             dlt_log(LOG_ERR, str);
1760             /* go back to last position in file */
1761             if (fseek(file->handle,file->file_position,SEEK_SET))
1762             {
1763                 snprintf(str,DLT_COMMON_BUFFER_LENGTH,"Seek back also failed!\n");
1764                 dlt_log(LOG_ERR, str);
1765             }
1766             return -1;
1767         }
1768
1769         /* store index pointer to message position in DLT file */
1770         file->index[file->counter] = file->file_position;
1771         file->counter++;
1772         file->position = file->counter - 1;
1773
1774         found = 1;
1775     }
1776
1777     /* increase total message counter */
1778     file->counter_total++;
1779
1780     /* store position to next message */
1781     file->file_position = ftell(file->handle);
1782
1783     return found;
1784 }
1785
1786 int dlt_file_read_raw(DltFile *file,int resync, int verbose)
1787 {
1788     int found = 0;
1789     long *ptr;
1790
1791     if (verbose)
1792     {
1793         snprintf(str,DLT_COMMON_BUFFER_LENGTH,"%s: Message %d:\n",__func__, file->counter_total);
1794         dlt_log(LOG_INFO, str);
1795     }
1796
1797     if (file==0)
1798         return -1;
1799
1800     /* allocate new memory for index if number of messages exceeds a multiple of DLT_COMMON_INDEX_ALLOC (e.g.: 1000) */
1801     if (file->counter % DLT_COMMON_INDEX_ALLOC == 0)
1802     {
1803         ptr = (long *) malloc(((file->counter/DLT_COMMON_INDEX_ALLOC) + 1) * DLT_COMMON_INDEX_ALLOC * sizeof(long));
1804
1805         if (ptr==0)
1806         {
1807             return -1;
1808         }
1809
1810         if (file->index)
1811         {
1812             memcpy(ptr,file->index,file->counter * sizeof(long));
1813             free(file->index);
1814         }
1815         file->index = ptr;
1816     }
1817
1818     /* set to end of last successful read message, because of conflicting calls to dlt_file_read and dlt_file_message */
1819     if (0 != fseek(file->handle,file->file_position,SEEK_SET))
1820         return -1;
1821
1822     /* get file position at start of DLT message */
1823     if (verbose)
1824     {
1825         snprintf(str,DLT_COMMON_BUFFER_LENGTH,"Position in file: %ld\n",file->file_position);
1826         dlt_log(LOG_INFO, str);
1827     }
1828
1829     /* read header */
1830     if (dlt_file_read_header_raw(file,resync,verbose)<0)
1831     {
1832         /* go back to last position in file */
1833         if (0!= fseek(file->handle,file->file_position,SEEK_SET))
1834         {
1835             snprintf(str,DLT_COMMON_BUFFER_LENGTH,"dlt_file_read_raw, fseek failed 1\n");
1836             dlt_log(LOG_ERR, str);
1837         }
1838         return -1;
1839     }
1840
1841     /* read the extended header if filter is enabled and extended header exists */
1842     if (dlt_file_read_header_extended(file, verbose)<0)
1843     {
1844         /* go back to last position in file */
1845         if (0 != fseek(file->handle,file->file_position,SEEK_SET))
1846         {
1847             snprintf(str,DLT_COMMON_BUFFER_LENGTH,"dlt_file_read_raw, fseek failed 2\n");
1848             dlt_log(LOG_ERR, str);
1849         }
1850         return-1;
1851     }
1852
1853     if (dlt_file_read_data(file,verbose)<0)
1854     {
1855         /* go back to last position in file */
1856         if (0 != fseek(file->handle,file->file_position,SEEK_SET))
1857         {
1858             snprintf(str,DLT_COMMON_BUFFER_LENGTH,"dlt_file_read_raw, fseek failed 3\n");
1859             dlt_log(LOG_ERR, str);
1860         }
1861         return-1;
1862     }
1863
1864     /* store index pointer to message position in DLT file */
1865     file->index[file->counter] = file->file_position;
1866     file->counter++;
1867     file->position = file->counter - 1;
1868
1869     found = 1;
1870
1871     /* increase total message counter */
1872     file->counter_total++;
1873
1874     /* store position to next message */
1875     file->file_position = ftell(file->handle);
1876
1877     return found;
1878 }
1879
1880 int dlt_file_close(DltFile *file,int verbose)
1881 {
1882     PRINT_FUNCTION_VERBOSE(verbose);
1883
1884     if (file==0)
1885     {
1886         return -1;
1887     }
1888
1889     if (file->handle)
1890     {
1891         fclose(file->handle);
1892     }
1893
1894     file->handle = 0;
1895
1896     return 0;
1897 }
1898
1899 int dlt_file_message(DltFile *file,int index,int verbose)
1900 {
1901     PRINT_FUNCTION_VERBOSE(verbose);
1902
1903     if (file==0)
1904     {
1905         return -1;
1906     }
1907
1908     /* check if message is in range */
1909     if (index >= file->counter)
1910     {
1911         snprintf(str,DLT_COMMON_BUFFER_LENGTH,"Message %d out of range!\r\n",index);
1912         dlt_log(LOG_ERR, str);
1913         return -1;
1914     }
1915
1916     /* seek to position in file */
1917     if (fseek(file->handle,file->index[index],SEEK_SET)!=0)
1918     {
1919         snprintf(str,DLT_COMMON_BUFFER_LENGTH,"Seek to message %d to position %ld failed!\r\n",index,file->index[index]);
1920         dlt_log(LOG_ERR, str);
1921         return -1;
1922     }
1923
1924     /* read all header and payload */
1925     if (dlt_file_read_header(file,verbose)<0)
1926     {
1927         return -1;
1928     }
1929
1930     if (dlt_file_read_header_extended(file,verbose)<0)
1931     {
1932         return -1;
1933     }
1934
1935     if (dlt_file_read_data(file,verbose)<0)
1936     {
1937         return -1;
1938     }
1939
1940     /* set current position in file */
1941     file->position = index;
1942
1943     return 0;
1944 }
1945
1946 int dlt_file_free(DltFile *file,int verbose)
1947 {
1948     PRINT_FUNCTION_VERBOSE(verbose);
1949
1950     if (file==0)
1951     {
1952         return -1;
1953     }
1954
1955     /* delete index lost if exists */
1956     if (file->index)
1957     {
1958         free(file->index);
1959     }
1960     file->index = 0;
1961
1962     /* close file */
1963     if (file->handle)
1964     {
1965         fclose(file->handle);
1966     }
1967     file->handle = 0;
1968
1969     return dlt_message_free(&(file->msg),verbose);
1970 }
1971
1972 void dlt_log_set_level(int level)
1973 {
1974         logging_level = level;
1975 }
1976
1977 void dlt_log_set_filename(const char *filename)
1978 {
1979         strncpy(logging_filename,filename,NAME_MAX);
1980         logging_filename[NAME_MAX]=0;
1981
1982 }
1983
1984 void dlt_log_init(int mode)
1985 {
1986     logging_mode = mode;
1987
1988         if(logging_mode == DLT_LOG_TO_FILE)
1989         {
1990                 /* internal logging to file */
1991                 logging_handle = fopen(logging_filename,"w");
1992                 if (logging_handle == 0)
1993                 {
1994                         printf("Internal log file %s cannot be opened!\n",logging_filename);
1995                         return;
1996                 }
1997         }
1998 }
1999
2000 void dlt_log_free(void)
2001 {
2002         if(logging_mode == DLT_LOG_TO_FILE) {
2003                 fclose(logging_handle);
2004         }
2005 }
2006
2007 int dlt_log(int prio, char *s)
2008 {
2009     char logfmtstring[DLT_COMMON_BUFFER_LENGTH];
2010
2011     if (s==0)
2012     {
2013         return -1;
2014     }
2015         if(logging_level<prio)
2016         {
2017                 return 0;
2018         }
2019
2020     switch (prio)
2021     {
2022         case    LOG_EMERG:
2023         {
2024             strncpy(logfmtstring,"DLT| EMERGENCY: %s",sizeof(logfmtstring)-1);
2025             logfmtstring[sizeof(logfmtstring)-1]=0;
2026             break;
2027         }
2028         case    LOG_ALERT:
2029         {
2030             strncpy(logfmtstring,"DLT| ALERT:     %s",sizeof(logfmtstring)-1);
2031             logfmtstring[sizeof(logfmtstring)-1]=0;
2032             break;
2033         }
2034         case    LOG_CRIT:
2035         {
2036             strncpy(logfmtstring,"DLT| CRITICAL:  %s",sizeof(logfmtstring)-1);
2037             logfmtstring[sizeof(logfmtstring)-1]=0;
2038             break;
2039         }
2040         case    LOG_ERR:
2041         {
2042             strncpy(logfmtstring,"DLT| ERROR:     %s",sizeof(logfmtstring)-1);
2043             logfmtstring[sizeof(logfmtstring)-1]=0;
2044             break;
2045         }
2046         case    LOG_WARNING:
2047         {
2048             strncpy(logfmtstring,"DLT| WARNING:   %s",sizeof(logfmtstring)-1);
2049             logfmtstring[sizeof(logfmtstring)-1]=0;
2050             break;
2051         }
2052         case    LOG_NOTICE:
2053         {
2054             strncpy(logfmtstring,"DLT| NOTICE:    %s",sizeof(logfmtstring)-1);
2055             logfmtstring[sizeof(logfmtstring)-1]=0;
2056             break;
2057         }
2058         case    LOG_INFO:
2059         {
2060             strncpy(logfmtstring,"DLT| INFO:      %s",sizeof(logfmtstring)-1);
2061             logfmtstring[sizeof(logfmtstring)-1]=0;
2062             break;
2063         }
2064         case    LOG_DEBUG:
2065         {
2066             strncpy(logfmtstring,"DLT| DEBUG:     %s",sizeof(logfmtstring)-1);
2067             logfmtstring[sizeof(logfmtstring)-1]=0;
2068             break;
2069         }
2070         default:
2071         {
2072             strncpy(logfmtstring,"DLT|            %s",sizeof(logfmtstring)-1);
2073             logfmtstring[sizeof(logfmtstring)-1]=0;
2074             break;
2075         }
2076     }
2077
2078         switch(logging_mode)
2079         {
2080                 case DLT_LOG_TO_CONSOLE:
2081                         /* log to stdout */
2082                         printf(logfmtstring, s);
2083                         break;
2084                 case DLT_LOG_TO_SYSLOG:
2085                         /* log to syslog */
2086 #if !defined (__WIN32__) && !defined(_MSC_VER)
2087                         openlog("DLT",LOG_PID,LOG_DAEMON);
2088                         syslog(prio, logfmtstring, s);
2089                         closelog();
2090 #endif
2091                         break;
2092                 case DLT_LOG_TO_FILE:
2093                         /* log to file */
2094                         if(logging_handle) {
2095                                 fprintf(logging_handle,logfmtstring, s);
2096                                 fflush(logging_handle);
2097                         }
2098                         break;
2099                 case DLT_LOG_DROPPED:
2100                 default:
2101                         break;
2102         }
2103
2104     return 0;
2105 }
2106
2107 int dlt_receiver_init(DltReceiver *receiver,int fd, int buffersize)
2108 {
2109     if (receiver==0)
2110     {
2111         return -1;
2112     }
2113
2114     receiver->lastBytesRcvd = 0;
2115     receiver->bytesRcvd = 0;
2116     receiver->totalBytesRcvd = 0;
2117     receiver->buffersize = buffersize;
2118     receiver->fd = fd;
2119     receiver->buffer = (char*)malloc(receiver->buffersize);
2120
2121     if (receiver->buffer == 0)
2122     {
2123         receiver->buf = 0;
2124         return -1;
2125     }
2126     else
2127     {
2128         receiver->buf = receiver->buffer;
2129     }
2130
2131     return 0;
2132 }
2133
2134 int dlt_receiver_free(DltReceiver *receiver)
2135 {
2136
2137     if (receiver==0)
2138     {
2139         return -1;
2140     }
2141
2142     if (receiver->buffer)
2143     {
2144         free(receiver->buffer);
2145     }
2146
2147     receiver->buffer = 0;
2148     receiver->buf = 0;
2149
2150     return 0;
2151 }
2152
2153 #ifndef QT_VIEWER
2154 int dlt_receiver_receive_socket(DltReceiver *receiver)
2155 {
2156     if (receiver==0)
2157     {
2158         return -1;
2159     }
2160
2161     if (receiver->buffer==0)
2162     {
2163         return -1;
2164     }
2165
2166     receiver->buf = (char *)receiver->buffer;
2167     receiver->lastBytesRcvd = receiver->bytesRcvd;
2168
2169     /* wait for data from socket */
2170     if ((receiver->bytesRcvd = recv(receiver->fd, receiver->buf + receiver->lastBytesRcvd, receiver->buffersize - receiver->lastBytesRcvd , 0)) <= 0)
2171     {
2172         receiver->bytesRcvd = 0;
2173
2174         return receiver->bytesRcvd;
2175     } /* if */
2176
2177     receiver->totalBytesRcvd += receiver->bytesRcvd;
2178     receiver->bytesRcvd += receiver->lastBytesRcvd;
2179
2180     return receiver->bytesRcvd;
2181 }
2182 #endif
2183
2184 int dlt_receiver_receive_fd(DltReceiver *receiver)
2185 {
2186     if (receiver==0)
2187     {
2188         return -1;
2189     }
2190
2191     if (receiver->buffer==0)
2192     {
2193         return -1;
2194     }
2195
2196     receiver->buf = (char *)receiver->buffer;
2197     receiver->lastBytesRcvd = receiver->bytesRcvd;
2198
2199     /* wait for data from fd */
2200     if ((receiver->bytesRcvd = read(receiver->fd, receiver->buf + receiver->lastBytesRcvd, receiver->buffersize - receiver->lastBytesRcvd)) <= 0)
2201     {
2202         receiver->bytesRcvd = 0;
2203
2204         return receiver->bytesRcvd;
2205     } /* if */
2206
2207     receiver->totalBytesRcvd += receiver->bytesRcvd;
2208     receiver->bytesRcvd += receiver->lastBytesRcvd;
2209
2210     return receiver->bytesRcvd;
2211 }
2212
2213 int dlt_receiver_remove(DltReceiver *receiver,int size)
2214 {
2215     if (receiver==0)
2216     {
2217         return -1;
2218     }
2219
2220     if (receiver->buf==0)
2221     {
2222         return -1;
2223     }
2224
2225     if (size > receiver->bytesRcvd || size <= 0)
2226     {
2227         receiver->buf = receiver->buf + receiver->bytesRcvd;
2228         receiver->bytesRcvd=0;
2229         return -1;
2230     }
2231
2232     receiver->bytesRcvd = receiver->bytesRcvd - size;
2233     receiver->buf = receiver->buf + size;
2234
2235     return 0;
2236 }
2237
2238 int dlt_receiver_move_to_begin(DltReceiver *receiver)
2239 {
2240     if (receiver==0)
2241     {
2242         return -1;
2243     }
2244
2245     if ((receiver->buffer==0) || (receiver->buf==0))
2246     {
2247         return -1;
2248     }
2249
2250     if ((receiver->buffer!=receiver->buf) && (receiver->bytesRcvd!=0))
2251     {
2252         memmove(receiver->buffer,receiver->buf,receiver->bytesRcvd);
2253     }
2254
2255     return 0;
2256 }
2257
2258 int dlt_set_storageheader(DltStorageHeader *storageheader, const char *ecu)
2259 {
2260
2261 #if !defined(_MSC_VER)
2262     struct timeval tv;
2263 #endif
2264
2265     if (storageheader==0)
2266     {
2267         return -1;
2268     }
2269
2270     /* get time of day */
2271 #if defined(_MSC_VER)
2272     time(&(storageheader->seconds));
2273 #else
2274     gettimeofday(&tv, NULL);
2275 #endif
2276
2277     /* prepare storage header */
2278     storageheader->pattern[0] = 'D';
2279     storageheader->pattern[1] = 'L';
2280     storageheader->pattern[2] = 'T';
2281     storageheader->pattern[3] = 0x01;
2282
2283     dlt_set_id(storageheader->ecu,ecu);
2284
2285     /* Set current time */
2286 #if defined(_MSC_VER)
2287     storageheader->microseconds = 0;
2288 #else
2289     storageheader->seconds = (time_t)tv.tv_sec; /* value is long */
2290     storageheader->microseconds = (int32_t)tv.tv_usec; /* value is long */
2291 #endif
2292
2293     return 0;
2294 }
2295
2296 int dlt_check_storageheader(DltStorageHeader *storageheader)
2297 {
2298     if (storageheader==0)
2299     {
2300         return -1;
2301     }
2302
2303     return  ((storageheader->pattern[0] == 'D') &&
2304              (storageheader->pattern[1] == 'L') &&
2305              (storageheader->pattern[2] == 'T') &&
2306              (storageheader->pattern[3] == 1));
2307 }
2308
2309
2310
2311
2312
2313
2314
2315
2316
2317
2318
2319
2320 int dlt_buffer_init_static_server(DltBuffer *buf, const unsigned char *ptr, uint32_t size)
2321 {
2322         char str[256];
2323         DltBufferHead *head;
2324
2325         // Init parameters
2326         buf->shm = (unsigned char *)ptr;
2327         buf->min_size = size;
2328         buf->max_size = size;
2329         buf->step_size = 0;
2330
2331         // Init pointers
2332         head = (DltBufferHead*)buf->shm;
2333         head->read = 0;
2334         head->write = 0;
2335         head->count = 0;
2336     buf->mem = (unsigned char *)(buf->shm + sizeof(DltBufferHead));
2337         buf->size = buf->min_size - sizeof(DltBufferHead);
2338
2339         // clear memory
2340         memset(buf->mem,0,buf->size);
2341
2342         snprintf(str,sizeof(str),"Buffer: Size %d\n",buf->size);
2343         dlt_log(LOG_INFO, str);
2344
2345         return 0; /* OK */
2346 }
2347
2348 int dlt_buffer_init_static_client(DltBuffer *buf, const unsigned char *ptr, uint32_t size)
2349 {
2350         char str[256];
2351
2352         // Init parameters
2353         buf->shm = (unsigned char *)ptr;
2354         buf->min_size = size;
2355         buf->max_size = size;
2356         buf->step_size = 0;
2357
2358         // Init pointers
2359     buf->mem = (unsigned char *)(buf->shm + sizeof(DltBufferHead));
2360     buf->size = buf->min_size - sizeof(DltBufferHead);
2361
2362         snprintf(str,sizeof(str),"Buffer: Size %d\n",buf->size);
2363         dlt_log(LOG_INFO, str);
2364
2365         return 0; /* OK */
2366 }
2367
2368 int dlt_buffer_init_dynamic(DltBuffer *buf, uint32_t min_size, uint32_t max_size,uint32_t step_size)
2369 {
2370     //Do not DLT_SEM_LOCK inside here!
2371         char str[256];
2372         DltBufferHead *head;
2373
2374         // Init parameters
2375         buf->min_size = min_size;
2376         buf->max_size = max_size;
2377         buf->step_size = step_size;
2378
2379         // allocat memory
2380         buf->shm = malloc(buf->min_size);
2381         if(buf->shm == NULL) {
2382                 snprintf(str,sizeof(str),"Buffer: Cannot allocate %d bytes\n",buf->min_size);
2383                 dlt_log(LOG_EMERG, str);
2384                 return -1;
2385         }
2386
2387         // Init pointers
2388         head = (DltBufferHead*)buf->shm;
2389         head->read = 0;
2390         head->write = 0;
2391         head->count = 0;
2392     buf->mem = (unsigned char *)(buf->shm + sizeof(DltBufferHead));
2393     buf->size = buf->min_size - sizeof(DltBufferHead);
2394
2395         // clear memory
2396         memset(buf->mem,0,buf->size);
2397
2398         //snprintf(str,sizeof(str),"Buffer: Size %d bytes\n",buf->size);
2399         //dlt_log(LOG_INFO, str);
2400
2401         return 0; /* OK */
2402 }
2403
2404 int dlt_buffer_free_static(DltBuffer *buf)
2405 {
2406         if(!buf->mem) {
2407                 // buffer not initialised
2408                 dlt_log(LOG_ERR,"Buffer: Buffer not initialised\n");
2409                 return -1; /* ERROR */
2410         }
2411
2412         return 0;
2413 }
2414
2415 int dlt_buffer_free_dynamic(DltBuffer *buf)
2416 {
2417         if(!buf->shm) {
2418                 // buffer not initialised
2419                 dlt_log(LOG_ERR,"Buffer: Buffer not initialised\n");
2420                 return -1; /* ERROR */
2421         }
2422
2423         free(buf->shm);
2424         buf->shm = 0;
2425         buf->mem = 0;
2426
2427         return 0;
2428 }
2429
2430 void dlt_buffer_write_block(DltBuffer *buf,int *write, const unsigned char *data,unsigned int size)
2431 {
2432         if((int)(*write+size) <= buf->size) {
2433                 // write one block
2434                 memcpy(buf->mem+*write,data,size);
2435                 *write += size;
2436         }
2437         else {
2438                 // write two blocks
2439                 memcpy(buf->mem+*write, data, buf->size-*write);
2440                 memcpy(buf->mem, data+buf->size-*write, size-buf->size+*write);
2441                 *write += size-buf->size;
2442         }
2443 }
2444
2445 void dlt_buffer_read_block(DltBuffer *buf,int *read,unsigned char *data,unsigned int size)
2446 {
2447         if((int)(*read+size) <= buf->size) {
2448                 // read one block
2449                 memcpy(data,buf->mem+*read,size);
2450                 *read += size;
2451         }
2452         else {
2453                 // read two blocks
2454                 memcpy(data, buf->mem+*read, buf->size-*read);
2455                 memcpy(data+buf->size-*read, buf->mem, size-buf->size+*read);
2456                 *read += size-buf->size;
2457         }
2458 }
2459
2460 int dlt_buffer_increase_size(DltBuffer *buf)
2461 {
2462         DltBufferHead *head,*new_head;
2463         unsigned char *new_ptr;
2464
2465         /* check size */
2466         if(buf->step_size==0) {
2467                 /* cannot increase size */
2468                 return -1;
2469         }
2470
2471         /* check size */
2472         if((buf->size + sizeof(DltBufferHead) + buf->step_size) > buf->max_size) {
2473                 /* max size reached, do not increase */
2474                 return -1;
2475         }
2476
2477         /* allocate new buffer */
2478         new_ptr = malloc(buf->size + sizeof(DltBufferHead) + buf->step_size);
2479         if(new_ptr == NULL) {
2480                 snprintf(str,sizeof(str),"Buffer: Cannot increase size because allocate %d bytes failed\n",buf->min_size);
2481                 dlt_log(LOG_WARNING, str);
2482                 return -1;
2483         }
2484
2485         /* copy data */
2486         head = (DltBufferHead*)buf->shm;
2487         new_head = (DltBufferHead*)new_ptr;
2488         if(head->read < head->write) {
2489                 memcpy(new_ptr+sizeof(DltBufferHead) , buf->mem+head->read , head->write-head->read);
2490                 new_head->read = 0;
2491                 new_head->write = head->write-head->read;
2492                 new_head->count = head->count;
2493         }
2494         else {
2495                 memcpy(new_ptr+sizeof(DltBufferHead) , buf->mem+head->read , buf->size-head->read);
2496                 memcpy(new_ptr+sizeof(DltBufferHead)+buf->size-head->read , buf->mem , head->write);
2497                 new_head->read = 0;
2498                 new_head->write = buf->size-head->read+head->write;
2499                 new_head->count = head->count;
2500         }
2501
2502         /* free old data */
2503         free(buf->shm);
2504
2505         /* update data */
2506         buf->shm = new_ptr;
2507         buf->mem = new_ptr+sizeof(DltBufferHead);
2508         buf->size += buf->step_size;
2509
2510         snprintf(str,sizeof(str),"Buffer: Size increased to %d bytes\n",buf->size+sizeof(DltBufferHead));
2511         dlt_log(LOG_INFO, str);
2512
2513         return 0; // OK
2514 }
2515
2516 int dlt_buffer_minimize_size(DltBuffer *buf)
2517 {
2518         unsigned char *new_ptr;
2519
2520         if((buf->size + sizeof(DltBufferHead)) == buf->min_size)
2521         {
2522                 /* already minimized */
2523                 return 0;
2524         }
2525
2526         /* allocate new buffer */
2527         new_ptr = malloc(buf->min_size);
2528         if(new_ptr == NULL) {
2529                 snprintf(str,sizeof(str),"Buffer: Cannot set to min size of %d bytes\n",buf->min_size);
2530                 dlt_log(LOG_WARNING, str);
2531                 return -1;
2532         }
2533
2534         /* free old data */
2535         free(buf->shm);
2536
2537         /* update data */
2538         buf->shm = new_ptr;
2539         buf->mem = new_ptr+sizeof(DltBufferHead);
2540         buf->size = buf->min_size - sizeof(DltBufferHead);
2541
2542         /* reset pointers and counters */
2543         ((int*)(buf->shm))[0] = 0;  // pointer to write memory
2544         ((int*)(buf->shm))[1] = 0;  // pointer to read memory
2545         ((int*)(buf->shm))[2] = 0;  // number of packets
2546
2547         // clear memory
2548         memset(buf->mem,0,buf->size);
2549
2550         dlt_log(LOG_INFO,"Buffer: Buffer minimized.\n");
2551
2552         return 0; /* OK */
2553 }
2554
2555 int dlt_buffer_reset(DltBuffer *buf)
2556 {
2557         dlt_log(LOG_ERR,"Buffer: Buffer reset triggered.\n");
2558
2559         /* reset pointers and counters */
2560         ((int*)(buf->shm))[0] = 0;  // pointer to write memory
2561         ((int*)(buf->shm))[1] = 0;  // pointer to read memory
2562         ((int*)(buf->shm))[2] = 0;  // number of packets
2563
2564         // clear memory
2565         memset(buf->mem,0,buf->size);
2566
2567         return 0; /* OK */
2568 }
2569
2570 int dlt_buffer_push(DltBuffer *buf,const unsigned char *data,unsigned int size)
2571 {
2572         return dlt_buffer_push3(buf,data,size,0,0,0,0);
2573 }
2574
2575 int 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)
2576 {
2577         int free_size;
2578         int write, read, count;
2579         DltBufferBlockHead head;
2580
2581         if(!buf->shm) {
2582                 // buffer not initialised
2583                 dlt_log(LOG_ERR,"Buffer: Buffer not initialised\n");
2584                 return -1; /* ERROR */
2585         }
2586
2587         // get current write pointer
2588         write = ((int*)(buf->shm))[0];
2589         read = ((int*)(buf->shm))[1];
2590         count = ((int*)(buf->shm))[2];
2591
2592         // check pointers
2593         if((read>buf->size) || (write>buf->size))
2594         {
2595                 dlt_log(LOG_ERR,"Buffer: Pointer out of range\n");
2596                 dlt_buffer_reset(buf);
2597                 return -1; // ERROR
2598         }
2599
2600         // calculate free size
2601         if(read>write)
2602                 free_size = read - write;
2603         else if(count && (write == read))
2604                 free_size = 0;
2605         else
2606                 free_size = buf->size - write + read;
2607
2608         // check size
2609         if(free_size < (int)(sizeof(DltBufferBlockHead)+size1+size2+size3)) {
2610                 // try to increase size if possible
2611                 if(dlt_buffer_increase_size(buf)) {
2612                         /* increase size is not possible */
2613                         //dlt_log(LOG_ERR,"Buffer: Buffer is full\n");
2614                         return -1; // ERROR
2615                 }
2616                 // update pointers
2617                 write = ((int*)(buf->shm))[0];
2618                 read = ((int*)(buf->shm))[1];
2619         }
2620
2621         // set header
2622         strncpy(head.head,DLT_BUFFER_HEAD,3);
2623         head.head[3]=0;
2624         head.status = 2;
2625         head.size = size1+size2+size3;
2626
2627         // write data
2628         dlt_buffer_write_block(buf,&write,(unsigned char*)&head,sizeof(DltBufferBlockHead));
2629         if(size1) dlt_buffer_write_block(buf,&write,data1,size1);
2630         if(size2) dlt_buffer_write_block(buf,&write,data2,size2);
2631         if(size3) dlt_buffer_write_block(buf,&write,data3,size3);
2632
2633         // update global shm pointers
2634         ((int*)(buf->shm))[0] = write; // set new write pointer
2635         ((int*)(buf->shm))[2] += 1; // increase counter
2636
2637         return 0; // OK
2638
2639 }
2640
2641 int dlt_buffer_get(DltBuffer *buf,unsigned char *data, int max_size,int delete)
2642 {
2643         int used_size;
2644         int write, read, count;
2645         char head_compare[] = DLT_BUFFER_HEAD;
2646         DltBufferBlockHead head;
2647
2648         if(!buf->shm) {
2649                 // shm not initialised
2650                 dlt_log(LOG_ERR,"Buffer: SHM not initialised\n");
2651                 return -1; /* ERROR */
2652         }
2653
2654         // get current write pointer
2655         write = ((int*)(buf->shm))[0];
2656         read = ((int*)(buf->shm))[1];
2657         count = ((int*)(buf->shm))[2];
2658
2659         // check pointers
2660         if((read>buf->size) || (write>buf->size) || (count<0))
2661         {
2662                 dlt_log(LOG_ERR,"Buffer: Pointer out of range\n");
2663                 dlt_buffer_reset(buf);
2664                 return -1; // ERROR
2665         }
2666
2667         // check if data is in there
2668         if(count==0) {
2669                 if(write!=read)
2670                 {
2671                         dlt_log(LOG_ERR,"Buffer: SHM should be empty, but is not\n");
2672                         dlt_buffer_reset(buf);
2673                 }
2674                 return -1; // ERROR
2675         }
2676
2677         // calculate used size
2678         if(write>read)
2679                 used_size = write - read;
2680         else
2681                 used_size = buf->size - read + write;
2682
2683         // first check size
2684         if(used_size < (int)(sizeof(DltBufferBlockHead))) {
2685                 dlt_log(LOG_ERR,"Buffer: Size check 1 failed\n");
2686                 dlt_buffer_reset(buf);
2687                 return -1; // ERROR
2688         }
2689
2690         // read header
2691         dlt_buffer_read_block(buf,&read,(unsigned char*)&head,sizeof(DltBufferBlockHead));
2692
2693         // check header
2694         if(memcmp((unsigned char*)(head.head),head_compare,sizeof(head_compare))!=0)
2695         {
2696                 dlt_log(LOG_ERR,"Buffer: Header head check failed\n");
2697                 dlt_buffer_reset(buf);
2698                 return -1; // ERROR
2699         }
2700         if(head.status != 2)
2701         {
2702                 dlt_log(LOG_ERR,"Buffer: Header status check failed\n");
2703                 dlt_buffer_reset(buf);
2704                 return -1; // ERROR
2705         }
2706
2707         // second check size
2708         if(used_size < (int)(sizeof(DltBufferBlockHead)+head.size)) {
2709                 dlt_log(LOG_ERR,"Buffer: Size check 2 failed\n");
2710                 dlt_buffer_reset(buf);
2711                 return -1; // ERROR
2712         }
2713
2714         // third check size
2715         if(max_size && (head.size > max_size)) {
2716                 dlt_log(LOG_ERR,"Buffer: Size check 3 failed\n");
2717                 // nothing to do but data does not fit provided buffer
2718         }
2719
2720         if(data && max_size)
2721         {
2722                 // read data
2723                 dlt_buffer_read_block(buf,&read,data,head.size);
2724
2725                 if(delete)
2726                 {
2727                         // update buffer pointers
2728                         ((int*)(buf->shm))[1] = read; // set new read pointer
2729                 }
2730         }
2731         else
2732         {
2733                 if(delete) {
2734                         if( (read+head.size) <= buf->size)
2735                                 ((int*)(buf->shm))[1] = read+head.size; // set new read pointer
2736                         else
2737                                 ((int*)(buf->shm))[1] = read+head.size-buf->size; // set new read pointer
2738                 }
2739         }
2740         if(delete) {
2741                 ((int*)(buf->shm))[2] -= 1; // decrease counter
2742
2743                 if(((int*)(buf->shm))[2] == 0)
2744                 {
2745                         // try to minimize size
2746                         dlt_buffer_minimize_size(buf);
2747                 }
2748         }
2749
2750         return head.size; // OK
2751 }
2752
2753 int dlt_buffer_pull(DltBuffer *buf,unsigned char *data, int max_size)
2754 {
2755         return dlt_buffer_get(buf,data,max_size,1);
2756 }
2757
2758 int dlt_buffer_copy(DltBuffer *buf,unsigned char *data, int max_size)
2759 {
2760         return dlt_buffer_get(buf,data,max_size,0);
2761 }
2762
2763 int dlt_buffer_remove(DltBuffer *buf)
2764 {
2765         return dlt_buffer_get(buf,0,0,1);
2766 }
2767
2768 void dlt_buffer_info(DltBuffer *buf)
2769 {
2770         char str[256];
2771
2772         snprintf(str,sizeof(str),"Buffer: Available size: %d\n",buf->size);
2773         dlt_log(LOG_INFO, str);
2774         snprintf(str,sizeof(str),"Buffer: Buffer full start address: %lX\n",(unsigned long)buf->shm);
2775         dlt_log(LOG_INFO, str);
2776         snprintf(str,sizeof(str),"Buffer: Buffer start address: %lX\n",(unsigned long)buf->mem);
2777         dlt_log(LOG_INFO, str);
2778
2779 }
2780
2781 void dlt_buffer_status(DltBuffer *buf)
2782 {
2783         int write, read, count;
2784         char str[256];
2785
2786     /* check if buffer available */
2787     if(!buf->shm)
2788         return;
2789
2790         write = ((int*)(buf->shm))[0];
2791         read = ((int*)(buf->shm))[1];
2792         count = ((int*)(buf->shm))[2];
2793
2794         snprintf(str,sizeof(str),"Buffer: Write: %d\n",write);
2795         dlt_log(LOG_INFO, str);
2796         snprintf(str,sizeof(str),"Buffer: Read: %d\n",read);
2797         dlt_log(LOG_INFO, str);
2798         snprintf(str,sizeof(str),"Buffer: Count: %d\n",count);
2799         dlt_log(LOG_INFO, str);
2800 }
2801
2802 int dlt_buffer_get_total_size(DltBuffer *buf)
2803 {
2804         return buf->max_size;
2805 }
2806
2807 int dlt_buffer_get_used_size(DltBuffer *buf)
2808 {
2809         int write, read, count;
2810
2811     /* check if buffer available */
2812     if(!buf->shm)
2813         return 0;
2814
2815         write = ((int*)(buf->shm))[0];
2816         read = ((int*)(buf->shm))[1];
2817         count = ((int*)(buf->shm))[2];
2818
2819         if(count == 0)
2820                 return 0;
2821
2822         if(write>read)
2823                 return (write - read);
2824
2825         return (buf->size - read + write);
2826 }
2827
2828 int dlt_buffer_get_message_count(DltBuffer *buf)
2829 {
2830     /* check if buffer available */
2831     if(!buf->shm)
2832         return 0;
2833
2834     return ((int*)(buf->shm))[2];
2835 }
2836
2837 #if !defined (__WIN32__)
2838
2839 int dlt_setup_serial(int fd, speed_t speed)
2840 {
2841 #if !defined (__WIN32__) && !defined(_MSC_VER)
2842     struct termios config;
2843
2844     if (isatty(fd)==0)
2845     {
2846         return -1;
2847     }
2848
2849     if (tcgetattr(fd, &config) < 0)
2850     {
2851         return -1;
2852     }
2853
2854     /* Input flags - Turn off input processing
2855        convert break to null byte, no CR to NL translation,
2856        no NL to CR translation, don't mark parity errors or breaks
2857        no input parity check, don't strip high bit off,
2858        no XON/XOFF software flow control
2859     */
2860     config.c_iflag &= ~(IGNBRK | BRKINT | ICRNL |
2861                         INLCR | PARMRK | INPCK | ISTRIP | IXON);
2862
2863     /* Output flags - Turn off output processing
2864        no CR to NL translation, no NL to CR-NL translation,
2865        no NL to CR translation, no column 0 CR suppression,
2866        no Ctrl-D suppression, no fill characters, no case mapping,
2867        no local output processing
2868
2869        config.c_oflag &= ~(OCRNL | ONLCR | ONLRET |
2870                            ONOCR | ONOEOT| OFILL | OLCUC | OPOST);
2871     */
2872     config.c_oflag = 0;
2873
2874     /* No line processing:
2875        echo off, echo newline off, canonical mode off,
2876        extended input processing off, signal chars off
2877     */
2878     config.c_lflag &= ~(ECHO | ECHONL | ICANON | IEXTEN | ISIG);
2879
2880     /* Turn off character processing
2881        clear current char size mask, no parity checking,
2882        no output processing, force 8 bit input
2883     */
2884     config.c_cflag &= ~(CSIZE | PARENB);
2885     config.c_cflag |= CS8;
2886
2887     /* One input byte is enough to return from read()
2888        Inter-character timer off
2889     */
2890     config.c_cc[VMIN]  = 1;
2891     config.c_cc[VTIME] = 0;
2892
2893     /* Communication speed (simple version, using the predefined
2894        constants)
2895     */
2896     if (cfsetispeed(&config, speed) < 0 || cfsetospeed(&config, speed) < 0)
2897     {
2898         return -1;
2899     }
2900
2901     /* Finally, apply the configuration
2902     */
2903     if (tcsetattr(fd, TCSAFLUSH, &config) < 0)
2904     {
2905         return -1;
2906     }
2907
2908     return 0;
2909 #else
2910     return -1;
2911 #endif
2912 }
2913
2914 speed_t dlt_convert_serial_speed(int baudrate)
2915 {
2916 #if !defined (__WIN32__) && !defined(_MSC_VER) && !defined(__CYGWIN__)
2917     speed_t ret;
2918
2919     switch (baudrate)
2920     {
2921     case  50:
2922     {
2923         ret = B50;
2924         break;
2925     }
2926     case  75:
2927     {
2928         ret = B75;
2929         break;
2930     }
2931     case  110:
2932     {
2933         ret = B110;
2934         break;
2935     }
2936     case  134:
2937     {
2938         ret = B134;
2939         break;
2940     }
2941     case  150:
2942     {
2943         ret = B150;
2944         break;
2945     }
2946     case  200:
2947     {
2948         ret = B200;
2949         break;
2950     }
2951     case  300:
2952     {
2953         ret = B300;
2954         break;
2955     }
2956     case  600:
2957     {
2958         ret = B600;
2959         break;
2960     }
2961     case  1200:
2962     {
2963         ret = B1200;
2964         break;
2965     }
2966     case  1800:
2967     {
2968         ret = B1800;
2969         break;
2970     }
2971     case  2400:
2972     {
2973         ret = B2400;
2974         break;
2975     }
2976     case  4800:
2977     {
2978         ret = B4800;
2979         break;
2980     }
2981     case  9600:
2982     {
2983         ret = B9600;
2984         break;
2985     }
2986     case  19200:
2987     {
2988         ret = B19200;
2989         break;
2990     }
2991     case  38400:
2992     {
2993         ret = B38400;
2994         break;
2995     }
2996     case  57600:
2997     {
2998         ret = B57600;
2999         break;
3000     }
3001     case  115200:
3002     {
3003         ret = B115200;
3004         break;
3005     }
3006     case 230400:
3007     {
3008         ret = B230400;
3009         break;
3010     }
3011     case 460800:
3012     {
3013         ret = B460800;
3014         break;
3015     }
3016     case  500000:
3017     {
3018         ret = B500000;
3019         break;
3020     }
3021     case  576000:
3022     {
3023         ret = B576000;
3024         break;
3025     }
3026     case  921600:
3027     {
3028         ret = B921600;
3029         break;
3030     }
3031     case  1000000:
3032     {
3033         ret = B1000000;
3034         break;
3035     }
3036     case  1152000:
3037     {
3038         ret = B1152000;
3039         break;
3040     }
3041     case  1500000:
3042     {
3043         ret = B1500000;
3044         break;
3045     }
3046     case  2000000:
3047     {
3048         ret = B2000000;
3049         break;
3050     }
3051     case  2500000:
3052     {
3053         ret = B2500000;
3054         break;
3055     }
3056     case  3000000:
3057     {
3058         ret = B3000000;
3059         break;
3060     }
3061     case  3500000:
3062     {
3063         ret = B3500000;
3064         break;
3065     }
3066     case  4000000:
3067     {
3068         ret = B4000000;
3069         break;
3070     }
3071     default:
3072     {
3073         ret = B115200;
3074         break;
3075     }
3076     }
3077
3078     return ret;
3079 #else
3080     return 0;
3081 #endif
3082 }
3083
3084 #endif
3085
3086 void dlt_get_version(char *buf, size_t size)
3087 {
3088     snprintf(buf,size,"DLT Package Version: %s %s, Package Revision: %s, build on %s %s\n%s %s %s %s\n",
3089             _DLT_PACKAGE_VERSION, _DLT_PACKAGE_VERSION_STATE, _DLT_PACKAGE_REVISION, __DATE__ , __TIME__,_DLT_SYSTEMD_ENABLE,_DLT_SYSTEMD_WATCHDOG_ENABLE,_DLT_TEST_ENABLE,_DLT_SHM_ENABLE );
3090 }
3091
3092 void dlt_get_major_version(char *buf, size_t size)
3093 {
3094         snprintf(buf,size,"%s",_DLT_PACKAGE_MAJOR_VERSION);
3095 }
3096
3097 void dlt_get_minor_version(char *buf, size_t size)
3098 {
3099     snprintf(buf,size,"%s",_DLT_PACKAGE_MINOR_VERSION);
3100 }
3101
3102
3103 uint32_t dlt_uptime(void)
3104 {
3105
3106 #if defined (__WIN32__) || defined(_MSC_VER)
3107
3108     return (uint32_t)(GetTickCount()*10); /* GetTickCount() return DWORD */
3109
3110 #else
3111     struct timespec ts;
3112
3113     if (clock_gettime(CLOCK_MONOTONIC,&ts)==0)
3114     {
3115         return ( (uint32_t)ts.tv_sec*10000 + (uint32_t)ts.tv_nsec/100000 );// in 0.1 ms = 100 us
3116     }
3117     else
3118     {
3119         return 0;
3120     }
3121
3122 #endif
3123
3124 }
3125
3126 int dlt_message_print_header(DltMessage *message, char *text, uint32_t size, int verbose)
3127 {
3128     if ((message==0) || (text==0))
3129     {
3130         return -1;
3131     }
3132
3133     dlt_message_header(message,text,size,verbose);
3134     printf("%s\n",text);
3135
3136     return 0;
3137 }
3138
3139 int dlt_message_print_hex(DltMessage *message, char *text, uint32_t size, int verbose)
3140 {
3141     if ((message==0) || (text==0))
3142     {
3143         return -1;
3144     }
3145
3146     dlt_message_header(message,text,size,verbose);
3147     printf("%s ",text);
3148     dlt_message_payload(message,text,size,DLT_OUTPUT_HEX,verbose);
3149     printf("[%s]\n",text);
3150
3151     return 0;
3152 }
3153
3154 int dlt_message_print_ascii(DltMessage *message, char *text, uint32_t size, int verbose)
3155 {
3156     if ((message==0) || (text==0))
3157     {
3158         return -1;
3159     }
3160
3161     dlt_message_header(message,text,size,verbose);
3162     printf("%s ",text);
3163     dlt_message_payload(message,text,size,DLT_OUTPUT_ASCII,verbose);
3164     printf("[%s]\n",text);
3165
3166     return 0;
3167 }
3168
3169 int dlt_message_print_mixed_plain(DltMessage *message, char *text, uint32_t size, int verbose)
3170 {
3171     if ((message==0) || (text==0))
3172     {
3173         return -1;
3174     }
3175
3176     dlt_message_header(message,text,size,verbose);
3177     printf("%s \n",text);
3178     dlt_message_payload(message,text,size,DLT_OUTPUT_MIXED_FOR_PLAIN,verbose);
3179     printf("[%s]\n",text);
3180
3181     return 0;
3182 }
3183
3184 int dlt_message_print_mixed_html(DltMessage *message, char *text, uint32_t size, int verbose)
3185 {
3186     if ((message==0) || (text==0))
3187     {
3188         return -1;
3189     }
3190
3191     dlt_message_header(message,text,size,verbose);
3192     printf("%s \n",text);
3193     dlt_message_payload(message,text,size,DLT_OUTPUT_MIXED_FOR_HTML,verbose);
3194     printf("[%s]\n",text);
3195
3196     return 0;
3197 }
3198
3199 int dlt_message_argument_print(DltMessage *msg,uint32_t type_info,uint8_t **ptr,int32_t *datalength,char *text,int textlength,int byteLength,int __attribute__((unused)) verbose)
3200 {
3201     int16_t length=0,length_tmp=0; /* the macro can set this variable to -1 */
3202     uint16_t length2=0,length2_tmp=0,length3=0,length3_tmp=0;
3203
3204     uint8_t value8u=0;
3205     uint16_t value16u=0,value16u_tmp=0;
3206     uint32_t value32u=0,value32u_tmp=0;
3207     uint64_t value64u=0,value64u_tmp=0;
3208
3209     int8_t  value8i=0;
3210     int16_t value16i=0,value16i_tmp=0;
3211     int32_t value32i=0,value32i_tmp=0;
3212     int64_t value64i=0,value64i_tmp=0;
3213
3214     float32_t value32f=0,value32f_tmp=0;
3215     int32_t value32f_tmp_int32i=0,value32f_tmp_int32i_swaped=0;
3216     float64_t value64f=0,value64f_tmp=0;
3217     int64_t value64f_tmp_int64i=0,value64f_tmp_int64i_swaped=0;
3218
3219     uint32_t quantisation_tmp = 0;
3220
3221     if ( (type_info & DLT_TYPE_INFO_STRG) && (((type_info & DLT_TYPE_INFO_SCOD) == DLT_SCOD_ASCII) || ((type_info & DLT_TYPE_INFO_SCOD) == DLT_SCOD_UTF8)) )
3222     {
3223
3224         /* string type or utf8-encoded string type */
3225         if (byteLength<0)
3226         {
3227             DLT_MSG_READ_VALUE(length_tmp,*ptr,*datalength,uint16_t);
3228             if((*datalength)<0)
3229                 return -1;
3230             length=DLT_ENDIAN_GET_16(msg->standardheader->htyp, length_tmp);
3231         }
3232         else
3233         {
3234             length=(int16_t)byteLength;
3235         }
3236
3237         if (type_info & DLT_TYPE_INFO_VARI)
3238         {
3239             DLT_MSG_READ_VALUE(length2_tmp,*ptr,*datalength,uint16_t);
3240             if((*datalength)<0)
3241                 return -1;
3242             length2=DLT_ENDIAN_GET_16(msg->standardheader->htyp, length2_tmp);
3243             if((*datalength)<length2)
3244                 return -1;
3245             *ptr += length2;
3246             *datalength-=length2;
3247         }
3248
3249         DLT_MSG_READ_STRING((text+strlen(text)),*ptr,*datalength,length);
3250         if((*datalength)<0)
3251             return -1;
3252
3253     }
3254     else if (type_info & DLT_TYPE_INFO_BOOL)
3255     {
3256         /* Boolean type */
3257         if (type_info & DLT_TYPE_INFO_VARI)
3258         {
3259             DLT_MSG_READ_VALUE(length2_tmp,*ptr,*datalength,uint16_t);
3260             if((*datalength)<0)
3261                 return -1;
3262             length2=DLT_ENDIAN_GET_16(msg->standardheader->htyp, length2_tmp);
3263             if((*datalength)<length2)
3264                 return -1;
3265             *ptr += length2;
3266             *datalength-=length2;
3267         }
3268         value8u=0;
3269         DLT_MSG_READ_VALUE(value8u,*ptr,*datalength,uint8_t); /* No endian conversion necessary */
3270         if((*datalength)<0)
3271             return -1;
3272         snprintf(text+strlen(text),textlength-strlen(text),"%d",value8u);
3273     }
3274     else if ((type_info & DLT_TYPE_INFO_SINT) || (type_info & DLT_TYPE_INFO_UINT))
3275     {
3276         /* signed or unsigned argument received */
3277         if (type_info & DLT_TYPE_INFO_VARI)
3278         {
3279             DLT_MSG_READ_VALUE(length2_tmp,*ptr,*datalength,uint16_t);
3280             if((*datalength)<0)
3281                 return -1;
3282             length2=DLT_ENDIAN_GET_16(msg->standardheader->htyp, length2_tmp);
3283             DLT_MSG_READ_VALUE(length3_tmp,*ptr,*datalength,uint16_t);
3284             if((*datalength)<0)
3285                 return -1;
3286             length3=DLT_ENDIAN_GET_16(msg->standardheader->htyp, length3_tmp);
3287             if((*datalength)<length2)
3288                 return -1;
3289             *ptr += length2;
3290             *datalength-=length2;
3291             if((*datalength)<length3)
3292                 return -1;
3293             *ptr += length3;
3294             *datalength-=length3;
3295         }
3296         if (type_info & DLT_TYPE_INFO_FIXP)
3297         {
3298                 quantisation_tmp=quantisation_tmp; // prevent compiler warning
3299                 DLT_MSG_READ_VALUE(quantisation_tmp,*ptr,*datalength,uint32_t);
3300
3301             if((*datalength)<0)
3302                 return -1;
3303             switch (    type_info & DLT_TYPE_INFO_TYLE)
3304             {
3305                                 case DLT_TYLE_8BIT:
3306                                 case DLT_TYLE_16BIT:
3307                                 case DLT_TYLE_32BIT:
3308                                 {
3309                     if((*datalength)<4)
3310                         return -1;
3311                     *ptr += 4;
3312                                         *datalength-=4;
3313                                         break;
3314                                 }
3315                                 case DLT_TYLE_64BIT:
3316                                 {
3317                     if((*datalength)<8)
3318                         return -1;
3319                     *ptr += 8;
3320                                         *datalength-=8;
3321                                         break;
3322                                 }
3323                                 case DLT_TYLE_128BIT:
3324                                 {
3325                     if((*datalength)<16)
3326                         return -1;
3327                     *ptr += 16;
3328                                         *datalength-=16;
3329                                         break;
3330                                 }
3331                                 default:
3332                                 {
3333                                         return -1;
3334                                 }
3335             }
3336         }
3337         switch (        type_info & DLT_TYPE_INFO_TYLE)
3338         {
3339                         case DLT_TYLE_8BIT:
3340                         {
3341                                 if (type_info & DLT_TYPE_INFO_SINT)
3342                                 {
3343                                         value8i=0;
3344                                         DLT_MSG_READ_VALUE(value8i,*ptr,*datalength,int8_t); /* No endian conversion necessary */
3345                     if((*datalength)<0)
3346                         return -1;
3347                     snprintf(text+strlen(text),textlength-strlen(text),"%d",value8i);
3348                                 }
3349                                 else
3350                                 {
3351                                         value8u=0;
3352                                         DLT_MSG_READ_VALUE(value8u,*ptr,*datalength,uint8_t); /* No endian conversion necessary */
3353                     if((*datalength)<0)
3354                         return -1;
3355                     snprintf(text+strlen(text),textlength-strlen(text),"%d",value8u);
3356                                 }
3357                                 break;
3358                         }
3359                         case DLT_TYLE_16BIT:
3360                         {
3361                                 if (type_info & DLT_TYPE_INFO_SINT)
3362                                 {
3363                                         value16i=0;
3364                                         value16i_tmp=0;
3365                                         DLT_MSG_READ_VALUE(value16i_tmp,*ptr,*datalength,int16_t);
3366                     if((*datalength)<0)
3367                         return -1;
3368                     value16i=DLT_ENDIAN_GET_16(msg->standardheader->htyp, value16i_tmp);
3369                                         snprintf(text+strlen(text),textlength-strlen(text),"%hd",value16i);
3370                                 }
3371                                 else
3372                                 {
3373                                         value16u=0;
3374                                         value16u_tmp=0;
3375                                         DLT_MSG_READ_VALUE(value16u_tmp,*ptr,*datalength,uint16_t);
3376                     if((*datalength)<0)
3377                         return -1;
3378                     value16u=DLT_ENDIAN_GET_16(msg->standardheader->htyp, value16u_tmp);
3379                                         snprintf(text+strlen(text),textlength-strlen(text),"%hu",value16u);
3380                                 }
3381                                 break;
3382                         }
3383                         case DLT_TYLE_32BIT:
3384                         {
3385                                 if (type_info & DLT_TYPE_INFO_SINT)
3386                                 {
3387                                         value32i=0;
3388                                         value32i_tmp=0;
3389                                         DLT_MSG_READ_VALUE(value32i_tmp,*ptr,*datalength,int32_t);
3390                     if((*datalength)<0)
3391                         return -1;
3392                     value32i=DLT_ENDIAN_GET_32(msg->standardheader->htyp, (uint32_t)value32i_tmp);
3393                                         snprintf(text+strlen(text),textlength-strlen(text),"%d",value32i);
3394                                 }
3395                                 else
3396                                 {
3397                                         value32u=0;
3398                                         value32u_tmp=0;
3399                                         DLT_MSG_READ_VALUE(value32u_tmp,*ptr,*datalength,uint32_t);
3400                     if((*datalength)<0)
3401                         return -1;
3402                     value32u=DLT_ENDIAN_GET_32(msg->standardheader->htyp, value32u_tmp);
3403                                         snprintf(text+strlen(text),textlength-strlen(text),"%u",value32u);
3404                                 }
3405                                 break;
3406                         }
3407                         case DLT_TYLE_64BIT:
3408                         {
3409                                 if (type_info & DLT_TYPE_INFO_SINT)
3410                                 {
3411                                         value64i=0;
3412                                         value64i_tmp=0;
3413                                         DLT_MSG_READ_VALUE(value64i_tmp,*ptr,*datalength,int64_t);
3414                     if((*datalength)<0)
3415                         return -1;
3416                     value64i=DLT_ENDIAN_GET_64(msg->standardheader->htyp, (uint64_t)value64i_tmp);
3417         #if defined (__WIN32__) && !defined(_MSC_VER)
3418                                         snprintf(text+strlen(text),textlength-strlen(text),"%I64d",value64i);
3419         #else
3420                                         snprintf(text+strlen(text),textlength-strlen(text),"%lld",value64i);
3421         #endif
3422                                 }
3423                                 else
3424                                 {
3425                                         value64u=0;
3426                                         value64u_tmp=0;
3427                                         DLT_MSG_READ_VALUE(value64u_tmp,*ptr,*datalength,uint64_t);
3428                     if((*datalength)<0)
3429                         return -1;
3430                     value64u=DLT_ENDIAN_GET_64(msg->standardheader->htyp, value64u_tmp);
3431         #if defined (__WIN32__) && !defined(_MSC_VER)
3432                                         snprintf(text+strlen(text),textlength-strlen(text),"%I64u",value64u);
3433         #else
3434                                         snprintf(text+strlen(text),textlength-strlen(text),"%llu",value64u);
3435         #endif
3436                                 }
3437                                 break;
3438                         }
3439                         case DLT_TYLE_128BIT:
3440                         {
3441                                 if (*datalength>=16)
3442                                         dlt_print_hex_string(text+strlen(text),textlength,*ptr,16);
3443                 if((*datalength)<16)
3444                     return -1;
3445                 *ptr += 16;
3446                                 *datalength-=16;
3447                                 break;
3448                         }
3449                         default:
3450                         {
3451                                 return -1;
3452                         }
3453         }
3454     }
3455     else if (type_info & DLT_TYPE_INFO_FLOA)
3456     {
3457         /* float data argument */
3458         if (type_info & DLT_TYPE_INFO_VARI)
3459         {
3460             DLT_MSG_READ_VALUE(length2_tmp,*ptr,*datalength,uint16_t);
3461             if((*datalength)<0)
3462                 return -1;
3463             length2=DLT_ENDIAN_GET_16(msg->standardheader->htyp, length2_tmp);
3464             DLT_MSG_READ_VALUE(length3_tmp,*ptr,*datalength,uint16_t);
3465             if((*datalength)<0)
3466                 return -1;
3467             length3=DLT_ENDIAN_GET_16(msg->standardheader->htyp, length3_tmp);
3468             if((*datalength)<length2)
3469                 return -1;
3470             *ptr += length2;
3471             *datalength-=length2;
3472             if((*datalength)<length3)
3473                 return -1;
3474             *ptr += length3;
3475             *datalength-=length3;
3476         }
3477         switch (        type_info & DLT_TYPE_INFO_TYLE)
3478         {
3479                         case DLT_TYLE_8BIT:
3480                         {
3481                                 if (*datalength>=1)
3482                                         dlt_print_hex_string(text+strlen(text),textlength,*ptr,1);
3483                 if((*datalength)<1)
3484                     return -1;
3485                 *ptr += 1;
3486                                 *datalength-=1;
3487                                 break;
3488                         }
3489                         case DLT_TYLE_16BIT:
3490                         {
3491                                 if (*datalength>=2)
3492                                         dlt_print_hex_string(text+strlen(text),textlength,*ptr,2);
3493                 if((*datalength)<2)
3494                     return -1;
3495                 *ptr += 2;
3496                                 *datalength-=2;
3497                                 break;
3498                         }
3499                         case DLT_TYLE_32BIT:
3500                         {
3501                                 if (sizeof(float32_t)==4)
3502                                 {
3503                                         value32f=0;
3504                                         value32f_tmp=0;
3505                                         value32f_tmp_int32i=0;
3506                                         value32f_tmp_int32i_swaped=0;
3507                                         DLT_MSG_READ_VALUE(value32f_tmp,*ptr,*datalength,float32_t);
3508                     if((*datalength)<0)
3509                         return -1;
3510                     memcpy(&value32f_tmp_int32i,&value32f_tmp,sizeof(float32_t));
3511                                         value32f_tmp_int32i_swaped=DLT_ENDIAN_GET_32(msg->standardheader->htyp, (uint32_t)value32f_tmp_int32i);
3512                                         memcpy(&value32f,&value32f_tmp_int32i_swaped,sizeof(float32_t));
3513                                         snprintf(text+strlen(text),textlength-strlen(text),"%g",value32f);
3514                                 }
3515                                 else
3516                                 {
3517                                         dlt_log(LOG_ERR, "Invalid size of float32_t\n");
3518                                         return -1;
3519                                 }
3520                                 break;
3521                         }
3522                         case DLT_TYLE_64BIT:
3523                         {
3524                                 if (sizeof(float64_t)==8)
3525                                 {
3526                                         value64f=0;
3527                                         value64f_tmp=0;
3528                                         value64f_tmp_int64i=0;
3529                                         value64f_tmp_int64i_swaped=0;
3530                                         DLT_MSG_READ_VALUE(value64f_tmp,*ptr,*datalength,float64_t);
3531                     if((*datalength)<0)
3532                         return -1;
3533                     memcpy(&value64f_tmp_int64i,&value64f_tmp,sizeof(float64_t));
3534                                         value64f_tmp_int64i_swaped=DLT_ENDIAN_GET_64(msg->standardheader->htyp, (uint64_t)value64f_tmp_int64i);
3535                                         memcpy(&value64f,&value64f_tmp_int64i_swaped,sizeof(float64_t));
3536 #ifdef __arm__
3537                                         snprintf(text+strlen(text),textlength-strlen(text),"ILLEGAL");
3538 #else
3539                                         snprintf(text+strlen(text),textlength-strlen(text),"%g",value64f);
3540 #endif
3541                                 }
3542                                 else
3543                                 {
3544                                         dlt_log(LOG_ERR, "Invalid size of float64_t\n");
3545                                         return -1;
3546                                 }
3547                                 break;
3548                         }
3549                         case DLT_TYLE_128BIT:
3550                         {
3551                                 if (*datalength>=16)
3552                                         dlt_print_hex_string(text+strlen(text),textlength,*ptr,16);
3553                 if((*datalength)<16)
3554                     return -1;
3555                 *ptr += 16;
3556                                 *datalength-=16;
3557                                 break;
3558                         }
3559                         default:
3560                         {
3561                                 return -1;
3562                         }
3563         }
3564
3565     }
3566     else if (type_info & DLT_TYPE_INFO_RAWD)
3567     {
3568         /* raw data argument */
3569         DLT_MSG_READ_VALUE(length_tmp,*ptr,*datalength,uint16_t);
3570         if((*datalength)<0)
3571             return -1;
3572         length=DLT_ENDIAN_GET_16(msg->standardheader->htyp, length_tmp);
3573         if (type_info & DLT_TYPE_INFO_VARI)
3574         {
3575             DLT_MSG_READ_VALUE(length2_tmp,*ptr,*datalength,uint16_t);
3576             if((*datalength)<0)
3577                 return -1;
3578             length2=DLT_ENDIAN_GET_16(msg->standardheader->htyp, length2_tmp);
3579             if((*datalength)<length2)
3580                 return -1;
3581             *ptr += length2;
3582             *datalength-=length2;
3583         }
3584         if((*datalength)<length)
3585             return -1;
3586         dlt_print_hex_string(text+strlen(text),textlength,*ptr,length);
3587         *ptr+=length;
3588         *datalength-=length;
3589     }
3590     else if (type_info & DLT_TYPE_INFO_TRAI)
3591     {
3592         /* trace info argument */
3593         DLT_MSG_READ_VALUE(length_tmp,*ptr,*datalength,uint16_t);
3594         if((*datalength)<0)
3595             return -1;
3596         length=DLT_ENDIAN_GET_16(msg->standardheader->htyp, length_tmp);
3597         DLT_MSG_READ_STRING((text+strlen(text)),*ptr,*datalength,length);
3598         if((*datalength)<0)
3599             return -1;
3600     }
3601     else
3602     {
3603         return -1;
3604     }
3605
3606     if (*datalength<0)
3607     {
3608         dlt_log(LOG_ERR, "Payload of DLT message corrupted\n");
3609         return -1;
3610     }
3611
3612     return 0;
3613 }
3614
3615 void dlt_check_envvar()
3616 {
3617     char* env_log_filename = getenv("DLT_LOG_FILENAME");
3618
3619     if( env_log_filename != NULL )
3620     {
3621         dlt_log_set_filename(env_log_filename);
3622     }
3623
3624     char* env_log_level_str = getenv("DLT_LOG_LEVEL");
3625
3626         if( env_log_level_str != NULL )
3627         {
3628                 int level = 0;
3629                 if( sscanf(env_log_level_str, "%d", &level) )
3630                 {
3631                         dlt_log_set_level(level);
3632                 }
3633         }
3634
3635     char* env_log_mode = getenv("DLT_LOG_MODE");
3636
3637         if( env_log_mode != NULL )
3638         {
3639                 int mode = 0;
3640                 if( sscanf(env_log_mode, "%d", &mode) )
3641                 {
3642                         dlt_log_init(mode);
3643                 }
3644         }
3645
3646
3647 }