src/shared/dlt_common.c

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