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; }