// mir_free() the return value
static BYTE* GetDataHeader(BYTE *data,DWORD cbDataSize,DWORD *pnDataRecordCount)
{
BYTE *recordData;
/* uncompressed size stored in first DWORD */
*pnDataRecordCount=(*(DWORD*)data)/DATARECORD_SIZE;
recordData=(BYTE*)mir_alloc(*(DWORD*)data);
if (recordData != NULL)
Huffman_Uncompress(data+sizeof(DWORD),recordData,cbDataSize-sizeof(DWORD),*(DWORD*)data);
return recordData;
}
void PollingWorker::PollRS232()
{
char * readBuf;
char * rawByte;
char * unCompressed;
Header * headerBuffer;
Item * sender;
long numBytesToGet;
char receiveID;
DWORD dwCommEvent, dwBytesTransferred;
Msg * newMsg;
isFinish = 0;
while(!isFinish)
{
SetUpDCB(baudRate);
// set up the mask, EV_RXCHAR is the event when we receive a character
if (!SetCommMask(hComm, EV_RXCHAR))
emit error(QString("Error setting communications mask."), (int)GetLastError());
// wait for a character to come in
if (!WaitCommEvent(hComm, &dwCommEvent, NULL))
emit error(QString("Error waiting for a character."), (int)GetLastError());
// we have a character, read the header to see if its good
else
{
if(!isRaw->isChecked())
{
// set up the header buffer
if(!(headerBuffer = (Header *)malloc(sizeof(struct Header))))
emit error(QString("Error malloccing headerBuffer."), (int)GetLastError());
// get the header
if(!ReadFile(hComm, (BYTE *)headerBuffer, HEADERSIZE, &dwBytesTransferred, 0))
emit error(QString("Error getting the header buffer."), (int)GetLastError());
if(headerBuffer->lSignature == 0xDEADBEEF)
{
// get the data length from the header
numBytesToGet = headerBuffer->lDataLength;
readBuf = (char*)calloc(numBytesToGet,sizeof(char));
if (readBuf == NULL)
emit error(QString("Error mallocing readBuf."), (int)GetLastError());
// get the message
if(!ReadFile(hComm, readBuf, numBytesToGet, &dwBytesTransferred, 0))
emit error(QString("Error getting the message."), (int)GetLastError());
emit error(QString("Bytes gotten"), (int)(dwBytesTransferred));
unCompressed = readBuf;
// calculate the checksum and compare
if(headerBuffer->sChecksum != CalculateChecksum(readBuf, headerBuffer->lDataLength))
{
emit transmitError();
//emit error (QString ("Checksum reports errors"),0);
}
if (headerBuffer->bVersion == 0xFF)
{
if(!(unCompressed = (char *)calloc(headerBuffer->lDataUncompressed,sizeof(char))))
emit error(QString("Error malloccing unCompressed."), (int)GetLastError());
Huffman_Uncompress((unsigned char*)readBuf, (unsigned char*)unCompressed, headerBuffer->lDataLength, headerBuffer->lDataUncompressed);
// For testing purposes.
emit error (QString("We have a Huffman buffer."),0);
}else if (headerBuffer->bVersion == 0xF0)
{
if(!(unCompressed = (char *)calloc(headerBuffer->lDataUncompressed,sizeof(char))))
emit error(QString("Error malloccing unCompressed."), (int)GetLastError());
unCompressed = RunLengthDecode(readBuf, headerBuffer->lDataLength);
// For testing purposes.
emit error (QString("We have an RLE buffer."),0);
}else if (headerBuffer->bVersion == 0x0F)
{
if(!(unCompressed = (char *)calloc(headerBuffer->lDataUncompressed,sizeof(char))))
emit error(QString("Error malloccing unCompressed."), (int)GetLastError());
unCompressed = (char*)DifferentialExpand(readBuf, headerBuffer->lDataLength);
// For testing purposes.
emit error (QString("We have a Differential buffer."),0);
}
else
emit error (QString("We have an uncompressed buffer."),0);
receiveID = GetReceiverId(headerBuffer->lReceiverAddr);
if (headerBuffer->bDataType == 0)
{ // If the data is text.
// create a new message structure and put it on the queue
// not all the header options we need are available - ask Jack!
if(!(newMsg = (Msg *)malloc(sizeof(struct message))))
emit error(QString("Error malloccing newMsg."), (int)GetLastError());
strcpy(newMsg->txt, unCompressed);
newMsg->senderID = headerBuffer->bSenderAddr;
newMsg->receiverID = (short)receiveID;
newMsg->msgNum = rand() % 100;
newMsg->priority = headerBuffer->bPriority;
AddToQueue(newMsg);
// Check if the senderID has already been created. If not, create one.
if ((sender = BSTSearch(root, headerBuffer->bSenderAddr))== NULL)
{
Item * newItem = (Item*)(malloc (sizeof(Item)));
int * count = (int*)(malloc (sizeof(int)));
*count = 1;
newItem->key = headerBuffer->bSenderAddr;
newItem->data = count;
root = BSTInsert(root,newItem);
}
else // If it has been created, increment
*((int*)sender->data) = *((int*)sender->data) + 1;
emit labelEdit(QString("Number of Messages: %1").arg(numberOfMessages));
}
else
{
// we have audio, emit the data, the length of the data, and the sample rate
emit audioReceived(headerBuffer->lDataUncompressed,
unCompressed,
headerBuffer->sSamplesPerSec);
}
}
}
else
{
// in raw mode, just grab chunks of bytes as they come
do
{
if(!(rawByte = (char *)calloc(1, sizeof(char))))
emit error(QString("Error malloccing rawByte."), (int)GetLastError());
if(!ReadFile(hComm, rawByte, 1, &dwBytesTransferred, 0))
emit error(QString("Error getting the raw data."), (int)GetLastError());
if(dwBytesTransferred != 0)
emit messageEdit(*rawByte);
}while(dwBytesTransferred != 0);
}
}
}
emit finished();
}
/* Just before starting the client, we may need to make final
adjustments to its initial image. Also we need to set up the VEX
guest state for thread 1 (the root thread) and copy in essential
starting values. This is handed the IIFinaliseImageInfo created by
VG_(ii_create_image).
*/
void VG_(ii_finalise_image)( IIFinaliseImageInfo iifii )
{
UInt adler32_act;
SysRes sres;
/* On AIX we get a block of 37 words telling us the initial state
for (GPR0 .. GPR31, PC, CR, LR, CTR, XER), and we start with all
the other registers zeroed. */
ThreadArchState* arch = &VG_(threads)[1].arch;
# if defined(VGP_ppc32_aix5)
vg_assert(0 == sizeof(VexGuestPPC32State) % 8);
/* Zero out the initial state, and set up the simulated FPU in a
sane way. */
LibVEX_GuestPPC32_initialise(&arch->vex);
/* Zero out the shadow area. */
VG_(memset)(&arch->vex_shadow, 0, sizeof(VexGuestPPC32State));
# else /* defined(VGP_ppc64_aix5) */
vg_assert(0 == sizeof(VexGuestPPC64State) % 8);
/* Zero out the initial state, and set up the simulated FPU in a
sane way. */
LibVEX_GuestPPC64_initialise(&arch->vex);
/* Zero out the shadow area. */
VG_(memset)(&arch->vex_shadow, 0, sizeof(VexGuestPPC64State));
# endif
/* iifii.intregs37 contains the integer register state as it needs
to be at client startup. These values are supplied by the
launcher. The 37 regs are:initial values from launcher for:
GPR0 .. GPR31, PC, CR, LR, CTR, XER. */
/* Put essential stuff into the new state. */
arch->vex.guest_GPR0 = (UWord)iifii.intregs37[0];
arch->vex.guest_GPR1 = (UWord)iifii.intregs37[1];
arch->vex.guest_GPR2 = (UWord)iifii.intregs37[2];
arch->vex.guest_GPR3 = (UWord)iifii.intregs37[3];
arch->vex.guest_GPR4 = (UWord)iifii.intregs37[4];
arch->vex.guest_GPR5 = (UWord)iifii.intregs37[5];
arch->vex.guest_GPR6 = (UWord)iifii.intregs37[6];
arch->vex.guest_GPR7 = (UWord)iifii.intregs37[7];
arch->vex.guest_GPR8 = (UWord)iifii.intregs37[8];
arch->vex.guest_GPR9 = (UWord)iifii.intregs37[9];
arch->vex.guest_GPR10 = (UWord)iifii.intregs37[10];
arch->vex.guest_GPR11 = (UWord)iifii.intregs37[11];
arch->vex.guest_GPR12 = (UWord)iifii.intregs37[12];
arch->vex.guest_GPR13 = (UWord)iifii.intregs37[13];
arch->vex.guest_GPR14 = (UWord)iifii.intregs37[14];
arch->vex.guest_GPR15 = (UWord)iifii.intregs37[15];
arch->vex.guest_GPR16 = (UWord)iifii.intregs37[16];
arch->vex.guest_GPR17 = (UWord)iifii.intregs37[17];
arch->vex.guest_GPR18 = (UWord)iifii.intregs37[18];
arch->vex.guest_GPR19 = (UWord)iifii.intregs37[19];
arch->vex.guest_GPR20 = (UWord)iifii.intregs37[20];
arch->vex.guest_GPR21 = (UWord)iifii.intregs37[21];
arch->vex.guest_GPR22 = (UWord)iifii.intregs37[22];
arch->vex.guest_GPR23 = (UWord)iifii.intregs37[23];
arch->vex.guest_GPR24 = (UWord)iifii.intregs37[24];
arch->vex.guest_GPR25 = (UWord)iifii.intregs37[25];
arch->vex.guest_GPR26 = (UWord)iifii.intregs37[26];
arch->vex.guest_GPR27 = (UWord)iifii.intregs37[27];
arch->vex.guest_GPR28 = (UWord)iifii.intregs37[28];
arch->vex.guest_GPR29 = (UWord)iifii.intregs37[29];
arch->vex.guest_GPR30 = (UWord)iifii.intregs37[30];
arch->vex.guest_GPR31 = (UWord)iifii.intregs37[31];
arch->vex.guest_CIA = (UWord)iifii.intregs37[32+0];
arch->vex.guest_LR = (UWord)iifii.intregs37[32+2];
arch->vex.guest_CTR = (UWord)iifii.intregs37[32+3];
# if defined(VGP_ppc32_aix5)
LibVEX_GuestPPC32_put_CR( (UWord)iifii.intregs37[32+1], &arch->vex );
LibVEX_GuestPPC32_put_XER( (UWord)iifii.intregs37[32+4], &arch->vex );
/* Set the cache line size (KLUDGE) */
VG_(machine_ppc32_set_clszB)( 128 );
# else /* defined(VGP_ppc64_aix5) */
LibVEX_GuestPPC64_put_CR( (UWord)iifii.intregs37[32+1], &arch->vex );
LibVEX_GuestPPC64_put_XER( (UWord)iifii.intregs37[32+4], &arch->vex );
/* Set the cache line size (KLUDGE) */
VG_(machine_ppc64_set_clszB)( 128 );
# endif
/* Fix up the client's command line. Its argc/v/envp is in r3/4/5
(32-bit AIX) or r14/15/16 (64-bit AIX). but that is for the
Valgrind invokation as a whole. Hence we need to decrement argc
and advance argv to step over the args for Valgrind, and the
name of the Valgrind tool exe bogusly inserted by the launcher
(hence the "+1"). */
# if defined(VGP_ppc32_aix5)
{ UWord n_vargs = VG_(sizeXA)( VG_(args_for_valgrind) );
vg_assert(arch->vex.guest_GPR3 >= 1 + n_vargs);
arch->vex.guest_GPR3 -= (1 + n_vargs);
arch->vex.guest_GPR4 += sizeof(UWord) * (1 + n_vargs);
}
# else /* defined(VGP_ppc64_aix5) */
{ UWord n_vargs = VG_(sizeXA)( VG_(args_for_valgrind) );
vg_assert(arch->vex.guest_GPR14 >= 1 + n_vargs);
arch->vex.guest_GPR14 -= (1 + n_vargs);
arch->vex.guest_GPR15 += sizeof(UWord) * (1 + n_vargs);
}
# endif
/* At this point the guest register state is correct for client
startup. However, that's not where we want to start; in fact we
want to start at VG_(ppc{32,64}_aix5_do_preloads_then_start_client),
passing it iifii.preloadpage in r3. This will load the core/tool
preload .so's, then restore r2-r10 from what's stashed in the
preloadpage, and then start the client really. Hence: */
/* Save r2-r10 and the client start point in preloadpage */
iifii.preloadpage->r2 = (ULong)arch->vex.guest_GPR2;
iifii.preloadpage->r3 = (ULong)arch->vex.guest_GPR3;
iifii.preloadpage->r4 = (ULong)arch->vex.guest_GPR4;
iifii.preloadpage->r5 = (ULong)arch->vex.guest_GPR5;
iifii.preloadpage->r6 = (ULong)arch->vex.guest_GPR6;
iifii.preloadpage->r7 = (ULong)arch->vex.guest_GPR7;
iifii.preloadpage->r8 = (ULong)arch->vex.guest_GPR8;
iifii.preloadpage->r9 = (ULong)arch->vex.guest_GPR9;
iifii.preloadpage->r10 = (ULong)arch->vex.guest_GPR10;
iifii.preloadpage->client_start = (ULong)arch->vex.guest_CIA;
# if defined(VGP_ppc32_aix5)
/* Set up to start at VG_(ppc32_aix5_do_preloads_then_start_client) */
arch->vex.guest_CIA = (UWord)&VG_(ppc32_aix5_do_preloads_then_start_client);
# else /* defined(VGP_ppc64_aix5) */
/* Set up to start at VG_(ppc64_aix5_do_preloads_then_start_client) */
arch->vex.guest_CIA = (UWord)&VG_(ppc64_aix5_do_preloads_then_start_client);
# endif
arch->vex.guest_GPR3 = (UWord)iifii.preloadpage;
/* The rest of the preloadpage fields will already have been filled
in by VG_(setup_client_initial_image). So we're done. */
/* Finally, decompress the page compressed by the launcher. We
can't do this any earlier, because the page is (effectively)
decompressed in place, which trashes iifii.intregs37. So we have
to wait till this point, at which we're done with iifii.intregs37
(to be precise, with what it points at). */
VG_(debugLog)(1, "initimg", "decompressing page at %p\n",
(void*)iifii.compressed_page);
vg_assert(VG_IS_PAGE_ALIGNED(iifii.compressed_page));
Huffman_Uncompress( (void*)iifii.compressed_page, unz_page,
VKI_PAGE_SIZE, VKI_PAGE_SIZE );
adler32_act = compute_adler32(unz_page, VKI_PAGE_SIZE);
VG_(debugLog)(1, "initimg",
"decompress done, adler32s: act 0x%x, exp 0x%x\n",
adler32_act, iifii.adler32_exp );
VG_(memcpy)((void*)iifii.compressed_page, unz_page, VKI_PAGE_SIZE);
VG_(debugLog)(1, "initimg", "copy back done\n");
/* Tell the tool that we just wrote to the registers. */
VG_TRACK( post_reg_write, Vg_CoreStartup, /*tid*/1, /*offset*/0,
sizeof(VexGuestArchState));
/* Determine the brk limit. */
VG_(debugLog)(1, "initimg", "establishing current brk ..\n");
vg_assert(__NR_AIX5_sbrk != __NR_AIX5_UNKNOWN);
sres = VG_(do_syscall1)(__NR_AIX5_sbrk, 0);
vg_assert(sres.err == 0); /* assert no error */
VG_(brk_base) = VG_(brk_limit) = sres.res;
VG_(debugLog)(1, "initimg", ".. brk = %p\n", (void*)VG_(brk_base));
}
int TestFile( char *name, int algo, int verbose )
{
unsigned int insize, outsize, bufsize, *work, k, err_count;
unsigned char *in, *out, *buf;
FILE *f;
double t0, t_comp, t_uncomp;
printf( "Testing %s...", name );
/* Open input file */
f = fopen( name, "rb" );
if( !f )
{
printf( "unable to open!\n" );
return 0;
}
/* Get input size */
insize = GetFileSize( f );
if( insize < 1 )
{
printf( "empty file!\n" );
fclose( f );
return 0;
}
/* Worst case output buffer size */
bufsize = (insize*104+50)/100 + 384;
/* Allocate memory */
in = (unsigned char *) malloc( insize + 2*bufsize );
if( !in )
{
printf( "out of memory!\n" );
fclose( f );
return 0;
}
/* Pointers to compression buffer and output memory */
buf = &in[ insize ];
out = &buf[ bufsize ];
/* Read and close input file */
fread( in, 1, insize, f );
fclose( f );
/* Compress and decompress */
switch( algo )
{
case 1:
t0 = GetTime();
outsize = RLE_Compress( in, insize, buf, bufsize );
t_comp = GetTime() - t0;
t0 = GetTime();
RLE_Uncompress( buf, outsize, out, insize );
t_uncomp = GetTime() - t0;
break;
case 2:
t0 = GetTime();
outsize = Huffman_Compress( in, buf, insize );
t_comp = GetTime() - t0;
t0 = GetTime();
Huffman_Uncompress( buf, out, outsize, insize );
t_uncomp = GetTime() - t0;
break;
case 3:
t0 = GetTime();
outsize = Rice_Compress( in, buf, insize, RICE_FMT_UINT8 );
t_comp = GetTime() - t0;
t0 = GetTime();
Rice_Uncompress( buf, out, outsize, insize, RICE_FMT_UINT8 );
t_uncomp = GetTime() - t0;
break;
case 4:
t0 = GetTime();
outsize = Rice_Compress( in, buf, insize, RICE_FMT_UINT16 );
t_comp = GetTime() - t0;
t0 = GetTime();
Rice_Uncompress( buf, out, outsize, insize, RICE_FMT_UINT16 );
t_uncomp = GetTime() - t0;
break;
case 5:
t0 = GetTime();
outsize = Rice_Compress( in, buf, insize, RICE_FMT_UINT32 );
t_comp = GetTime() - t0;
t0 = GetTime();
Rice_Uncompress( buf, out, outsize, insize, RICE_FMT_UINT32 );
t_uncomp = GetTime() - t0;
break;
case 6:
t0 = GetTime();
outsize = Rice_Compress( in, buf, insize, RICE_FMT_INT8 );
t_comp = GetTime() - t0;
t0 = GetTime();
Rice_Uncompress( buf, out, outsize, insize, RICE_FMT_INT8 );
t_uncomp = GetTime() - t0;
break;
case 7:
t0 = GetTime();
outsize = Rice_Compress( in, buf, insize, RICE_FMT_INT16 );
t_comp = GetTime() - t0;
t0 = GetTime();
Rice_Uncompress( buf, out, outsize, insize, RICE_FMT_INT16 );
t_uncomp = GetTime() - t0;
break;
case 8:
t0 = GetTime();
outsize = Rice_Compress( in, buf, insize, RICE_FMT_INT32 );
t_comp = GetTime() - t0;
t0 = GetTime();
Rice_Uncompress( buf, out, outsize, insize, RICE_FMT_INT32 );
t_uncomp = GetTime() - t0;
break;
case 9:
t0 = GetTime();
outsize = LZ_Compress( in, buf, insize );
t_comp = GetTime() - t0;
t0 = GetTime();
LZ_Uncompress( buf, out, outsize );
t_uncomp = GetTime() - t0;
break;
case 10:
work = malloc( sizeof(unsigned int) * (65536+insize) );
if( work )
{
t0 = GetTime();
outsize = LZ_CompressFast( in, buf, insize, work );
t_comp = GetTime() - t0;
free( work );
t0 = GetTime();
LZ_Uncompress( buf, out, outsize );
t_uncomp = GetTime() - t0;
}
else
{
printf( "unable to allocate working buffer!\n" );
t_comp = 0.0;
t_uncomp = 0.0;
outsize = 0;
}
break;
case 11:
t0 = GetTime();
outsize = SF_Compress( in, buf, insize );
t_comp = GetTime() - t0;
t0 = GetTime();
SF_Uncompress( buf, out, outsize, insize );
t_uncomp = GetTime() - t0;
break;
default:
/* Should never happen... */
outsize = 0;
t_comp = 0.0;
t_uncomp = 0.0;
}
err_count = 0;
if(outsize > 0)
{
/* Show compression result */
if( verbose )
{
printf( "\n Compression: %d/%d bytes (%.1f%%)", outsize, insize,
100*(float)outsize/(float)insize );
}
/* Compare input / output data */
for( k = 0; k < insize; ++ k )
{
if( in[ k ] != out[ k ] )
{
if( err_count == 0 ) printf( "\n" );
if( err_count == 30 ) printf( " ...\n" );
else if( err_count < 30 )
{
printf( " %d: %d != %d\n", k, out[ k ], in[ k ] );
}
++ err_count;
}
}
/* Did we have success? */
if( err_count == 0 )
{
printf( " - OK!\n" );
if( verbose )
{
printf( " Compression speed: %.1f KB/s (%.2f ms)\n",
(double) insize / (1024.0 * t_comp), 1000.0 * t_comp );
printf( " Uncompression speed: %.1f KB/s (%.2f ms)\n",
(double) insize / (1024.0 * t_uncomp), 1000.0 * t_uncomp );
}
}
else
{
printf( " *******************************\n" );
printf( " ERROR: %d faulty bytes\n", err_count );
printf( " *******************************\n" );
}
}
/* Free all memory */
free( in );
return (outsize > 0) && (err_count == 0);
}
