diff options
author | Christian Muck <christian.muck@bmw.de> | 2011-04-11 15:41:05 +0200 |
---|---|---|
committer | Christian Muck <christian.muck@bmw.de> | 2011-04-11 15:41:05 +0200 |
commit | 760fb8a4daba3e403376099ce38aca8f88d695d3 (patch) | |
tree | 36b6f428cee8ba0af0fd50b3e44a3d4da9083a44 /src/tests/dlt-test-client.c | |
parent | 5394c6fa5bf40d9bc8619026cbc4c306211a8499 (diff) | |
download | DLT-daemon-760fb8a4daba3e403376099ce38aca8f88d695d3.tar.gz |
Init of dlt daemon
Diffstat (limited to 'src/tests/dlt-test-client.c')
-rwxr-xr-x | src/tests/dlt-test-client.c | 2004 |
1 files changed, 2004 insertions, 0 deletions
diff --git a/src/tests/dlt-test-client.c b/src/tests/dlt-test-client.c new file mode 100755 index 0000000..180badf --- /dev/null +++ b/src/tests/dlt-test-client.c @@ -0,0 +1,2004 @@ +/* + * Dlt Test Client - Diagnostic Log and Trace + * @licence app begin@ + * + * Copyright (C) 2011, BMW AG - Alexander Wenzel <alexander.wenzel@bmw.de> + * + * This program is free software; you can redistribute it and/or modify it under the terms of the + * GNU Lesser General Public License, version 2.1, as published by the Free Software Foundation. + * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even + * the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General + * Public License, version 2.1, for more details. + * + * You should have received a copy of the GNU Lesser General Public License, version 2.1, along + * with this program; if not, see <http://www.gnu.org/licenses/lgpl-2.1.html>. + * + * Note that the copyright holders assume that the GNU Lesser General Public License, version 2.1, may + * also be applicable to programs even in cases in which the program is not a library in the technical sense. + * + * Linking DLT statically or dynamically with other modules is making a combined work based on DLT. You may + * license such other modules under the GNU Lesser General Public License, version 2.1. If you do not want to + * license your linked modules under the GNU Lesser General Public License, version 2.1, you + * may use the program under the following exception. + * + * As a special exception, the copyright holders of DLT give you permission to combine DLT + * with software programs or libraries that are released under any license unless such a combination is not + * permitted by the license of such a software program or library. You may copy and distribute such a + * system following the terms of the GNU Lesser General Public License, version 2.1, including this + * special exception, for DLT and the licenses of the other code concerned. + * + * Note that people who make modified versions of DLT are not obligated to grant this special exception + * for their modified versions; it is their choice whether to do so. The GNU Lesser General Public License, + * version 2.1, gives permission to release a modified version without this exception; this exception + * also makes it possible to release a modified version which carries forward this exception. + * + * @licence end@ + */ + + +/******************************************************************************* +** ** +** SRC-MODULE: dlt-test-client.c ** +** ** +** TARGET : linux ** +** ** +** PROJECT : DLT ** +** ** +** AUTHOR : Alexander Wenzel Alexander.AW.Wenzel@bmw.de ** +** Markus Klein ** +** ** +** PURPOSE : ** +** ** +** REMARKS : ** +** ** +** PLATFORM DEPENDANT [yes/no]: yes ** +** ** +** TO BE CHANGED BY USER [yes/no]: no ** +** ** +*******************************************************************************/ + +/******************************************************************************* +** Author Identity ** +******************************************************************************** +** ** +** Initials Name Company ** +** -------- ------------------------- ---------------------------------- ** +** aw Alexander Wenzel BMW ** +** mk Markus Klein Fraunhofer ESK ** +*******************************************************************************/ + +/******************************************************************************* +** Revision Control History ** +*******************************************************************************/ + +/* + * $LastChangedRevision: 1670 $ + * $LastChangedDate: 2011-04-08 15:12:06 +0200 (Fr, 08. Apr 2011) $ + * $LastChangedBy$ + Initials Date Comment + aw 13.01.2010 initial + */ + +#include <ctype.h> /* for isprint() */ +#include <stdlib.h> /* for atoi() */ +#include <sys/stat.h> /* for S_IRUSR, S_IWUSR, S_IRGRP, S_IROTH */ +#include <fcntl.h> /* for open() */ +#include <string.h> /* for strcmp() */ +#include <sys/uio.h> /* for writev() */ + +#include "dlt_client.h" +#include "dlt_protocol.h" +#include "dlt_user.h" + +#define DLT_TESTCLIENT_TEXTBUFSIZE 10024 /* Size of buffer for text output */ +#define DLT_TESTCLIENT_ECU_ID "ECU1" + +#define DLT_TESTCLIENT_NUM_TESTS 7 + +/* Function prototypes */ +int dlt_testclient_message_callback(DltMessage *message, void *data); + +typedef struct +{ + int aflag; + int sflag; + int xflag; + int mflag; + int vflag; + int yflag; + char *ovalue; + char *fvalue; + char *tvalue; + char *evalue; + int bvalue; + + char ecuid[4]; + int ohandle; + + DltFile file; + DltFilter filter; + + int running_test; + + int test_counter_macro[DLT_TESTCLIENT_NUM_TESTS]; + int test_counter_function[DLT_TESTCLIENT_NUM_TESTS]; + + int tests_passed; + int tests_failed; + + int sock; +} DltTestclientData; + +/** + * Print usage information of tool. + */ +void usage() +{ + char version[255]; + + dlt_get_version(version); + + printf("Usage: dlt-test-client [options] hostname/serial_device_name\n"); + printf("Test against received data from dlt-test-user.\n"); + printf("%s \n", version); + printf("Options:\n"); + printf(" -a Print DLT messages; payload as ASCII\n"); + printf(" -x Print DLT messages; payload as hex\n"); + printf(" -m Print DLT messages; payload as hex and ASCII\n"); + printf(" -s Print DLT messages; only headers\n"); + printf(" -v Verbose mode\n"); + printf(" -h Usage\n"); + printf(" -y Serial device mode\n"); + printf(" -b baudrate Serial device baudrate (Default: 115200)\n"); + printf(" -e ecuid Set ECU ID (Default: ECU1)\n"); + printf(" -o filename Output messages in new DLT file\n"); + printf(" -f filename Enable filtering of messages\n"); +} + +/** + * Main function of tool. + */ +int main(int argc, char* argv[]) +{ + DltClient dltclient; + DltTestclientData dltdata; + int c,i; + int index; + + /* Initialize dltdata */ + dltdata.aflag = 0; + dltdata.sflag = 0; + dltdata.xflag = 0; + dltdata.mflag = 0; + dltdata.vflag = 0; + dltdata.yflag = 0; + dltdata.ovalue = 0; + dltdata.fvalue = 0; + dltdata.evalue = 0; + dltdata.bvalue = 0; + dltdata.ohandle=-1; + + dltdata.running_test = 0; + + for (i=0;i<DLT_TESTCLIENT_NUM_TESTS;i++) + { + dltdata.test_counter_macro[i]=0; + dltdata.test_counter_function[i]=0; + } + + dltdata.tests_passed = 0; + dltdata.tests_failed = 0; + + dltdata.sock = -1; + + /* Fetch command line arguments */ + opterr = 0; + + while ((c = getopt (argc, argv, "vashyxmf:o:e:b:")) != -1) + { + switch (c) + { + case 'v': + { + dltdata.vflag = 1; + break; + } + case 'a': + { + dltdata.aflag = 1; + break; + } + case 's': + { + dltdata.sflag = 1; + break; + } + case 'x': + { + dltdata.xflag = 1; + break; + } + case 'm': + { + dltdata.mflag = 1; + break; + } + case 'h': + { + usage(); + return -1; + } + case 'y': + { + dltdata.yflag = 1; + break; + } + case 'f': + { + dltdata.fvalue = optarg; + break; + } + case 'o': + { + dltdata.ovalue = optarg; + break; + } + case 'e': + { + dltdata.evalue = optarg; + break; + } + case 'b': + { + dltdata.bvalue = atoi(optarg); + break; + } + case '?': + { + if (optopt == 'o' || optopt == 'f' || optopt == 't') + { + fprintf (stderr, "Option -%c requires an argument.\n", optopt); + } + else if (isprint (optopt)) + { + fprintf (stderr, "Unknown option `-%c'.\n", optopt); + } + else + { + fprintf (stderr, "Unknown option character `\\x%x'.\n",optopt); + } + /* unknown or wrong option used, show usage information and terminate */ + usage(); + return -1; + } + default: + { + abort (); + } + } + } + + /* Initialize DLT Client */ + dlt_client_init(&dltclient, dltdata.vflag); + + /* Register callback to be called when message was received */ + dlt_client_register_message_callback(dlt_testclient_message_callback); + + /* Setup DLT Client structure */ + dltclient.serial_mode = dltdata.yflag; + + if (dltclient.serial_mode==0) + { + for (index = optind; index < argc; index++) + { + dltclient.servIP = argv[index]; + } + + if (dltclient.servIP == 0) + { + /* no hostname selected, show usage and terminate */ + fprintf(stderr,"ERROR: No hostname selected\n"); + usage(); + dlt_client_cleanup(&dltclient,dltdata.vflag); + return -1; + } + } + else + { + for (index = optind; index < argc; index++) + { + dltclient.serialDevice = argv[index]; + } + + if (dltclient.serialDevice == 0) + { + /* no serial device name selected, show usage and terminate */ + fprintf(stderr,"ERROR: No serial device name specified\n"); + usage(); + return -1; + } + + dlt_client_setbaudrate(&dltclient,dltdata.bvalue); + } + + /* initialise structure to use DLT file */ + dlt_file_init(&(dltdata.file),dltdata.vflag); + + /* first parse filter file if filter parameter is used */ + dlt_filter_init(&(dltdata.filter),dltdata.vflag); + + if (dltdata.fvalue) + { + if (dlt_filter_load(&(dltdata.filter),dltdata.fvalue,dltdata.vflag)<0) + { + dlt_file_free(&(dltdata.file),dltdata.vflag); + return -1; + } + + dlt_file_set_filter(&(dltdata.file),&(dltdata.filter),dltdata.vflag); + } + + /* open DLT output file */ + if (dltdata.ovalue) + { + dltdata.ohandle = open(dltdata.ovalue,O_WRONLY|O_CREAT, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH); /* mode: wb */ + + if (dltdata.ohandle == -1) + { + dlt_file_free(&(dltdata.file),dltdata.vflag); + fprintf(stderr,"ERROR: Output file %s cannot be opened!\n",dltdata.ovalue); + return -1; + } + } + + if (dltdata.evalue) + { + dlt_set_id(dltdata.ecuid,dltdata.evalue); + } + else + { + dlt_set_id(dltdata.ecuid,DLT_TESTCLIENT_ECU_ID); + } + + /* Connect to TCP socket or open serial device */ + if (dlt_client_connect(&dltclient, dltdata.vflag)!=-1) + { + dltdata.sock = dltclient.sock; + + /* Dlt Client Main Loop */ + dlt_client_main_loop(&dltclient, &dltdata, dltdata.vflag); + + /* Dlt Client Cleanup */ + dlt_client_cleanup(&dltclient,dltdata.vflag); + } + + /* dlt-receive cleanup */ + if (dltdata.ovalue) + { + close(dltdata.ohandle); + } + + dlt_file_free(&(dltdata.file),dltdata.vflag); + + dlt_filter_free(&(dltdata.filter),dltdata.vflag); + + return 0; +} + +int dlt_testclient_message_callback(DltMessage *message, void *data) +{ + static char text[DLT_TESTCLIENT_TEXTBUFSIZE]; + int mtin; + DltTestclientData *dltdata; + + uint32_t type_info, type_info_tmp; + int16_t length,length_tmp; /* the macro can set this variable to -1 */ + uint8_t *ptr; + int32_t datalength; + + uint32_t id,id_tmp; + int slen; + int tc_old; + + struct iovec iov[2]; + int bytes_written; + + if ((message==0) || (data==0)) + { + return -1; + } + + dltdata = (DltTestclientData*)data; + + /* prepare storage header */ + if (DLT_IS_HTYP_WEID(message->standardheader->htyp)) + { + dlt_set_storageheader(message->storageheader,message->headerextra.ecu); + } + else + { + dlt_set_storageheader(message->storageheader,dltdata->ecuid); + } + + if ((dltdata->fvalue==0) || (dltdata->fvalue && dlt_message_filter_check(message,&(dltdata->filter),dltdata->vflag)==1)) + { + + dlt_message_header(message,text,sizeof(text),dltdata->vflag); + if (dltdata->aflag) + { + printf("%s ",text); + } + dlt_message_payload(message,text,sizeof(text),DLT_OUTPUT_ASCII,dltdata->vflag); + if (dltdata->aflag) + { + printf("[%s]\n",text); + } + + if (strcmp(text,"Tests starting")==0) + { + printf("Tests starting\n"); + } + + /* check test 1m */ + if (strcmp(text,"Test1: (Macro IF) Test all log levels")==0) + { + printf("Test1m: (Macro IF) Test all log levels\n"); + dltdata->running_test = 1; + dltdata->test_counter_macro[0] = 0; + } + else if (strcmp(text,"Test1: (Macro IF) finished")==0) + { + /* >=4, as "info" is default log level */ + if (dltdata->test_counter_macro[0]>=4) + { + printf("Test1m PASSED\n"); + dltdata->tests_passed++; + } + else + { + printf("Test1m FAILED\n"); + dltdata->tests_failed++; + } + dltdata->running_test = 0; + } + else if (dltdata->running_test==1) + { + if (DLT_IS_HTYP_UEH(message->standardheader->htyp)) + { + if ((DLT_GET_MSIN_MSTP(message->extendedheader->msin))==DLT_TYPE_LOG) + { + mtin=DLT_GET_MSIN_MTIN(message->extendedheader->msin); + + if (mtin==DLT_LOG_FATAL) + { + dltdata->test_counter_macro[0]++; + } + if (mtin==DLT_LOG_ERROR) + { + dltdata->test_counter_macro[0]++; + } + if (mtin==DLT_LOG_WARN) + { + dltdata->test_counter_macro[0]++; + } + if (mtin==DLT_LOG_INFO) + { + dltdata->test_counter_macro[0]++; + } + if (mtin==DLT_LOG_DEBUG) + { + dltdata->test_counter_macro[0]++; + } + if (mtin==DLT_LOG_VERBOSE) + { + dltdata->test_counter_macro[0]++; + } + } + } + } + + /* check test 2m */ + if (strcmp(text,"Test2: (Macro IF) Test all variable types (verbose)")==0) + { + printf("Test2m: (Macro IF) Test all variable types (verbose)\n"); + dltdata->running_test = 2; + dltdata->test_counter_macro[1] = 0; + } + else if (strcmp(text,"Test2: (Macro IF) finished")==0) + { + if (dltdata->test_counter_macro[1]==14) + { + printf("Test2m PASSED\n"); + dltdata->tests_passed++; + } + else + { + printf("Test2m FAILED\n"); + dltdata->tests_failed++; + } + dltdata->running_test = 0; + } + else if (dltdata->running_test==2) + { + /* Verbose */ + if (!(DLT_MSG_IS_NONVERBOSE(message))) + { + type_info=0; + type_info_tmp=0; + length=0; /* the macro can set this variable to -1 */ + length_tmp=0; + ptr = message->databuffer; + datalength = message->datasize; + + /* Log message */ + if ((DLT_GET_MSIN_MSTP(message->extendedheader->msin))==DLT_TYPE_LOG) + { + if (message->extendedheader->noar>=2) + { + /* get type of first argument: must be string */ + DLT_MSG_READ_VALUE(type_info_tmp,ptr,datalength,uint32_t); + type_info=DLT_ENDIAN_GET_32(message->standardheader->htyp, type_info_tmp); + + if (type_info & DLT_TYPE_INFO_STRG) + { + /* skip string */ + DLT_MSG_READ_VALUE(length_tmp,ptr,datalength,uint16_t); + length=DLT_ENDIAN_GET_16(message->standardheader->htyp, length_tmp); + + if (length>=0) + { + ptr+=length; + datalength-=length; + + /* read type of second argument: must be raw */ + DLT_MSG_READ_VALUE(type_info_tmp,ptr,datalength,uint32_t); + type_info=DLT_ENDIAN_GET_32(message->standardheader->htyp, type_info_tmp); + + if (type_info & DLT_TYPE_INFO_BOOL) + { + if (datalength==sizeof(uint8_t)) + { + dltdata->test_counter_macro[1]++; + } + } + else if (type_info & DLT_TYPE_INFO_SINT) + { + switch (type_info & DLT_TYPE_INFO_TYLE) + { + case DLT_TYLE_8BIT: + { + if (datalength==sizeof(int8_t)) + { + dltdata->test_counter_macro[1]++; + } + break; + } + case DLT_TYLE_16BIT: + { + if (datalength==sizeof(int16_t)) + { + dltdata->test_counter_macro[1]++; + } + break; + } + case DLT_TYLE_32BIT: + { + if (datalength==sizeof(int32_t)) + { + dltdata->test_counter_macro[1]++; + } + break; + } + case DLT_TYLE_64BIT: + { + if (datalength==sizeof(int64_t)) + { + dltdata->test_counter_macro[1]++; + } + break; + } + case DLT_TYLE_128BIT: + { + /* Not tested here */ + break; + } + } + } + else if (type_info & DLT_TYPE_INFO_UINT) + { + switch (type_info & DLT_TYPE_INFO_TYLE) + { + case DLT_TYLE_8BIT: + { + if (datalength==sizeof(uint8_t)) + { + dltdata->test_counter_macro[1]++; + } + break; + } + case DLT_TYLE_16BIT: + { + if (datalength==sizeof(uint16_t)) + { + dltdata->test_counter_macro[1]++; + } + break; + } + case DLT_TYLE_32BIT: + { + if (datalength==sizeof(uint32_t)) + { + dltdata->test_counter_macro[1]++; + } + break; + } + case DLT_TYLE_64BIT: + { + if (datalength==sizeof(uint64_t)) + { + dltdata->test_counter_macro[1]++; + } + break; + } + case DLT_TYLE_128BIT: + { + /* Not tested here */ + break; + } + } + } + else if (type_info & DLT_TYPE_INFO_FLOA) + { + switch (type_info & DLT_TYPE_INFO_TYLE) + { + case DLT_TYLE_8BIT: + { + /* Not tested here */ + break; + } + case DLT_TYLE_16BIT: + { + /* Not tested here */ + break; + } + case DLT_TYLE_32BIT: + { + if (datalength==(2*sizeof(float)+sizeof(uint32_t))) + { + dltdata->test_counter_macro[1]++; + } + break; + } + case DLT_TYLE_64BIT: + { + if (datalength==(2*sizeof(double)+sizeof(uint32_t))) + { + dltdata->test_counter_macro[1]++; + } + break; + } + case DLT_TYLE_128BIT: + /* Not tested here */ + break; + } + } + else if (type_info & DLT_TYPE_INFO_RAWD) + { + /* Get length */ + DLT_MSG_READ_VALUE(length_tmp,ptr,datalength,uint16_t); + length=DLT_ENDIAN_GET_16(message->standardheader->htyp, length_tmp); + if ((length==datalength) && (length=10)) + { + dltdata->test_counter_macro[1]++; + } + } + } + } + } + } + } + } + + /* check test 3m */ + if (strcmp(text,"Test3: (Macro IF) Test all variable types (non-verbose)")==0) + { + printf("Test3m: (Macro IF) Test all variable types (non-verbose)\n"); + dltdata->running_test = 3; + dltdata->test_counter_macro[2]=0; + } + else if (strcmp(text,"Test3: (Macro IF) finished")==0) + { + if (dltdata->test_counter_macro[2]==14) + { + printf("Test3m PASSED\n"); + dltdata->tests_passed++; + } + else + { + printf("Test3m FAILED\n"); + dltdata->tests_failed++; + } + dltdata->running_test = 0; + } + else if (dltdata->running_test==3) + { + /* Nonverbose */ + if (DLT_MSG_IS_NONVERBOSE(message)) + { + id=0; + id_tmp=0; + ptr = message->databuffer; + datalength = message->datasize; + slen=-1; + + tc_old=dltdata->test_counter_macro[2]; + + /* Get message id */ + DLT_MSG_READ_VALUE(id_tmp,ptr,datalength,uint32_t); + id=DLT_ENDIAN_GET_32(message->standardheader->htyp, id_tmp); + + /* Length of string */ + datalength-=sizeof(uint16_t); + ptr+=sizeof(uint16_t); + + switch (id) + { + case 1: + { + slen=strlen("bool")+1; + datalength-=slen; + ptr+=slen; + if (datalength==sizeof(uint8_t)) + { + dltdata->test_counter_macro[2]++; + } + break; + } + case 2: + { + slen=strlen("int")+1; + datalength-=slen; + ptr+=slen; + if (datalength==sizeof(int)) + { + dltdata->test_counter_macro[2]++; + } + break; + } + case 3: + { + slen=strlen("int8")+1; + datalength-=slen; + ptr+=slen; + if (datalength==sizeof(int8_t)) + { + dltdata->test_counter_macro[2]++; + } + break; + } + case 4: + { + slen=strlen("int16")+1; + datalength-=slen; + ptr+=slen; + if (datalength==sizeof(int16_t)) + { + dltdata->test_counter_macro[2]++; + } + break; + } + case 5: + { + slen=strlen("int32")+1; + datalength-=slen; + ptr+=slen; + if (datalength==sizeof(int32_t)) + { + dltdata->test_counter_macro[2]++; + } + break; + } + case 6: + { + slen=strlen("int64")+1; + datalength-=slen; + ptr+=slen; + if (datalength==sizeof(int64_t)) + { + dltdata->test_counter_macro[2]++; + } + break; + } + case 7: + { + slen=strlen("uint")+1; + datalength-=slen; + ptr+=slen; + if (datalength==sizeof(unsigned int)) + { + dltdata->test_counter_macro[2]++; + } + break; + } + case 8: + { + slen=strlen("uint8")+1; + datalength-=slen; + ptr+=slen; + if (datalength==sizeof(uint8_t)) + { + dltdata->test_counter_macro[2]++; + } + break; + } + case 9: + { + slen=strlen("uint16")+1; + datalength-=slen; + ptr+=slen; + if (datalength==sizeof(uint16_t)) + { + dltdata->test_counter_macro[2]++; + } + break; + } + case 10: + { + slen=strlen("uint32")+1; + datalength-=slen; + ptr+=slen; + if (datalength==sizeof(uint32_t)) + { + dltdata->test_counter_macro[2]++; + } + break; + } + case 11: + { + slen=strlen("uint64")+1; + datalength-=slen; + ptr+=slen; + if (datalength==sizeof(uint64_t)) + { + dltdata->test_counter_macro[2]++; + } + break; + } + case 12: + { + slen=strlen("float32")+1; + datalength-=slen; + ptr+=slen; + /* 2*, as the min and the max is transfered */ + if (datalength==2*sizeof(float)) + { + dltdata->test_counter_macro[2]++; + } + break; + } + case 13: + { + slen=strlen("float64")+1; + datalength-=slen; + ptr+=slen; + /* 2*, as the min and the max is transfered */ + if (datalength==2*sizeof(double)) + { + dltdata->test_counter_macro[2]++; + } + break; + } + case 14: + { + slen=strlen("raw")+1; + datalength-=slen; + ptr+=slen; + datalength-=sizeof(uint16_t); + ptr+=sizeof(uint16_t); + if (datalength==10) + { + dltdata->test_counter_macro[2]++; + } + break; + } + } + + if ((slen>=0) && (tc_old==dltdata->test_counter_macro[2])) + { + printf("ID=%d, Datalength=%d => Failed!",id,datalength); + } + } + } + + /* check test 4m */ + if (strcmp(text,"Test4: (Macro IF) Test different message sizes")==0) + { + printf("Test4m: (Macro IF) Test different message sizes\n"); + dltdata->running_test = 4; + dltdata->test_counter_macro[3]=0; + } + else if (strcmp(text,"Test4: (Macro IF) finished")==0) + { + if (dltdata->test_counter_macro[3]==4) + { + printf("Test4m PASSED\n"); + dltdata->tests_passed++; + } + else + { + printf("Test4m FAILED\n"); + dltdata->tests_failed++; + } + dltdata->running_test = 0; + } + else if (dltdata->running_test==4) + { + /* Extended header */ + if (DLT_IS_HTYP_UEH(message->standardheader->htyp)) + { + /* Log message */ + if ((DLT_GET_MSIN_MSTP(message->extendedheader->msin))==DLT_TYPE_LOG) + { + /* Verbose */ + if (DLT_IS_MSIN_VERB(message->extendedheader->msin)) + { + /* 2 arguments */ + if (message->extendedheader->noar==2) + { + /* verbose mode */ + type_info=0; + type_info_tmp=0; + length=0; + length_tmp=0; /* the macro can set this variable to -1 */ + + ptr = message->databuffer; + datalength = message->datasize; + + /* first read the type info of the first argument: must be string */ + DLT_MSG_READ_VALUE(type_info_tmp,ptr,datalength,uint32_t); + type_info=DLT_ENDIAN_GET_32(message->standardheader->htyp, type_info_tmp); + + if (type_info & DLT_TYPE_INFO_STRG) + { + /* skip string */ + DLT_MSG_READ_VALUE(length_tmp,ptr,datalength,uint16_t); + length=DLT_ENDIAN_GET_16(message->standardheader->htyp, length_tmp); + + if (length>=0) + { + ptr+=length; + datalength-=length; + + /* read type of second argument: must be raw */ + DLT_MSG_READ_VALUE(type_info_tmp,ptr,datalength,uint32_t); + type_info=DLT_ENDIAN_GET_32(message->standardheader->htyp, type_info_tmp); + + if (type_info & DLT_TYPE_INFO_RAWD) + { + /* get length of raw data block */ + DLT_MSG_READ_VALUE(length_tmp,ptr,datalength,uint16_t); + length=DLT_ENDIAN_GET_16(message->standardheader->htyp, length_tmp); + + if ((length>=0) && (length==datalength)) + { + //printf("Raw data found in payload, length="); + //printf("%d, datalength=%d \n", length, datalength); + dltdata->test_counter_macro[3]++; + } + } + } + } + } + } + } + } + } + + /* check test 5m */ + if (strcmp(text,"Test5: (Macro IF) Test high-level API")==0) + { + printf("Test5m: (Macro IF) Test high-level API\n"); + dltdata->running_test = 5; + dltdata->test_counter_macro[4]=0; + } + else if (strcmp(text,"Test5: (Macro IF) finished")==0) + { + if (dltdata->test_counter_macro[4]==12) + { + printf("Test5m PASSED\n"); + dltdata->tests_passed++; + } + else + { + printf("Test5m FAILED\n"); + dltdata->tests_failed++; + } + dltdata->running_test = 0; + } + else if (dltdata->running_test==5) + { + if (strcmp(text,"Next line: DLT_LOG_INT")==0) + { + dltdata->test_counter_macro[4]++; + } + if (strcmp(text,"-42")==0) + { + dltdata->test_counter_macro[4]++; + } + + if (strcmp(text,"Next line: DLT_LOG_UINT")==0) + { + dltdata->test_counter_macro[4]++; + } + if (strcmp(text,"42")==0) + { + dltdata->test_counter_macro[4]++; + } + + if (strcmp(text,"Next line: DLT_LOG_STRING")==0) + { + dltdata->test_counter_macro[4]++; + } + if (strcmp(text,"String output")==0) + { + dltdata->test_counter_macro[4]++; + } + + if (strcmp(text,"Next line: DLT_LOG_RAW")==0) + { + dltdata->test_counter_macro[4]++; + } + if (strcmp(text,"00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f")==0) + { + dltdata->test_counter_macro[4]++; + } + + if (strcmp(text,"Next line: DLT_LOG_STRING_INT")==0) + { + dltdata->test_counter_macro[4]++; + } + if (strcmp(text,"String output: -42")==0) + { + dltdata->test_counter_macro[4]++; + } + + if (strcmp(text,"Next line: DLT_LOG_STRING_UINT")==0) + { + dltdata->test_counter_macro[4]++; + } + if (strcmp(text,"String output: 42")==0) + { + dltdata->test_counter_macro[4]++; + } + } + + /* check test 6m */ + if (strcmp(text,"Test 6: (Macro IF) Test local printing")==0) + { + printf("Test6m: (Macro IF) Test local printing\n"); + dltdata->running_test = 6; + dltdata->test_counter_macro[5]=0; + } + else if (strcmp(text,"Test6: (Macro IF) finished")==0) + { + if (dltdata->test_counter_macro[5]==2) + { + printf("Test6m PASSED\n"); + dltdata->tests_passed++; + } + else + { + printf("Test6m FAILED\n"); + dltdata->tests_failed++; + } + dltdata->running_test = 0; + } + else if (dltdata->running_test==6) + { + dltdata->test_counter_macro[5]++; + } + + /* check test 7m */ + if (strcmp(text,"Test 7: (Macro IF) Test network trace")==0) + { + printf("Test7m: (Macro IF) Test network trace\n"); + dltdata->running_test = 7; + dltdata->test_counter_macro[6]=0; + } + else if (strcmp(text,"Test7: (Macro IF) finished")==0) + { + if (dltdata->test_counter_macro[6]==8) + { + printf("Test7m PASSED\n"); + dltdata->tests_passed++; + } + else + { + printf("Test7m FAILED\n"); + dltdata->tests_failed++; + } + dltdata->running_test = 0; + } + else if (dltdata->running_test==7) + { + if (DLT_IS_HTYP_UEH(message->standardheader->htyp)) + { + if ((DLT_GET_MSIN_MSTP(message->extendedheader->msin))==DLT_TYPE_NW_TRACE) + { + /* Check message type information*/ + /* Each correct message type increases the counter by 1 */ + mtin=DLT_GET_MSIN_MTIN(message->extendedheader->msin); + + if (mtin==DLT_NW_TRACE_IPC) + { + dltdata->test_counter_macro[6]++; + } + if (mtin==DLT_NW_TRACE_CAN) + { + dltdata->test_counter_macro[6]++; + } + if (mtin==DLT_NW_TRACE_FLEXRAY) + { + dltdata->test_counter_macro[6]++; + } + if (mtin==DLT_NW_TRACE_MOST) + { + dltdata->test_counter_macro[6]++; + } + + /* Check payload, must be two arguments (2 raw data blocks) */ + /* If the payload is correct, the counter is increased by 1 */ + if (message->extendedheader->noar==2) + { + /* verbose mode */ + type_info=0; + type_info_tmp=0; + length=0,length_tmp=0; /* the macro can set this variable to -1 */ + + ptr = message->databuffer; + datalength = message->datasize; + + /* first read the type info of the first argument: must be string */ + DLT_MSG_READ_VALUE(type_info_tmp,ptr,datalength,uint32_t); + type_info=DLT_ENDIAN_GET_32(message->standardheader->htyp, type_info_tmp); + + if (type_info & DLT_TYPE_INFO_RAWD) + { + /* skip string */ + DLT_MSG_READ_VALUE(length_tmp,ptr,datalength,uint16_t); + length=DLT_ENDIAN_GET_16(message->standardheader->htyp, length_tmp); + + if (length>=0) + { + ptr+=length; + datalength-=length; + + /* read type of second argument: must be raw */ + DLT_MSG_READ_VALUE(type_info_tmp,ptr,datalength,uint32_t); + type_info=DLT_ENDIAN_GET_32(message->standardheader->htyp, type_info_tmp); + + if (type_info & DLT_TYPE_INFO_RAWD) + { + /* get length of raw data block */ + DLT_MSG_READ_VALUE(length_tmp,ptr,datalength,uint16_t); + length=DLT_ENDIAN_GET_16(message->standardheader->htyp, length_tmp); + + if ((length>=0) && (length==datalength)) + { + //printf("Raw data found in payload, length="); + //printf("%d, datalength=%d \n", length, datalength); + dltdata->test_counter_macro[6]++; + } + } + } + } + } + } + } + } + + /* check test 1f */ + if (strcmp(text,"Test1: (Function IF) Test all log levels")==0) + { + printf("Test1f: (Function IF) Test all log levels\n"); + dltdata->running_test = 8; + dltdata->test_counter_function[0] = 0; + } + else if (strcmp(text,"Test1: (Function IF) finished")==0) + { + /* >=4, as "info" is default log level */ + if (dltdata->test_counter_function[0]>=4) + { + printf("Test1f PASSED\n"); + dltdata->tests_passed++; + } + else + { + printf("Test1f FAILED\n"); + dltdata->tests_failed++; + } + dltdata->running_test = 0; + } + else if (dltdata->running_test==8) + { + if (DLT_IS_HTYP_UEH(message->standardheader->htyp)) + { + if ((DLT_GET_MSIN_MSTP(message->extendedheader->msin))==DLT_TYPE_LOG) + { + mtin=DLT_GET_MSIN_MTIN(message->extendedheader->msin); + + if (mtin==DLT_LOG_FATAL) + { + dltdata->test_counter_function[0]++; + } + if (mtin==DLT_LOG_ERROR) + { + dltdata->test_counter_function[0]++; + } + if (mtin==DLT_LOG_WARN) + { + dltdata->test_counter_function[0]++; + } + if (mtin==DLT_LOG_INFO) + { + dltdata->test_counter_function[0]++; + } + if (mtin==DLT_LOG_DEBUG) + { + dltdata->test_counter_function[0]++; + } + if (mtin==DLT_LOG_VERBOSE) + { + dltdata->test_counter_function[0]++; + } + } + } + } + + /* check test 2f */ + if (strcmp(text,"Test2: (Function IF) Test all variable types (verbose)")==0) + { + printf("Test2f: (Function IF) Test all variable types (verbose)\n"); + dltdata->running_test = 9; + dltdata->test_counter_function[1] = 0; + } + else if (strcmp(text,"Test2: (Function IF) finished")==0) + { + if (dltdata->test_counter_function[1]==14) + { + printf("Test2f PASSED\n"); + dltdata->tests_passed++; + } + else + { + printf("Test2f FAILED\n"); + dltdata->tests_failed++; + } + dltdata->running_test = 0; + } + else if (dltdata->running_test==9) + { + /* Verbose */ + if (!(DLT_MSG_IS_NONVERBOSE(message))) + { + type_info=0; + type_info_tmp=0; + length=0; + length_tmp=0; /* the macro can set this variable to -1 */ + ptr = message->databuffer; + datalength = message->datasize; + + /* Log message */ + if ((DLT_GET_MSIN_MSTP(message->extendedheader->msin))==DLT_TYPE_LOG) + { + if (message->extendedheader->noar>=2) + { + /* get type of first argument: must be string */ + DLT_MSG_READ_VALUE(type_info_tmp,ptr,datalength,uint32_t); + type_info=DLT_ENDIAN_GET_32(message->standardheader->htyp, type_info_tmp); + + if (type_info & DLT_TYPE_INFO_STRG) + { + /* skip string */ + DLT_MSG_READ_VALUE(length_tmp,ptr,datalength,uint16_t); + length=DLT_ENDIAN_GET_16(message->standardheader->htyp, length_tmp); + + if (length>=0) + { + ptr+=length; + datalength-=length; + + /* read type of second argument: must be raw */ + DLT_MSG_READ_VALUE(type_info_tmp,ptr,datalength,uint32_t); + type_info=DLT_ENDIAN_GET_32(message->standardheader->htyp, type_info_tmp); + + if (type_info & DLT_TYPE_INFO_BOOL) + { + if (datalength==sizeof(uint8_t)) + { + dltdata->test_counter_function[1]++; + } + } + else if (type_info & DLT_TYPE_INFO_SINT) + { + switch (type_info & DLT_TYPE_INFO_TYLE) + { + case DLT_TYLE_8BIT: + { + if (datalength==sizeof(int8_t)) + { + dltdata->test_counter_function[1]++; + } + break; + } + case DLT_TYLE_16BIT: + { + if (datalength==sizeof(int16_t)) + { + dltdata->test_counter_function[1]++; + } + break; + } + case DLT_TYLE_32BIT: + { + if (datalength==sizeof(int32_t)) + { + dltdata->test_counter_function[1]++; + } + break; + } + case DLT_TYLE_64BIT: + { + if (datalength==sizeof(int64_t)) + { + dltdata->test_counter_function[1]++; + } + break; + } + case DLT_TYLE_128BIT: + { + /* Not tested here */ + break; + } + } + } + else if (type_info & DLT_TYPE_INFO_UINT) + { + switch (type_info & DLT_TYPE_INFO_TYLE) + { + case DLT_TYLE_8BIT: + { + if (datalength==sizeof(uint8_t)) + { + dltdata->test_counter_function[1]++; + } + break; + } + case DLT_TYLE_16BIT: + { + if (datalength==sizeof(uint16_t)) + { + dltdata->test_counter_function[1]++; + } + break; + } + case DLT_TYLE_32BIT: + { + if (datalength==sizeof(uint32_t)) + { + dltdata->test_counter_function[1]++; + } + break; + } + case DLT_TYLE_64BIT: + { + if (datalength==sizeof(uint64_t)) + { + dltdata->test_counter_function[1]++; + } + break; + } + case DLT_TYLE_128BIT: + { + /* Not tested here */ + break; + } + } + } + else if (type_info & DLT_TYPE_INFO_FLOA) + { + switch (type_info & DLT_TYPE_INFO_TYLE) + { + case DLT_TYLE_8BIT: + { + /* Not tested here */ + break; + } + case DLT_TYLE_16BIT: + { + /* Not tested here */ + break; + } + case DLT_TYLE_32BIT: + { + if (datalength==(2*sizeof(float)+sizeof(uint32_t))) + { + dltdata->test_counter_function[1]++; + } + break; + } + case DLT_TYLE_64BIT: + { + if (datalength==(2*sizeof(double)+sizeof(uint32_t))) + { + dltdata->test_counter_function[1]++; + } + break; + } + case DLT_TYLE_128BIT: + { + /* Not tested here */ + break; + } + } + } + else if (type_info & DLT_TYPE_INFO_RAWD) + { + /* Get length */ + DLT_MSG_READ_VALUE(length_tmp,ptr,datalength,uint16_t); + length=DLT_ENDIAN_GET_16(message->standardheader->htyp, length_tmp); + if ((length==datalength) && (length=10)) + { + dltdata->test_counter_function[1]++; + } + } + } + } + } + } + } + } + + /* check test 3f */ + if (strcmp(text,"Test3: (Function IF) Test all variable types (non-verbose)")==0) + { + printf("Test3f: (Function IF) Test all variable types (non-verbose)\n"); + dltdata->running_test = 10; + dltdata->test_counter_function[2]=0; + } + else if (strcmp(text,"Test3: (Function IF) finished")==0) + { + if (dltdata->test_counter_function[2]==14) + { + printf("Test3f PASSED\n"); + dltdata->tests_passed++; + } + else + { + printf("Test3f FAILED\n"); + dltdata->tests_failed++; + } + dltdata->running_test = 0; + } + else if (dltdata->running_test==10) + { + /* Nonverbose */ + if (DLT_MSG_IS_NONVERBOSE(message)) + { + id=0; + id_tmp=0; + ptr = message->databuffer; + datalength = message->datasize; + slen=-1; + + tc_old=dltdata->test_counter_function[2]; + + /* Get message id */ + DLT_MSG_READ_VALUE(id_tmp,ptr,datalength,uint32_t); + id=DLT_ENDIAN_GET_32(message->standardheader->htyp, id_tmp); + + /* Length of string */ + datalength-=sizeof(uint16_t); + ptr+=sizeof(uint16_t); + + switch (id) + { + case 1: + { + slen=strlen("bool")+1; + datalength-=slen; + ptr+=slen; + if (datalength==sizeof(uint8_t)) + { + dltdata->test_counter_function[2]++; + } + break; + } + case 2: + { + slen=strlen("int")+1; + datalength-=slen; + ptr+=slen; + if (datalength==sizeof(int)) + { + dltdata->test_counter_function[2]++; + } + break; + } + case 3: + { + slen=strlen("int8")+1; + datalength-=slen; + ptr+=slen; + if (datalength==sizeof(int8_t)) + { + dltdata->test_counter_function[2]++; + } + break; + } + case 4: + { + slen=strlen("int16")+1; + datalength-=slen; + ptr+=slen; + if (datalength==sizeof(int16_t)) + { + dltdata->test_counter_function[2]++; + } + break; + } + case 5: + { + slen=strlen("int32")+1; + datalength-=slen; + ptr+=slen; + if (datalength==sizeof(int32_t)) + { + dltdata->test_counter_function[2]++; + } + break; + } + case 6: + { + slen=strlen("int64")+1; + datalength-=slen; + ptr+=slen; + if (datalength==sizeof(int64_t)) + { + dltdata->test_counter_function[2]++; + } + break; + } + case 7: + { + slen=strlen("uint")+1; + datalength-=slen; + ptr+=slen; + if (datalength==sizeof(unsigned int)) + { + dltdata->test_counter_function[2]++; + } + break; + } + case 8: + { + slen=strlen("uint8")+1; + datalength-=slen; + ptr+=slen; + if (datalength==sizeof(uint8_t)) + { + dltdata->test_counter_function[2]++; + } + break; + } + case 9: + { + slen=strlen("uint16")+1; + datalength-=slen; + ptr+=slen; + if (datalength==sizeof(uint16_t)) + { + dltdata->test_counter_function[2]++; + } + break; + } + case 10: + { + slen=strlen("uint32")+1; + datalength-=slen; + ptr+=slen; + if (datalength==sizeof(uint32_t)) + { + dltdata->test_counter_function[2]++; + } + break; + } + case 11: + { + slen=strlen("uint64")+1; + datalength-=slen; + ptr+=slen; + if (datalength==sizeof(uint64_t)) + { + dltdata->test_counter_function[2]++; + } + break; + } + case 12: + { + slen=strlen("float32")+1; + datalength-=slen; + ptr+=slen; + /* 2*, as the min and the max is transfered */ + if (datalength==2*sizeof(float)) + { + dltdata->test_counter_function[2]++; + } + break; + } + case 13: + { + slen=strlen("float64")+1; + datalength-=slen; + ptr+=slen; + /* 2*, as the min and the max is transfered */ + if (datalength==2*sizeof(double)) + { + dltdata->test_counter_function[2]++; + } + break; + } + case 14: + { + slen=strlen("raw")+1; + datalength-=slen; + ptr+=slen; + datalength-=sizeof(uint16_t); + ptr+=sizeof(uint16_t); + if (datalength==10) + { + dltdata->test_counter_function[2]++; + } + break; + } + } + + if ((slen>=0) && (tc_old==dltdata->test_counter_function[2])) + { + printf("ID=%d, Datalength=%d => Failed!",id,datalength); + } + } + } + + /* check test 4f */ + if (strcmp(text,"Test4: (Function IF) Test different message sizes")==0) + { + printf("Test4f: (Function IF) Test different message sizes\n"); + dltdata->running_test = 11; + dltdata->test_counter_function[3]=0; + } + else if (strcmp(text,"Test4: (Function IF) finished")==0) + { + if (dltdata->test_counter_function[3]==4) + { + printf("Test4f PASSED\n"); + dltdata->tests_passed++; + } + else + { + printf("Test4f FAILED\n"); + dltdata->tests_failed++; + } + dltdata->running_test = 0; + } + else if (dltdata->running_test==11) + { + /* Extended header */ + if (DLT_IS_HTYP_UEH(message->standardheader->htyp)) + { + /* Log message */ + if ((DLT_GET_MSIN_MSTP(message->extendedheader->msin))==DLT_TYPE_LOG) + { + /* Verbose */ + if (DLT_IS_MSIN_VERB(message->extendedheader->msin)) + { + /* 2 arguments */ + if (message->extendedheader->noar==2) + { + /* verbose mode */ + type_info=0; + type_info_tmp=0; + length=0; + length_tmp=0; /* the macro can set this variable to -1 */ + + ptr = message->databuffer; + datalength = message->datasize; + + /* first read the type info of the first argument: should be string */ + DLT_MSG_READ_VALUE(type_info_tmp,ptr,datalength,uint32_t); + type_info=DLT_ENDIAN_GET_32(message->standardheader->htyp, type_info_tmp); + + if (type_info & DLT_TYPE_INFO_STRG) + { + /* skip string */ + DLT_MSG_READ_VALUE(length_tmp,ptr,datalength,uint16_t); + length=DLT_ENDIAN_GET_16(message->standardheader->htyp, length_tmp); + + if (length>=0) + { + ptr+=length; + datalength-=length; + + /* read type of second argument: should be raw */ + DLT_MSG_READ_VALUE(type_info_tmp,ptr,datalength,uint32_t); + type_info=DLT_ENDIAN_GET_32(message->standardheader->htyp, type_info_tmp); + + if (type_info & DLT_TYPE_INFO_RAWD) + { + /* get length of raw data block */ + DLT_MSG_READ_VALUE(length_tmp,ptr,datalength,uint16_t); + length=DLT_ENDIAN_GET_16(message->standardheader->htyp, length_tmp); + + if ((length>=0) && (length==datalength)) + { + //printf("Raw data found in payload, length="); + //printf("%d, datalength=%d \n", length, datalength); + dltdata->test_counter_function[3]++; + } + } + } + } + } + } + } + } + } + + /* check test 5f */ + if (strcmp(text,"Test5: (Function IF) Test high-level API")==0) + { + printf("Test5f: (Function IF) Test high-level API\n"); + dltdata->running_test = 12; + dltdata->test_counter_function[4]=0; + } + else if (strcmp(text,"Test5: (Function IF) finished")==0) + { + if (dltdata->test_counter_function[4]==12) + { + printf("Test5f PASSED\n"); + dltdata->tests_passed++; + } + else + { + printf("Test5f FAILED\n"); + dltdata->tests_failed++; + } + dltdata->running_test = 0; + } + else if (dltdata->running_test==12) + { + if (strcmp(text,"Next line: dlt_log_int()")==0) + { + dltdata->test_counter_function[4]++; + } + if (strcmp(text,"-42")==0) + { + dltdata->test_counter_function[4]++; + } + + if (strcmp(text,"Next line: dlt_log_uint()")==0) + { + dltdata->test_counter_function[4]++; + } + if (strcmp(text,"42")==0) + { + dltdata->test_counter_function[4]++; + } + + if (strcmp(text,"Next line: dlt_log_string()")==0) + { + dltdata->test_counter_function[4]++; + } + if (strcmp(text,"String output")==0) + { + dltdata->test_counter_function[4]++; + } + + if (strcmp(text,"Next line: dlt_log_raw()")==0) + { + dltdata->test_counter_function[4]++; + } + if (strcmp(text,"00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f")==0) + { + dltdata->test_counter_function[4]++; + } + + if (strcmp(text,"Next line: dlt_log_string_int()")==0) + { + dltdata->test_counter_function[4]++; + } + if (strcmp(text,"String output: -42")==0) + { + dltdata->test_counter_function[4]++; + } + + if (strcmp(text,"Next line: dlt_log_string_uint()")==0) + { + dltdata->test_counter_function[4]++; + } + if (strcmp(text,"String output: 42")==0) + { + dltdata->test_counter_function[4]++; + } + } + + /* check test 6f */ + if (strcmp(text,"Test 6: (Function IF) Test local printing")==0) + { + printf("Test6f: (Function IF) Test local printing\n"); + dltdata->running_test = 13; + dltdata->test_counter_function[5]=0; + } + else if (strcmp(text,"Test6: (Function IF) finished")==0) + { + if (dltdata->test_counter_function[5]==2) + { + printf("Test6f PASSED\n"); + dltdata->tests_passed++; + } + else + { + printf("Test6f FAILED\n"); + dltdata->tests_failed++; + } + dltdata->running_test = 0; + } + else if (dltdata->running_test==13) + { + dltdata->test_counter_function[5]++; + } + + /* check test 7f */ + if (strcmp(text,"Test 7: (Function IF) Test network trace")==0) + { + printf("Test7f: (Function IF) Test network trace\n"); + dltdata->running_test = 14; + dltdata->test_counter_function[6]=0; + } + else if (strcmp(text,"Test7: (Function IF) finished")==0) + { + if (dltdata->test_counter_function[6]==8) + { + printf("Test7f PASSED\n"); + dltdata->tests_passed++; + } + else + { + printf("Test7f FAILED\n"); + dltdata->tests_failed++; + } + dltdata->running_test = 0; + } + else if (dltdata->running_test==14) + { + if (DLT_IS_HTYP_UEH(message->standardheader->htyp)) + { + if ((DLT_GET_MSIN_MSTP(message->extendedheader->msin))==DLT_TYPE_NW_TRACE) + { + /* Check message type information*/ + /* Each correct message type increases the counter by 1 */ + mtin=DLT_GET_MSIN_MTIN(message->extendedheader->msin); + + if (mtin==DLT_NW_TRACE_IPC) + { + dltdata->test_counter_function[6]++; + } + if (mtin==DLT_NW_TRACE_CAN) + { + dltdata->test_counter_function[6]++; + } + if (mtin==DLT_NW_TRACE_FLEXRAY) + { + dltdata->test_counter_function[6]++; + } + if (mtin==DLT_NW_TRACE_MOST) + { + dltdata->test_counter_function[6]++; + } + + /* Check payload, must be two arguments (2 raw data blocks) */ + /* If the payload is correct, the counter is increased by 1 */ + if (message->extendedheader->noar==2) + { + /* verbose mode */ + type_info=0; + type_info_tmp=0; + length=0; + length_tmp=0; /* the macro can set this variable to -1 */ + + ptr = message->databuffer; + datalength = message->datasize; + + /* first read the type info of the first argument: should be string */ + DLT_MSG_READ_VALUE(type_info_tmp,ptr,datalength,uint32_t); + type_info=DLT_ENDIAN_GET_32(message->standardheader->htyp, type_info_tmp); + + if (type_info & DLT_TYPE_INFO_RAWD) + { + /* skip string */ + DLT_MSG_READ_VALUE(length_tmp,ptr,datalength,uint16_t); + length=DLT_ENDIAN_GET_16(message->standardheader->htyp, length_tmp); + + if (length>=0) + { + ptr+=length; + datalength-=length; + + /* read type of second argument: should be raw */ + DLT_MSG_READ_VALUE(type_info_tmp,ptr,datalength,uint32_t); + type_info=DLT_ENDIAN_GET_32(message->standardheader->htyp, type_info_tmp); + + if (type_info & DLT_TYPE_INFO_RAWD) + { + /* get length of raw data block */ + DLT_MSG_READ_VALUE(length_tmp,ptr,datalength,uint16_t); + length=DLT_ENDIAN_GET_16(message->standardheader->htyp, length_tmp); + + if ((length>=0) && (length==datalength)) + { + //printf("Raw data found in payload, length="); + //printf("%d, datalength=%d \n", length, datalength); + dltdata->test_counter_function[6]++; + } + } + } + } + } + } + } + } + + if (strcmp(text,"Tests finished")==0) + { + printf("Tests finished\n"); + dltdata->running_test = 1; + + printf("%d tests passed\n",dltdata->tests_passed); + printf("%d tests failed\n",dltdata->tests_failed); + + if (dltdata->sock!=-1) + { + close(dltdata->sock); + } + + return 0; + } + + /* if no filter set or filter is matching display message */ + if (dltdata->xflag) + { + dlt_message_print_hex(message,text,DLT_TESTCLIENT_TEXTBUFSIZE,dltdata->vflag); + } + else if (dltdata->mflag) + { + dlt_message_print_mixed_plain(message,text,DLT_TESTCLIENT_TEXTBUFSIZE,dltdata->vflag); + } + else if (dltdata->sflag) + { + dlt_message_print_header(message,text,sizeof(text),dltdata->vflag); + } + + /* if file output enabled write message */ + if (dltdata->ovalue) + { + iov[0].iov_base = message->headerbuffer; + iov[0].iov_len = message->headersize; + iov[1].iov_base = message->databuffer; + iov[1].iov_len = message->datasize; + + bytes_written = writev(dltdata->ohandle, iov, 2); + } + } + + return 0; +} |