DataRecord* decompress_record(DataRecord *r)
{
if (r->flag & COMPRESS_FLAG) {
char scratch[QLZ_SCRATCH_DECOMPRESS];
int csize = qlz_size_compressed(r->value);
if (csize != r->vsz) {
fprintf(stderr, "broken compressed data: %d != %d, flag=%x\n", csize, r->vsz, r->flag);
goto DECOMP_END;
}
int size = qlz_size_decompressed(r->value);
char *v = malloc(size);
if (v == NULL) {
fprintf(stderr, "malloc(%d)\n", size);
goto DECOMP_END;
}
int ret = qlz_decompress(r->value, v, scratch);
if (ret != size) {
fprintf(stderr, "decompress %s failed: %d != %d\n", r->key, ret, size);
goto DECOMP_END;
}
if (r->free_value) {
free(r->value);
}
r->value = v;
r->free_value = true;
r->vsz = size;
r->flag &= ~COMPRESS_FLAG;
}
return r;
DECOMP_END:
free_record(r);
return NULL;
}
int tst_decomp(FILE *ifile, FILE *ofile, int opt_verbose)
{
char *src, *dst, *scratch;
unsigned int len;
// allocate source buffer
fseek(ifile, 0, SEEK_END);
len = ftell(ifile);
fseek(ifile, 0, SEEK_SET);
src = (char*) malloc(len);
// read file and allocate destination buffer
len = fread(src, 1, len, ifile);
len = qlz_size_decompressed(src);
if (opt_verbose)
printf("%s: uncomp block len: %d\n", progname, len);
dst = (char*) malloc(len);
// QLZ_SCRATCH_DECOMPRESS is defined in the beginning of the quicklz.h file
scratch = (char*) malloc(QLZ_SCRATCH_DECOMPRESS);
// decompress and write result
len = qlz_decompress(src, dst, scratch);
if (opt_verbose)
printf("%s: decompd len: %d\n", progname, len);
fwrite(dst, len, 1, ofile);
return 0;
}
int stream_decompress(FILE *ifile, FILE *ofile)
{
char *file_data, *decompressed;
size_t d, c, dc, fd_size, d_size;
qlz_state_decompress *state_decompress = (qlz_state_decompress *)malloc(sizeof(qlz_state_decompress));
// a compressed packet can be at most MAX_BUF_SIZE + BUF_BUFFER bytes if it
// was compressed with this program.
fd_size = MAX_BUF_SIZE + BUF_BUFFER;
file_data = (char*) malloc(fd_size);
// allocate decompression buffer
d_size = fd_size - BUF_BUFFER;
decompressed = (char*) malloc(d_size);
// allocate and initially zero out the scratch buffer. After this, make sure it is
// preserved across calls and never modified manually
memset(state_decompress, 0, sizeof(qlz_state_decompress));
// read 9-byte header to find the size of the entire compressed packet, and
// then read remaining packet
while((c = fread(file_data, 1, 9, ifile)) != 0)
{
// Do we need a bigger decompressed buffer? If the file was compressed
// with segments larger than the default in this program.
dc = qlz_size_decompressed(file_data);
if (dc > (fd_size - BUF_BUFFER)) {
free(file_data);
fd_size = dc + BUF_BUFFER;
file_data = (char*)malloc(fd_size);
}
// Do we need a bigger compressed buffer?
c = qlz_size_compressed(file_data);
if (c > d_size) {
free (decompressed);
d_size = c;
decompressed = (char*)malloc(d_size);
}
fread(file_data + 9, 1, c - 9, ifile);
d = qlz_decompress(file_data, decompressed, state_decompress);
fwrite(decompressed, d, 1, ofile);
}
free(decompressed);
free(state_decompress);
free(file_data);
return 0;
}
void AdvImageLayout::GetDataFromDataBytes(enum GetByteMode mode, unsigned char* data, unsigned int* prevFrame, unsigned int* pixels, int sectionDataLength, int startOffset)
{
unsigned char* layoutData;
if (!m_UsesCompression)
{
layoutData = data + startOffset;
}
else if (0 == strcmp(Compression, "QUICKLZ"))
{
size_t size = qlz_size_decompressed((char*)(data + startOffset));
// MaxFrameBufferSize
qlz_decompress((char*)(data + startOffset), m_DecompressedPixels, m_StateDecompress);
layoutData = (unsigned char*)m_DecompressedPixels;
}
else if (0 == strcmp(Compression, "LAGARITH16"))
{
int size = m_Lagarith16Decompressor->DecompressData((char*)(data + startOffset), (unsigned short*)m_DecompressedPixels);
layoutData = (unsigned char*)m_DecompressedPixels;
}
bool crcOkay;
int readIndex = 0;
if (Bpp == 12)
{
GetPixelsFrom12BitByteArray(layoutData, prevFrame, pixels, mode, &readIndex, &crcOkay);
}
else if (Bpp == 16)
{
if (IsDiffCorrLayout)
GetPixelsFrom16BitByteArrayDiffCorrLayout(layoutData, prevFrame, pixels, &readIndex, &crcOkay);
else
GetPixelsFrom16BitByteArrayRawLayout(layoutData, prevFrame, pixels, &readIndex, &crcOkay);
}
else if (Bpp == 8)
{
if (IsDiffCorrLayout)
GetPixelsFrom8BitByteArrayDiffCorrLayout(layoutData, prevFrame, pixels, &readIndex, &crcOkay);
else
GetPixelsFrom8BitByteArrayRawLayout(layoutData, prevFrame, pixels, &readIndex, &crcOkay);
}
}
PyObject *qlz_decompress_py(PyObject *self, PyObject *args)
{
PyObject *result = NULL;
PyObject *state = NULL;
char* buffer;
char* decompressed_buffer;
int buffer_length;
int size_decompressed;
#if PY_MAJOR_VERSION >= 3
if (PyArg_ParseTuple(args, "y#O!",
&buffer, &buffer_length,
&QLZStateDecompressType, &state))
#else
if (PyArg_ParseTuple(args, "s#O!",
&buffer, &buffer_length,
&QLZStateDecompressType, &state))
#endif
{
size_decompressed = qlz_size_decompressed(buffer);
decompressed_buffer = (char*)malloc(size_decompressed);
qlz_decompress(buffer, decompressed_buffer,
((qlz_state_decompress_Type*)state)->value);
#if PY_MAJOR_VERSION >= 3
result = Py_BuildValue("y#", decompressed_buffer, size_decompressed);
#else
result = Py_BuildValue("s#", decompressed_buffer, size_decompressed);
#endif
free(decompressed_buffer);
} /* otherwise there is an error,
* the exception already raised by PyArg_ParseTuple, and NULL is
* returned.
*/
return result;
}
int RecvPack(T_Connect *connect,T_NetHead *nethead)
{
char headbuf[HEADPACKLENGTH+1],addr[16];
int i,n;
u_int crc;
char *zbuf;
memset(nethead->para,0,sizeof(nethead->para));
nethead->data=NULL;
peeraddr(connect->Socket,addr);
i=RecvNet(connect->Socket,headbuf,HEADPACKLENGTH,connect->timeout);
if(i<HEADPACKLENGTH){
if(i==TIMEOUTERR) {
ShowLog(1,"%s:head TIMEOUT %d second's",__FUNCTION__,
connect->timeout);
return i;
}
ShowLog(1,"RecvPack Head LENERR i=%d,err=%d,%s",i,errno,strerror(errno));
return LENGERR;
}
if(connect->CryptFlg & DO_CRYPT)
enigma2_decrypt(&connect->t,headbuf,HEADPACKLENGTH);
i=NetHeadDispack(nethead,headbuf,connect->family[29]);
if(i!=0) {
ShowLog(1,"aft NetHeadDispack len=%d,PKGERR %s",i, addr);
showpack(1,headbuf,HEADPACKLENGTH);
return(FORMATERR);
}
if(!nethead->T_LEN) return 0;
if(connect->CryptFlg&UNDO_ZIP) {
i=nethead->T_LEN+1;
} else {
i=nethead->PKG_LEN+1;
if(nethead->T_LEN <nethead->PKG_LEN) i+=nethead->T_LEN+1;
}
n=connect->RecvLen-i;
if(!connect->RecvBuffer || n<0 || n>32768){
if(connect->RecvBuffer) {
free(connect->RecvBuffer);
connect->RecvBuffer=0;
}
connect->RecvLen=0;
connect->RecvBuffer=malloc(i);
if(!connect->RecvBuffer) return MEMERR;
connect->RecvLen=i;
}
if(!(connect->CryptFlg&UNDO_ZIP) && nethead->T_LEN != nethead->PKG_LEN) {
zbuf=connect->RecvBuffer+nethead->PKG_LEN+1;
} else zbuf=connect->RecvBuffer;
i=RecvNet(connect->Socket,zbuf,nethead->T_LEN,5);
if(i != (nethead->T_LEN)) {
if(TIMEOUTERR == i) {
ShowLog(1,"%s:recv body TIMEOUT",__FUNCTION__);
return i;
}
ShowLog(1,"%s,Recv Body T_LEN=%d i=%d,errno=%d",__FUNCTION__,
nethead->T_LEN,i,errno);
free(connect->RecvBuffer);
connect->RecvBuffer=0;
connect->RecvLen=0;
return i<0?SYSERR:LENGERR;
}
crc=ssh_crc32((const unsigned char *)zbuf, nethead->T_LEN);
if((connect->CryptFlg & CHECK_CRC) && (crc != nethead->PKG_CRC)) {
ShowLog(1,"RecvPack:PKG_CRC=%08X,crc=%08X,PKG_LEN=%d,T_LEN=%d,head=%s",
nethead->PKG_CRC,crc,nethead->PKG_LEN,nethead->T_LEN,headbuf);
return CRCERR;
}
pack_decode(zbuf, nethead->T_LEN,connect);
if(zbuf != connect->RecvBuffer) {
size_t sz=qlz_size_decompressed(zbuf);
if(nethead->T_LEN<9 || nethead->PKG_LEN != sz) {
ShowLog(1,"unzip error T_LEN=%d,sz=%ld,PKG_LEN=%d,ADDR=%s",nethead->T_LEN, sz,nethead->PKG_LEN,addr);
return FORMATERR;
}
i=qlz_decompress(zbuf,connect->RecvBuffer);
if(i!=nethead->PKG_LEN) {
ShowLog(1,"RecvPack:PKG_LEN=%d,T_LEN=%d,unzip_size=%d",
nethead->PKG_LEN,nethead->T_LEN,i);
return LENGERR;
}
} //else if(connect->CryptFlg & UNDO_ZIP)
// ShowLog(5,"%s:UNDO_ZIP %s,T_LEN=%d,PKG_LEN=%d,data=%s",__FUNCTION__,
// *connect->Host?connect->Host:"Client",nethead->T_LEN,nethead->PKG_LEN,connect->RecvBuffer);
if(!(connect->CryptFlg & UNDO_ZIP)) connect->RecvBuffer[nethead->PKG_LEN]=0;
nethead->data=connect->RecvBuffer;
return 0;
}
int main(int argc, char* argv[])
{
input_file = stdin;
output_file = stdout;
char *src = 0;
char *dst = 0;
size_t input_file_size = 0;
size_t output_file_size = 0;
char inputBuffer[1];
size_t bytesRead = 0;
parseArgv(argc, argv);
if(show_help)
{
printf("Quicklz implementation version 1:\n");
printf("\n");
printf("usage: quicklz [options]:\n");
printf("\n");
printf(" -f file - input file that will be compress or decompress. This can be stdin.\n");
printf(" -h - show this help message.\n");
printf(" -o file - output file. This can be stdout.\n");
printf(" -d - will decompress the file given via stdin or via -f option.\n");
printf("\n");
printf("Examples:.\n");
printf("\n");
printf(" cat file.qlz | quicklz -d > file\n");
printf(" cat file | quicklz > file.qlz\n");
printf(" quicklz -i file -o file.qlz\n");
printf(" quicklz -d -i file.qlz -o file\n");
exit(0);
}
do
{
bytesRead = fread(
inputBuffer,
1,
1,
input_file
);
char *tmp = (char*)realloc(src, input_file_size + bytesRead);
if (tmp)
{
src = tmp;
memmove(&src[input_file_size], inputBuffer, bytesRead);
input_file_size += bytesRead;
}
else
{
free(src);
exit(1);
}
} while (!feof(input_file));
if(compress)
{
qlz_state_compress *state_compress = (qlz_state_compress *)malloc(sizeof(qlz_state_compress));
dst = (char*) malloc(input_file_size + 400);
output_file_size = qlz_compress(src, dst, input_file_size, state_compress);
}
else if(decompress)
{
qlz_state_decompress *state_decompress = (qlz_state_decompress *)malloc(sizeof(qlz_state_decompress));
output_file_size = qlz_size_decompressed(src);
dst = (char*) malloc(output_file_size);
output_file_size = qlz_decompress(src, dst, state_decompress);
}
fwrite(dst, output_file_size, 1, output_file);
fclose(input_file);
fclose(output_file);
return 0;
}
int RecvPack(T_Connect *connect,T_NetHead *nethead)
{
char headbuf[HEADPACKLENGTH+1],addr[16];
int i,n;
u_int crc;
char *zbuf;
n_zero(PARANUM,nethead->para);
nethead->data=0;
memset(headbuf,0,sizeof(headbuf));
i=RecvNet(connect->Socket,headbuf,HEADPACKLENGTH,connect->timeout);
//free SendBuffer
if(i<HEADPACKLENGTH){
if(i==TIMEOUTERR) {
ShowLog(1,"%s:head TIMEOUT %d second's",__FUNCTION__,
connect->timeout);
return i;
}
ShowLog(1,"RecvPack Head LENERR i=%d,err=%d,%s",i,errno,strerror(errno));
return LENGERR;
}
headbuf[HEADPACKLENGTH]=0;
i=NetHeadDispack(nethead,headbuf,connect->family[29]);
if(i!=0) {
peeraddr(connect->Socket,addr);
ShowLog(1,"aft NetHeadDispack len=%d,PKGERR %s:%.48s",i, addr,headbuf);
showpack(1,headbuf,HEADPACKLENGTH);
return(FORMATERR);
}
if(!nethead->T_LEN) return 0;
i=((connect->CryptFlg&UNDO_ZIP)?nethead->T_LEN:nethead->PKG_LEN)+1;
n=connect->RecvLen-i;
if(n<0 || n>SDBC_BLKSZ){
if( connect->RecvBuffer)
free(connect->RecvBuffer);
connect->RecvBuffer=0;
connect->RecvLen=0;
connect->RecvBuffer=malloc(i);
if(!connect->RecvBuffer) return MEMERR;
connect->RecvLen=i;
}
if(!(connect->CryptFlg&UNDO_ZIP) && nethead->T_LEN != nethead->PKG_LEN) {
zbuf=malloc(nethead->T_LEN);
if(!zbuf) {
RecvNet(connect->Socket,connect->RecvBuffer,nethead->T_LEN,3);
return MEMERR;
}
} else zbuf=connect->RecvBuffer;
i=RecvNet(connect->Socket,zbuf,nethead->T_LEN,3);
if(i < (nethead->T_LEN)) {
if(TIMEOUTERR == i) {
ShowLog(1,"%s:recv body TIMEOUT",__FUNCTION__);
return i;
}
if(zbuf!=connect->RecvBuffer) free(zbuf);
ShowLog(1,"%s,Recv Body T_LEN=%d i=%d,errno=%d",__FUNCTION__,
nethead->T_LEN,i,errno);
free(connect->RecvBuffer);
connect->RecvBuffer=0;
connect->RecvLen=0;
return i<0?SYSERR:LENGERR;
}
crc=ssh_crc32((const unsigned char *)zbuf, nethead->T_LEN);
if((connect->CryptFlg & CHECK_CRC) && (crc != nethead->PKG_CRC)) {
ShowLog(1,"RecvPack:PKG_CRC=%08X,crc=%08X,PKG_LEN=%d,T_LEN=%d,head=%s",
nethead->PKG_CRC,crc,nethead->PKG_LEN,nethead->T_LEN,headbuf);
return CRCERR;
}
pack_decode(zbuf, nethead->T_LEN,connect);
if(zbuf != connect->RecvBuffer) {
if(nethead->T_LEN<9 || nethead->PKG_LEN != qlz_size_decompressed(zbuf)) {
ShowLog(1,"unzip error T_LEN=%d,ADDR=%s",nethead->T_LEN, addr);
return FORMATERR;
}
i=qlz_decompress(zbuf,connect->RecvBuffer);
free(zbuf);
if(i!=nethead->PKG_LEN) {
ShowLog(1,"RecvPack:PKG_LEN=%d,T_LEN=%d,unzip_size=%d",
nethead->PKG_LEN,nethead->T_LEN,i);
return LENGERR;
}
}
connect->RecvBuffer[nethead->PKG_LEN]=0;
nethead->data=connect->RecvBuffer;
return 0;
}
