mirror of https://github.com/Cisco-Talos/clamav
Tomasz Kojm
19 years ago
parent
12751467d9
commit
24fd05e150
@ -0,0 +1,624 @@ |
||||
/*
|
||||
* Copyright (C) 2006 Tomasz Kojm <tkojm@clamav.net> |
||||
* |
||||
* This code is based on the work of Stuart Caie and the official |
||||
* specification. |
||||
* |
||||
* This program is free software; you can redistribute it and/or modify |
||||
* it under the terms of the GNU General Public License version 2 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 General Public License for more details. |
||||
* |
||||
* You should have received a copy of the GNU General Public License |
||||
* along with this program; if not, write to the Free Software |
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, |
||||
* MA 02110-1301, USA. |
||||
*/ |
||||
|
||||
#if HAVE_CONFIG_H |
||||
#include "clamav-config.h" |
||||
#endif |
||||
|
||||
#include <stdio.h> |
||||
#include <string.h> |
||||
#include <ctype.h> |
||||
#include <sys/types.h> |
||||
#include <sys/stat.h> |
||||
#ifdef HAVE_UNISTD_H |
||||
#include <unistd.h> |
||||
#endif |
||||
#include <fcntl.h> |
||||
|
||||
#include "cltypes.h" |
||||
#include "others.h" |
||||
#include "mspack.h" |
||||
#include "cab.h" |
||||
|
||||
#define EC32(x) le32_to_host(x) /* Convert little endian to host */ |
||||
#define EC16(x) le16_to_host(x) |
||||
|
||||
#ifndef O_BINARY |
||||
#define O_BINARY 0 |
||||
#endif |
||||
|
||||
/* hard limits */ |
||||
#define CAB_FOLDER_LIMIT 5000 |
||||
#define CAB_FILE_LIMIT 5000 |
||||
|
||||
/* Cabinet format data structures */ |
||||
|
||||
struct cab_hdr { |
||||
uint32_t signature; /* file signature */ |
||||
uint32_t res1; /* reserved */ |
||||
uint32_t cbCabinet; /* size of cabinet file */ |
||||
uint32_t res2; /* reserved */ |
||||
uint32_t coffFiles; /* offset of the first file entry */ |
||||
uint32_t res3; /* reserved */ |
||||
uint8_t versionMinor; /* file format version, minor */ |
||||
uint8_t versionMajor; /* file format version, major */ |
||||
uint16_t cFolders; /* number of folder entries */ |
||||
uint16_t cFiles; /* number of file entries */ |
||||
uint16_t flags; /* option flags */ |
||||
uint16_t setID; /* multiple cabs related */ |
||||
uint16_t iCabinet; /* multiple cabs related */ |
||||
}; |
||||
|
||||
struct cab_hdr_opt { |
||||
uint16_t cbCFHeader; /* size of reserved header area */ |
||||
uint8_t cbCFFolder; /* size of reserved folder area */ |
||||
uint8_t cbCFData; /* size of reserved block area */ |
||||
}; |
||||
|
||||
struct cab_folder_hdr |
||||
{ |
||||
uint32_t coffCabStart; /* offset of the first data block */ |
||||
uint16_t cCFData; /* number of data blocks */ |
||||
uint16_t typeCompress; /* compression type */ |
||||
}; |
||||
|
||||
struct cab_file_hdr |
||||
{ |
||||
uint32_t cbFile; /* uncompressed size */ |
||||
uint32_t uoffFolderStart; /* uncompressed offset of file in folder */ |
||||
uint16_t iFolder; /* folder index */ |
||||
uint16_t date; /* date stamp */ |
||||
uint16_t time; /* time stamp */ |
||||
uint16_t attribs; /* attribute flags */ |
||||
}; |
||||
|
||||
struct cab_block_hdr |
||||
{ |
||||
uint32_t csum; /* data block checksum */ |
||||
uint16_t cbData; /* number of compressed bytes */ |
||||
uint16_t cbUncomp; /* number of uncompressed bytes */ |
||||
}; |
||||
|
||||
char *cab_readstr(int fd, int *ret) |
||||
{ |
||||
int i, bread, found = 0; |
||||
char buff[256], *str; |
||||
off_t pos; |
||||
|
||||
|
||||
if((pos = lseek(fd, 0, SEEK_CUR)) == -1) { |
||||
*ret = CL_EIO; |
||||
return NULL; |
||||
} |
||||
|
||||
bread = read(fd, buff, sizeof(buff)); |
||||
for(i = 0; i < bread; i++) { |
||||
if(!buff[i]) { |
||||
found = 1; |
||||
break; |
||||
} |
||||
} |
||||
|
||||
if(!found) { |
||||
*ret = CL_EFORMAT; |
||||
return NULL; |
||||
} |
||||
|
||||
if(lseek(fd, (off_t) (pos + i + 1), SEEK_SET) == -1) { |
||||
*ret = CL_EIO; |
||||
return NULL; |
||||
} |
||||
|
||||
if(!(str = cli_strdup(buff))) { |
||||
*ret = CL_EMEM; |
||||
return NULL; |
||||
} |
||||
|
||||
*ret = CL_SUCCESS; |
||||
return str; |
||||
} |
||||
|
||||
int cab_chkname(const char *name) |
||||
{ |
||||
size_t i, len = strlen(name); |
||||
|
||||
|
||||
for(i = 0; i < len; i++) { |
||||
if(strchr("%/*?|\\\"+=<>;:\t ", name[i]) || !isascii(name[i])) { |
||||
cli_dbgmsg("cab_chkname: File name contains disallowed characters\n"); |
||||
return 1; |
||||
} |
||||
} |
||||
|
||||
return 0; |
||||
} |
||||
|
||||
void cab_free(struct cab_archive *cab) |
||||
{ |
||||
struct cab_folder *folder; |
||||
struct cab_file *file; |
||||
|
||||
|
||||
while(cab->folders) { |
||||
folder = cab->folders; |
||||
cab->folders = cab->folders->next; |
||||
free(folder); |
||||
} |
||||
|
||||
while(cab->files) { |
||||
file = cab->files; |
||||
cab->files = cab->files->next; |
||||
free(file->name); |
||||
free(file); |
||||
} |
||||
} |
||||
|
||||
int cab_open(int fd, off_t offset, struct cab_archive *cab) |
||||
{ |
||||
unsigned int i, bscore = 0; |
||||
struct cab_file *file, *lfile = NULL; |
||||
struct cab_folder *folder, *lfolder = NULL; |
||||
struct cab_hdr hdr; |
||||
struct cab_hdr_opt hdr_opt; |
||||
struct cab_folder_hdr folder_hdr; |
||||
struct cab_file_hdr file_hdr; |
||||
struct stat sb; |
||||
uint16_t fidx; |
||||
char *pt; |
||||
int ret; |
||||
off_t resfold = 0, rsize; |
||||
|
||||
|
||||
if(lseek(fd, offset, SEEK_SET) == -1) { |
||||
cli_errmsg("cab_open: Can't lseek to %u (offset)\n", (unsigned int) offset); |
||||
return CL_EIO; |
||||
} |
||||
|
||||
if(cli_readn(fd, &hdr, sizeof(hdr)) != sizeof(hdr)) { |
||||
cli_dbgmsg("cab_open: Can't read cabinet header\n"); |
||||
return CL_EIO; |
||||
} |
||||
|
||||
if(EC32(hdr.signature) != 0x4643534d) { |
||||
cli_dbgmsg("cab_open: Incorrect CAB signature\n"); |
||||
return CL_EFORMAT; |
||||
} else { |
||||
cli_dbgmsg("CAB: -------------- Cabinet file ----------------\n"); |
||||
} |
||||
|
||||
if(fstat(fd, &sb) == -1) { |
||||
cli_errmsg("cab_open: Can't fstat descriptor %d\n", fd); |
||||
return CL_EIO; |
||||
} |
||||
rsize = sb.st_size; |
||||
|
||||
memset(cab, 0, sizeof(struct cab_archive)); |
||||
|
||||
cab->length = EC32(hdr.cbCabinet); |
||||
cli_dbgmsg("CAB: Cabinet length: %u\n", cab->length); |
||||
if((off_t) cab->length > rsize) |
||||
bscore++; |
||||
|
||||
cab->nfolders = EC16(hdr.cFolders); |
||||
if(!cab->nfolders) { |
||||
cli_dbgmsg("cab_open: No folders in cabinet (fake cab?)\n"); |
||||
return CL_EFORMAT; |
||||
} else { |
||||
cli_dbgmsg("CAB: Folders: %u\n", cab->nfolders); |
||||
if(cab->nfolders > CAB_FOLDER_LIMIT) { |
||||
cab->nfolders = CAB_FOLDER_LIMIT; |
||||
cli_dbgmsg("CAB: *** Number of folders limited to %u ***\n", cab->nfolders); |
||||
bscore++; |
||||
} |
||||
} |
||||
|
||||
cab->nfiles = EC16(hdr.cFiles); |
||||
if(!cab->nfiles) { |
||||
cli_dbgmsg("cab_open: No files in cabinet (fake cab?)\n"); |
||||
return CL_EFORMAT; |
||||
} else { |
||||
cli_dbgmsg("CAB: Files: %u\n", cab->nfiles); |
||||
if(cab->nfiles > CAB_FILE_LIMIT) { |
||||
cab->nfiles = CAB_FILE_LIMIT; |
||||
cli_dbgmsg("CAB: *** Number of files limited to %u ***\n", cab->nfiles); |
||||
bscore++; |
||||
} |
||||
} |
||||
|
||||
cli_dbgmsg("CAB: File format version: %u.%u\n", hdr.versionMajor, hdr.versionMinor); |
||||
if(hdr.versionMajor != 1 || hdr.versionMinor != 3) |
||||
bscore++; |
||||
|
||||
cab->flags = EC16(hdr.flags); |
||||
if(cab->flags & 0x0004) { |
||||
if(cli_readn(fd, &hdr_opt, sizeof(hdr_opt)) != sizeof(hdr_opt)) { |
||||
cli_dbgmsg("cab_open: Can't read file header (fake cab?)\n"); |
||||
return CL_EIO; |
||||
} |
||||
|
||||
cab->reshdr = EC16(hdr_opt.cbCFHeader); |
||||
resfold = hdr_opt.cbCFFolder; |
||||
cab->resdata = hdr_opt.cbCFData; |
||||
|
||||
if(cab->reshdr) { |
||||
if(lseek(fd, cab->reshdr, SEEK_CUR) == -1) { |
||||
cli_dbgmsg("cab_open: Can't lseek to %u (fake cab?)\n", cab->reshdr); |
||||
return CL_EIO; |
||||
} |
||||
} |
||||
} |
||||
|
||||
if(cab->flags & 0x0001) { /* preceeding cabinet */ |
||||
/* name */ |
||||
pt = cab_readstr(fd, &ret); |
||||
if(ret) |
||||
return ret; |
||||
if(cab_chkname(pt)) |
||||
bscore++; |
||||
else |
||||
cli_dbgmsg("CAB: Preceeding cabinet name: %s\n", pt); |
||||
free(pt); |
||||
/* info */ |
||||
pt = cab_readstr(fd, &ret); |
||||
if(ret) |
||||
return ret; |
||||
if(cab_chkname(pt)) |
||||
bscore++; |
||||
else |
||||
cli_dbgmsg("CAB: Preceeding cabinet info: %s\n", pt); |
||||
free(pt); |
||||
} |
||||
|
||||
if(cab->flags & 0x0002) { /* next cabinet */ |
||||
/* name */ |
||||
pt = cab_readstr(fd, &ret); |
||||
if(ret) |
||||
return ret; |
||||
if(cab_chkname(pt)) |
||||
bscore++; |
||||
else |
||||
cli_dbgmsg("CAB: Next cabinet name: %s\n", pt); |
||||
free(pt); |
||||
/* info */ |
||||
pt = cab_readstr(fd, &ret); |
||||
if(ret) |
||||
return ret; |
||||
if(cab_chkname(pt)) |
||||
bscore++; |
||||
else |
||||
cli_dbgmsg("CAB: Next cabinet info: %s\n", pt); |
||||
free(pt); |
||||
} |
||||
|
||||
if(bscore >= 4) { |
||||
cli_dbgmsg("CAB: bscore == %u, most likely a fake cabinet\n", bscore); |
||||
return CL_EFORMAT; |
||||
} |
||||
|
||||
/* folders */ |
||||
for(i = 0; i < cab->nfolders; i++) { |
||||
if(cli_readn(fd, &folder_hdr, sizeof(folder_hdr)) != sizeof(folder_hdr)) { |
||||
cli_errmsg("cab_open: Can't read header for folder %u\n", i); |
||||
cab_free(cab); |
||||
return CL_EIO; |
||||
} |
||||
|
||||
if(resfold) { |
||||
if(lseek(fd, resfold, SEEK_CUR) == -1) { |
||||
cli_errmsg("cab_open: Can't lseek to %u (resfold)\n", (unsigned int) resfold); |
||||
cab_free(cab); |
||||
return CL_EIO; |
||||
} |
||||
} |
||||
|
||||
folder = (struct cab_folder *) cli_calloc(1, sizeof(struct cab_folder)); |
||||
if(!folder) { |
||||
cli_errmsg("cab_open: Can't allocate memory for folder\n"); |
||||
cab_free(cab); |
||||
return CL_EMEM; |
||||
} |
||||
|
||||
folder->cab = (struct cab_archive *) cab; |
||||
folder->offset = (off_t) EC32(folder_hdr.coffCabStart) + offset; |
||||
if(folder->offset > rsize) |
||||
bscore++; |
||||
folder->nblocks = EC16(folder_hdr.cCFData); |
||||
folder->cmethod = EC16(folder_hdr.typeCompress); |
||||
|
||||
cli_dbgmsg("CAB: Folder record %u\n", i); |
||||
cli_dbgmsg("CAB: Folder offset: %u\n", (unsigned int) folder->offset); |
||||
cli_dbgmsg("CAB: Folder compression method: %d\n", folder->cmethod); |
||||
if((folder->cmethod & 0x000f) > 3) |
||||
bscore++; |
||||
|
||||
if(!lfolder) |
||||
cab->folders = folder; |
||||
else |
||||
lfolder->next = folder; |
||||
|
||||
lfolder = folder; |
||||
|
||||
if(bscore > 10) { |
||||
cab_free(cab); |
||||
cli_dbgmsg("CAB: bscore == %u, most likely a fake cabinet\n", bscore); |
||||
return CL_EFORMAT; |
||||
} |
||||
} |
||||
|
||||
/* files */ |
||||
for(i = 0; i < cab->nfiles; i++) { |
||||
if(cli_readn(fd, &file_hdr, sizeof(file_hdr)) != sizeof(file_hdr)) { |
||||
cli_errmsg("cab_open: Can't read file %u header\n", i); |
||||
cab_free(cab); |
||||
return CL_EIO; |
||||
} |
||||
|
||||
file = (struct cab_file *) cli_calloc(1, sizeof(struct cab_file)); |
||||
if(!file) { |
||||
cli_errmsg("cab_open: Can't allocate memory for file\n"); |
||||
cab_free(cab); |
||||
return CL_EMEM; |
||||
} |
||||
|
||||
file->cab = cab; |
||||
file->fd = fd; |
||||
file->length = EC32(file_hdr.cbFile); |
||||
file->offset = EC32(file_hdr.uoffFolderStart); |
||||
file->attribs = EC32(file_hdr.attribs); |
||||
fidx = EC32(file_hdr.iFolder); |
||||
|
||||
file->name = cab_readstr(fd, &ret); |
||||
if(ret) { |
||||
free(file); |
||||
cab_free(cab); |
||||
return ret; |
||||
} |
||||
|
||||
cli_dbgmsg("CAB: File record %u\n", i); |
||||
cli_dbgmsg("CAB: File name: %s\n", file->name); |
||||
cli_dbgmsg("CAB: File offset: %u\n", file->offset); |
||||
cli_dbgmsg("CAB: File folder index: %u\n", fidx); |
||||
cli_dbgmsg("CAB: File attribs: 0x%x\n", file->attribs); |
||||
if(file->attribs & 0x01) |
||||
cli_dbgmsg("CAB: * file is read-only\n"); |
||||
if(file->attribs & 0x02) |
||||
cli_dbgmsg("CAB: * file is hidden\n"); |
||||
if(file->attribs & 0x04) |
||||
cli_dbgmsg("CAB: * file is a system file\n"); |
||||
if(file->attribs & 0x20) |
||||
cli_dbgmsg("CAB: * file modified since last backup\n"); |
||||
if(file->attribs & 0x40) |
||||
cli_dbgmsg("CAB: * file to be run after extraction\n"); |
||||
if(file->attribs & 0x80) |
||||
cli_dbgmsg("CAB: * file name contains UTF\n"); |
||||
|
||||
/* folder index */ |
||||
if(fidx < 0xfffd) { |
||||
if(fidx > cab->nfolders) { |
||||
cli_warnmsg("cab_open: File %s is not associated with any folder\n", file->name); |
||||
free(file->name); |
||||
free(file); |
||||
continue; |
||||
} |
||||
|
||||
file->folder = cab->folders; |
||||
while(file->folder && fidx--) |
||||
file->folder = file->folder->next; |
||||
|
||||
if(!file->folder) { |
||||
cli_errmsg("cab_open: Folder not found for file %s\n", file->name); |
||||
free(file->name); |
||||
free(file); |
||||
cab_free(cab); |
||||
return CL_EFORMAT; |
||||
} |
||||
|
||||
} else { |
||||
cli_dbgmsg("CAB: File is split *skipping*\n"); |
||||
free(file->name); |
||||
free(file); |
||||
continue; |
||||
} |
||||
|
||||
if(!lfile) |
||||
cab->files = file; |
||||
else |
||||
lfile->next = file; |
||||
|
||||
lfile = file; |
||||
|
||||
if(bscore > 10) { |
||||
cab_free(cab); |
||||
cli_dbgmsg("CAB: bscore == %u, most likely a fake cabinet\n", bscore); |
||||
return CL_EFORMAT; |
||||
} |
||||
} |
||||
|
||||
return CL_SUCCESS; |
||||
} |
||||
|
||||
static int cab_read_block(int fd, struct cab_state *state, uint16_t resdata) |
||||
{ |
||||
struct cab_block_hdr block_hdr; |
||||
|
||||
|
||||
if(cli_readn(fd, &block_hdr, sizeof(block_hdr)) != sizeof(block_hdr)) { |
||||
cli_errmsg("cab_read_block: Can't read block header\n"); |
||||
return CL_EIO; |
||||
} |
||||
|
||||
if(resdata && lseek(fd, (off_t) resdata, SEEK_CUR) == -1) { |
||||
cli_dbgmsg("cab_read_block: lseek failed\n"); |
||||
return CL_EIO; |
||||
} |
||||
|
||||
state->blklen = EC16(block_hdr.cbData); |
||||
if(state->blklen > CAB_INPUTMAX) { |
||||
cli_dbgmsg("cab_read_block: block size > CAB_INPUTMAX\n"); |
||||
return CL_EFORMAT; |
||||
} |
||||
|
||||
state->outlen = EC16(block_hdr.cbUncomp); |
||||
|
||||
if(state->outlen > CAB_BLOCKMAX) { |
||||
cli_dbgmsg("cab_read_block: output size > CAB_BLOCKMAX\n"); |
||||
return CL_EFORMAT; |
||||
} |
||||
|
||||
if(cli_readn(fd, state->block, state->blklen) != state->blklen) { |
||||
cli_dbgmsg("cab_read_block: Can't read block data\n"); |
||||
return CL_EIO; |
||||
} |
||||
|
||||
state->pt = state->end = state->block; |
||||
state->end += state->blklen; |
||||
|
||||
return CL_SUCCESS; |
||||
} |
||||
|
||||
static int cab_read(struct cab_file *file, unsigned char *buffer, int bytes) |
||||
{ |
||||
uint16_t todo, left; |
||||
|
||||
|
||||
todo = bytes; |
||||
while(todo > 0) { |
||||
left = file->state->end - file->state->pt; |
||||
|
||||
if(left) { |
||||
if(left > todo) |
||||
left = todo; |
||||
|
||||
memcpy(buffer, file->state->pt, left); |
||||
file->state->pt += left; |
||||
buffer += left; |
||||
todo -= left; |
||||
|
||||
} else { |
||||
if(file->state->blknum++ >= file->folder->nblocks) { |
||||
file->error = CL_EFORMAT; |
||||
break; |
||||
} |
||||
|
||||
file->error = cab_read_block(file->fd, file->state, file->cab->resdata); |
||||
if(file->error) |
||||
return -1; |
||||
|
||||
if((file->folder->cmethod & 0x000f) == 0x0002) /* Quantum hack */ |
||||
*file->state->end++ = 0xff; |
||||
|
||||
if(file->state->blknum >= file->folder->nblocks) { |
||||
if((file->folder->cmethod & 0x000f) == 0x0003) { /* LZX hack */ |
||||
lzx_set_output_length(file->state->stream, (off_t) ((file->state->blknum - 1) * CAB_BLOCKMAX + file->state->outlen)); |
||||
} |
||||
} else { |
||||
if(file->state->outlen != CAB_BLOCKMAX) { |
||||
cli_dbgmsg("cab_read: WARNING: partial data block\n"); |
||||
} |
||||
} |
||||
} |
||||
} |
||||
|
||||
return bytes - todo; |
||||
} |
||||
|
||||
int cab_extract(int fd, struct cab_file *file, const char *name) |
||||
{ |
||||
struct cab_folder *folder; |
||||
int ofd, ret; |
||||
|
||||
|
||||
if(!file || !name) { |
||||
cli_errmsg("cab_extract: !file || !name\n"); |
||||
return CL_ENULLARG; |
||||
} |
||||
|
||||
if(!(folder = file->folder)) { |
||||
cli_errmsg("cab_extract: file->folder == NULL\n"); |
||||
return CL_ENULLARG; |
||||
} |
||||
|
||||
if(lseek(fd, file->folder->offset, SEEK_SET) == -1) { |
||||
cli_errmsg("cab_extract: Can't lseek to %u\n", file->folder->offset); |
||||
return CL_EIO; |
||||
} |
||||
|
||||
file->state = (struct cab_state *) cli_calloc(1, sizeof(struct cab_state)); |
||||
if(!file->state) { |
||||
cli_errmsg("cab_extract: Can't allocate memory for internal state\n"); |
||||
return CL_EIO; |
||||
} |
||||
|
||||
ofd = open(name, O_WRONLY|O_CREAT|O_TRUNC|O_BINARY, S_IRWXU); |
||||
if(ofd == -1) { |
||||
cli_errmsg("cab_extract: Can't open file %s in write mode\n", name); |
||||
free(file->state); |
||||
return CL_EIO; |
||||
} |
||||
|
||||
/* initialize decompressors */ |
||||
switch(file->folder->cmethod & 0x000f) { |
||||
case 0x0001: /* MSZIP */ |
||||
cli_dbgmsg("CAB: Compression method: MSZIP\n"); |
||||
file->state->stream = (struct mszip_stream *) mszip_init(fd, ofd, 4096, 1, file, &cab_read); |
||||
if(file->offset) { |
||||
((struct mszip_stream *) file->state->stream)->wflag = 0; |
||||
mszip_decompress(file->state->stream, file->offset); |
||||
((struct mszip_stream *) file->state->stream)->wflag = 1; |
||||
} |
||||
ret = mszip_decompress(file->state->stream, file->length); |
||||
mszip_free(file->state->stream); |
||||
break; |
||||
|
||||
case 0x0002: /* QUANTUM */ |
||||
cli_dbgmsg("CAB: Compression method: QUANTUM\n"); |
||||
file->state->stream = (struct qtm_stream *) qtm_init(fd, ofd, (int) (file->folder->cmethod >> 8) & 0x1f, 4096, file, &cab_read); |
||||
if(file->offset) { |
||||
((struct qtm_stream *) file->state->stream)->wflag = 0; |
||||
qtm_decompress(file->state->stream, file->offset); |
||||
((struct qtm_stream *) file->state->stream)->wflag = 1; |
||||
} |
||||
ret = qtm_decompress(file->state->stream, file->length); |
||||
qtm_free(file->state->stream); |
||||
break; |
||||
|
||||
case 0x0003: /* LZX */ |
||||
cli_dbgmsg("CAB: Compression method: LZX\n"); |
||||
file->state->stream = (struct lzx_stream *) lzx_init(fd, ofd, (int) (file->folder->cmethod >> 8) & 0x1f, 0, 4096, 0, file, &cab_read); |
||||
if(file->offset) { |
||||
((struct lzx_stream *) file->state->stream)->wflag = 0; |
||||
lzx_decompress(file->state->stream, file->offset); |
||||
((struct lzx_stream *) file->state->stream)->wflag = 1; |
||||
} |
||||
ret = lzx_decompress(file->state->stream, file->length); |
||||
lzx_free(file->state->stream); |
||||
break; |
||||
|
||||
default: |
||||
cli_warnmsg("CAB: Not supported compression method: 0x%x\n", file->folder->cmethod & 0x000f); |
||||
ret = CL_EFORMAT; |
||||
} |
||||
|
||||
free(file->state); |
||||
close(ofd); |
||||
|
||||
return ret; |
||||
} |
||||
@ -0,0 +1,73 @@ |
||||
/*
|
||||
* Copyright (C) 2006 Tomasz Kojm <tkojm@clamav.net> |
||||
* |
||||
* This program is free software; you can redistribute it and/or modify |
||||
* it under the terms of the GNU General Public License version 2 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 General Public License for more details. |
||||
* |
||||
* You should have received a copy of the GNU General Public License |
||||
* along with this program; if not, write to the Free Software |
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, |
||||
* MA 02110-1301, USA. |
||||
*/ |
||||
|
||||
#ifndef __CAB_H |
||||
#define __CAB_H |
||||
|
||||
#include <sys/types.h> |
||||
#include "cltypes.h" |
||||
|
||||
#define CAB_BLOCKMAX 32768 |
||||
#define CAB_INPUTMAX (CAB_BLOCKMAX + 6144) |
||||
|
||||
struct cab_archive { |
||||
uint32_t length; |
||||
uint16_t nfolders; |
||||
uint16_t nfiles; |
||||
uint16_t flags; |
||||
uint16_t reshdr; |
||||
uint8_t resdata; |
||||
struct cab_folder *folders; |
||||
struct cab_file *files; |
||||
}; |
||||
|
||||
struct cab_state { |
||||
unsigned char *pt, *end; |
||||
unsigned char block[CAB_INPUTMAX]; |
||||
uint16_t blklen; |
||||
uint16_t outlen; |
||||
void *stream; |
||||
uint16_t blknum; |
||||
}; |
||||
|
||||
struct cab_file { |
||||
uint32_t length; |
||||
uint16_t attribs; |
||||
off_t offset; |
||||
char *name; |
||||
int error; |
||||
int fd; |
||||
struct cab_folder *folder; |
||||
struct cab_file *next; |
||||
struct cab_archive *cab; |
||||
struct cab_state *state; |
||||
}; |
||||
|
||||
struct cab_folder { |
||||
uint16_t cmethod; |
||||
uint16_t nblocks; |
||||
struct cab_archive *cab; |
||||
off_t offset; |
||||
struct cab_folder *next; |
||||
}; |
||||
|
||||
int cab_open(int fd, off_t offset, struct cab_archive *cab); |
||||
int cab_extract(int fd, struct cab_file *file, const char *name); |
||||
void cab_free(struct cab_archive *cab); |
||||
|
||||
#endif |
||||
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,292 @@ |
||||
/*
|
||||
* This file includes code from libmspack adapted for libclamav by |
||||
* tkojm@clamav.net |
||||
* |
||||
* Copyright (C) 2003-2004 Stuart Caie |
||||
* |
||||
* This library 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 library 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 for more details. |
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public |
||||
* License along with this library; if not, write to the Free Software |
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 |
||||
* USA |
||||
*/ |
||||
|
||||
#ifndef __MSPACK_H |
||||
#define __MSPACK_H |
||||
|
||||
#include <sys/types.h> |
||||
#include "cab.h" |
||||
|
||||
|
||||
/***************************************************************************
|
||||
* MS-ZIP decompression definitions * |
||||
***************************************************************************/ |
||||
|
||||
#define MSZIP_FRAME_SIZE (32768) /* size of LZ history window */ |
||||
#define MSZIP_MAX_HUFFBITS (16) /* maximum huffman code length */ |
||||
#define MSZIP_LITERAL_MAXSYMBOLS (288) /* literal/length huffman tree */ |
||||
#define MSZIP_LITERAL_TABLEBITS (9) |
||||
#define MSZIP_DISTANCE_MAXSYMBOLS (32) /* distance huffman tree */ |
||||
#define MSZIP_DISTANCE_TABLEBITS (6) |
||||
|
||||
/* if there are less direct lookup entries than symbols, the longer
|
||||
* code pointers will be <= maxsymbols. This must not happen, or we |
||||
* will decode entries badly */ |
||||
#if (1 << MSZIP_LITERAL_TABLEBITS) < (MSZIP_LITERAL_MAXSYMBOLS * 2) |
||||
# define MSZIP_LITERAL_TABLESIZE (MSZIP_LITERAL_MAXSYMBOLS * 4) |
||||
#else |
||||
# define MSZIP_LITERAL_TABLESIZE ((1 << MSZIP_LITERAL_TABLEBITS) + \ |
||||
(MSZIP_LITERAL_MAXSYMBOLS * 2)) |
||||
#endif |
||||
|
||||
#if (1 << MSZIP_DISTANCE_TABLEBITS) < (MSZIP_DISTANCE_MAXSYMBOLS * 2) |
||||
# define MSZIP_DISTANCE_TABLESIZE (MSZIP_DISTANCE_MAXSYMBOLS * 4) |
||||
#else |
||||
# define MSZIP_DISTANCE_TABLESIZE ((1 << MSZIP_DISTANCE_TABLEBITS) + \ |
||||
(MSZIP_DISTANCE_MAXSYMBOLS * 2)) |
||||
#endif |
||||
|
||||
struct mszip_stream { |
||||
int fd; /* input file descriptor */ |
||||
int ofd; /* output file descriptor */ |
||||
unsigned char wflag; /* write flag */ |
||||
|
||||
unsigned int window_posn; /* offset within window */ |
||||
|
||||
/* inflate() will call this whenever the window should be emptied. */ |
||||
int (*flush_window)(struct mszip_stream *, unsigned int); |
||||
|
||||
int error, repair_mode, bytes_output, input_end; |
||||
|
||||
/* I/O buffering */ |
||||
unsigned char *inbuf, *i_ptr, *i_end, *o_ptr, *o_end; |
||||
unsigned int bit_buffer, bits_left, inbuf_size; |
||||
|
||||
/* huffman code lengths */ |
||||
unsigned char LITERAL_len[MSZIP_LITERAL_MAXSYMBOLS]; |
||||
unsigned char DISTANCE_len[MSZIP_DISTANCE_MAXSYMBOLS]; |
||||
|
||||
/* huffman decoding tables */ |
||||
unsigned short LITERAL_table [MSZIP_LITERAL_TABLESIZE]; |
||||
unsigned short DISTANCE_table[MSZIP_DISTANCE_TABLESIZE]; |
||||
|
||||
/* 32kb history window */ |
||||
unsigned char window[MSZIP_FRAME_SIZE]; |
||||
|
||||
/* cabinet related stuff */ |
||||
struct cab_file *file; |
||||
int (*read)(struct cab_file *, unsigned char *, int); |
||||
}; |
||||
|
||||
struct mszip_stream *mszip_init(int fd, |
||||
int ofd, |
||||
int input_buffer_size, |
||||
int repair_mode, |
||||
struct cab_file *file, |
||||
int (*read)(struct cab_file *, unsigned char *, int)); |
||||
|
||||
extern int mszip_decompress(struct mszip_stream *zip, off_t out_bytes); |
||||
|
||||
void mszip_free(struct mszip_stream *zip); |
||||
|
||||
|
||||
/***************************************************************************
|
||||
* Quantum decompression definitions * |
||||
***************************************************************************/ |
||||
|
||||
/* Quantum compression / decompression definitions */ |
||||
|
||||
#define QTM_FRAME_SIZE (32768) |
||||
|
||||
struct qtm_modelsym { |
||||
unsigned short sym, cumfreq; |
||||
}; |
||||
|
||||
struct qtm_model { |
||||
int shiftsleft, entries; |
||||
struct qtm_modelsym *syms; |
||||
}; |
||||
|
||||
struct qtm_stream { |
||||
int fd; /* input file descriptor */ |
||||
int ofd; /* output file descriptor */ |
||||
unsigned char wflag; /* write flag */ |
||||
|
||||
unsigned char *window; /* decoding window */ |
||||
unsigned int window_size; /* window size */ |
||||
unsigned int window_posn; /* decompression offset within window */ |
||||
unsigned int frame_start; /* start of current frame within window */ |
||||
|
||||
unsigned short H, L, C; /* high/low/current: arith coding state */ |
||||
unsigned char header_read; /* have we started decoding a new frame? */ |
||||
|
||||
int error; |
||||
|
||||
/* I/O buffers */ |
||||
unsigned char *inbuf, *i_ptr, *i_end, *o_ptr, *o_end; |
||||
unsigned int bit_buffer, inbuf_size; |
||||
unsigned char bits_left; |
||||
|
||||
/* data tables */ |
||||
unsigned int position_base[42]; |
||||
unsigned char extra_bits[42], length_base[27], length_extra[27]; |
||||
|
||||
/* four literal models, each representing 64 symbols
|
||||
* model0 for literals from 0 to 63 (selector = 0) |
||||
* model1 for literals from 64 to 127 (selector = 1) |
||||
* model2 for literals from 128 to 191 (selector = 2) |
||||
* model3 for literals from 129 to 255 (selector = 3) */ |
||||
struct qtm_model model0, model1, model2, model3; |
||||
|
||||
/* three match models.
|
||||
* model4 for match with fixed length of 3 bytes |
||||
* model5 for match with fixed length of 4 bytes |
||||
* model6 for variable length match, encoded with model6len model */ |
||||
struct qtm_model model4, model5, model6, model6len; |
||||
|
||||
/* selector model. 0-6 to say literal (0,1,2,3) or match (4,5,6) */ |
||||
struct qtm_model model7; |
||||
|
||||
/* symbol arrays for all models */ |
||||
struct qtm_modelsym m0sym[64 + 1]; |
||||
struct qtm_modelsym m1sym[64 + 1]; |
||||
struct qtm_modelsym m2sym[64 + 1]; |
||||
struct qtm_modelsym m3sym[64 + 1]; |
||||
struct qtm_modelsym m4sym[24 + 1]; |
||||
struct qtm_modelsym m5sym[36 + 1]; |
||||
struct qtm_modelsym m6sym[42 + 1], m6lsym[27 + 1]; |
||||
struct qtm_modelsym m7sym[7 + 1]; |
||||
|
||||
/* cabinet related stuff */ |
||||
struct cab_file *file; |
||||
int (*read)(struct cab_file *, unsigned char *, int); |
||||
|
||||
}; |
||||
|
||||
extern struct qtm_stream *qtm_init(int fd, |
||||
int ofd, |
||||
int window_bits, |
||||
int input_buffer_size, |
||||
struct cab_file *file, |
||||
int (*read)(struct cab_file *, unsigned char *, int)); |
||||
|
||||
extern int qtm_decompress(struct qtm_stream *qtm, off_t out_bytes); |
||||
|
||||
void qtm_free(struct qtm_stream *qtm); |
||||
|
||||
/***************************************************************************
|
||||
* LZX decompression definitions * |
||||
***************************************************************************/ |
||||
|
||||
/* some constants defined by the LZX specification */ |
||||
#define LZX_MIN_MATCH (2) |
||||
#define LZX_MAX_MATCH (257) |
||||
#define LZX_NUM_CHARS (256) |
||||
#define LZX_BLOCKTYPE_INVALID (0) /* also blocktypes 4-7 invalid */ |
||||
#define LZX_BLOCKTYPE_VERBATIM (1) |
||||
#define LZX_BLOCKTYPE_ALIGNED (2) |
||||
#define LZX_BLOCKTYPE_UNCOMPRESSED (3) |
||||
#define LZX_PRETREE_NUM_ELEMENTS (20) |
||||
#define LZX_ALIGNED_NUM_ELEMENTS (8) /* aligned offset tree #elements */ |
||||
#define LZX_NUM_PRIMARY_LENGTHS (7) /* this one missing from spec! */ |
||||
#define LZX_NUM_SECONDARY_LENGTHS (249) /* length tree #elements */ |
||||
|
||||
/* LZX huffman defines: tweak tablebits as desired */ |
||||
#define LZX_PRETREE_MAXSYMBOLS (LZX_PRETREE_NUM_ELEMENTS) |
||||
#define LZX_PRETREE_TABLEBITS (6) |
||||
#define LZX_MAINTREE_MAXSYMBOLS (LZX_NUM_CHARS + 50*8) |
||||
#define LZX_MAINTREE_TABLEBITS (12) |
||||
#define LZX_LENGTH_MAXSYMBOLS (LZX_NUM_SECONDARY_LENGTHS+1) |
||||
#define LZX_LENGTH_TABLEBITS (12) |
||||
#define LZX_ALIGNED_MAXSYMBOLS (LZX_ALIGNED_NUM_ELEMENTS) |
||||
#define LZX_ALIGNED_TABLEBITS (7) |
||||
#define LZX_LENTABLE_SAFETY (64) /* table decoding overruns are allowed */ |
||||
|
||||
#define LZX_FRAME_SIZE (32768) /* the size of a frame in LZX */ |
||||
|
||||
struct lzx_stream { |
||||
int fd; /* input file descriptor */ |
||||
int ofd; /* output file descriptor */ |
||||
unsigned char wflag; /* write flag */ |
||||
|
||||
off_t offset; /* number of bytes actually output */ |
||||
off_t length; /* overall decompressed length of stream */ |
||||
|
||||
unsigned char *window; /* decoding window */ |
||||
unsigned int window_size; /* window size */ |
||||
unsigned int window_posn; /* decompression offset within window */ |
||||
unsigned int frame_posn; /* current frame offset within in window */ |
||||
unsigned int frame; /* the number of 32kb frames processed */ |
||||
unsigned int reset_interval; /* which frame do we reset the compressor? */ |
||||
|
||||
unsigned int R0, R1, R2; /* for the LRU offset system */ |
||||
unsigned int block_length; /* uncompressed length of this LZX block */ |
||||
unsigned int block_remaining; /* uncompressed bytes still left to decode */ |
||||
|
||||
signed int intel_filesize; /* magic header value used for transform */ |
||||
signed int intel_curpos; /* current offset in transform space */ |
||||
|
||||
unsigned char intel_started; /* has intel E8 decoding started? */ |
||||
unsigned char block_type; /* type of the current block */ |
||||
unsigned char header_read; /* have we started decoding at all yet? */ |
||||
unsigned char posn_slots; /* how many posn slots in stream? */ |
||||
unsigned char input_end; /* have we reached the end of input? */ |
||||
|
||||
int error; |
||||
|
||||
/* I/O buffering */ |
||||
unsigned char *inbuf, *i_ptr, *i_end, *o_ptr, *o_end; |
||||
unsigned int bit_buffer, bits_left, inbuf_size; |
||||
|
||||
/* huffman code lengths */ |
||||
unsigned char PRETREE_len [LZX_PRETREE_MAXSYMBOLS + LZX_LENTABLE_SAFETY]; |
||||
unsigned char MAINTREE_len [LZX_MAINTREE_MAXSYMBOLS + LZX_LENTABLE_SAFETY]; |
||||
unsigned char LENGTH_len [LZX_LENGTH_MAXSYMBOLS + LZX_LENTABLE_SAFETY]; |
||||
unsigned char ALIGNED_len [LZX_ALIGNED_MAXSYMBOLS + LZX_LENTABLE_SAFETY]; |
||||
|
||||
/* huffman decoding tables */ |
||||
unsigned short PRETREE_table [(1 << LZX_PRETREE_TABLEBITS) + |
||||
(LZX_PRETREE_MAXSYMBOLS * 2)]; |
||||
unsigned short MAINTREE_table[(1 << LZX_MAINTREE_TABLEBITS) + |
||||
(LZX_MAINTREE_MAXSYMBOLS * 2)]; |
||||
unsigned short LENGTH_table [(1 << LZX_LENGTH_TABLEBITS) + |
||||
(LZX_LENGTH_MAXSYMBOLS * 2)]; |
||||
unsigned short ALIGNED_table [(1 << LZX_ALIGNED_TABLEBITS) + |
||||
(LZX_ALIGNED_MAXSYMBOLS * 2)]; |
||||
|
||||
unsigned int position_base[51]; |
||||
unsigned char extra_bits[51]; |
||||
|
||||
/* this is used purely for doing the intel E8 transform */ |
||||
unsigned char e8_buf[LZX_FRAME_SIZE]; |
||||
|
||||
/* cabinet related stuff */ |
||||
struct cab_file *file; |
||||
int (*read)(struct cab_file *, unsigned char *, int); |
||||
}; |
||||
|
||||
struct lzx_stream *lzx_init(int fd, |
||||
int ofd, |
||||
int window_bits, |
||||
int reset_interval, |
||||
int input_buffer_size, |
||||
off_t output_length, |
||||
struct cab_file *file, |
||||
int (*read)(struct cab_file *, unsigned char *, int)); |
||||
|
||||
extern void lzx_set_output_length(struct lzx_stream *lzx, |
||||
off_t output_length); |
||||
|
||||
extern int lzx_decompress(struct lzx_stream *lzx, off_t out_bytes); |
||||
|
||||
void lzx_free(struct lzx_stream *lzx); |
||||
|
||||
#endif |
||||
@ -1,127 +0,0 @@ |
||||
/* This file is part of libmspack.
|
||||
* (C) 2003-2004 Stuart Caie. |
||||
* |
||||
* libmspack is free software; you can redistribute it and/or modify it under |
||||
* the terms of the GNU Lesser General Public License (LGPL) version 2.1 |
||||
* |
||||
* For further details, see the file COPYING.LIB distributed with libmspack |
||||
*/ |
||||
|
||||
#ifndef MSPACK_CAB_H |
||||
#define MSPACK_CAB_H 1 |
||||
|
||||
#include <mszip.h> |
||||
#include <qtm.h> |
||||
#include <lzx.h> |
||||
|
||||
/* generic CAB definitions */ |
||||
|
||||
/* structure offsets */ |
||||
#define cfhead_Signature (0x00) |
||||
#define cfhead_CabinetSize (0x08) |
||||
#define cfhead_FileOffset (0x10) |
||||
#define cfhead_MinorVersion (0x18) |
||||
#define cfhead_MajorVersion (0x19) |
||||
#define cfhead_NumFolders (0x1A) |
||||
#define cfhead_NumFiles (0x1C) |
||||
#define cfhead_Flags (0x1E) |
||||
#define cfhead_SetID (0x20) |
||||
#define cfhead_CabinetIndex (0x22) |
||||
#define cfhead_SIZEOF (0x24) |
||||
#define cfheadext_HeaderReserved (0x00) |
||||
#define cfheadext_FolderReserved (0x02) |
||||
#define cfheadext_DataReserved (0x03) |
||||
#define cfheadext_SIZEOF (0x04) |
||||
#define cffold_DataOffset (0x00) |
||||
#define cffold_NumBlocks (0x04) |
||||
#define cffold_CompType (0x06) |
||||
#define cffold_SIZEOF (0x08) |
||||
#define cffile_UncompressedSize (0x00) |
||||
#define cffile_FolderOffset (0x04) |
||||
#define cffile_FolderIndex (0x08) |
||||
#define cffile_Date (0x0A) |
||||
#define cffile_Time (0x0C) |
||||
#define cffile_Attribs (0x0E) |
||||
#define cffile_SIZEOF (0x10) |
||||
#define cfdata_CheckSum (0x00) |
||||
#define cfdata_CompressedSize (0x04) |
||||
#define cfdata_UncompressedSize (0x06) |
||||
#define cfdata_SIZEOF (0x08) |
||||
|
||||
/* flags */ |
||||
#define cffoldCOMPTYPE_MASK (0x000f) |
||||
#define cffoldCOMPTYPE_NONE (0x0000) |
||||
#define cffoldCOMPTYPE_MSZIP (0x0001) |
||||
#define cffoldCOMPTYPE_QUANTUM (0x0002) |
||||
#define cffoldCOMPTYPE_LZX (0x0003) |
||||
#define cfheadPREV_CABINET (0x0001) |
||||
#define cfheadNEXT_CABINET (0x0002) |
||||
#define cfheadRESERVE_PRESENT (0x0004) |
||||
#define cffileCONTINUED_FROM_PREV (0xFFFD) |
||||
#define cffileCONTINUED_TO_NEXT (0xFFFE) |
||||
#define cffileCONTINUED_PREV_AND_NEXT (0xFFFF) |
||||
|
||||
/* CAB data blocks are <= 32768 bytes in uncompressed form. Uncompressed
|
||||
* blocks have zero growth. MSZIP guarantees that it won't grow above |
||||
* uncompressed size by more than 12 bytes. LZX guarantees it won't grow |
||||
* more than 6144 bytes. Quantum has no documentation, but the largest |
||||
* block seen in the wild is 337 bytes above uncompressed size. |
||||
*/ |
||||
#define CAB_BLOCKMAX (32768) |
||||
#define CAB_INPUTMAX (CAB_BLOCKMAX+6144) |
||||
|
||||
/* CAB compression definitions */ |
||||
|
||||
struct mscab_compressor_p { |
||||
struct mscab_compressor base; |
||||
struct mspack_system *system; |
||||
/* todo */ |
||||
}; |
||||
|
||||
/* CAB decompression definitions */ |
||||
|
||||
struct mscabd_decompress_state { |
||||
struct mscabd_folder_p *folder; /* current folder we're extracting from */ |
||||
struct mscabd_folder_data *data; /* current folder split we're in */ |
||||
unsigned int offset; /* uncompressed offset within folder */ |
||||
unsigned int block; /* which block are we decompressing? */ |
||||
struct mspack_system sys; /* special I/O code for decompressor */ |
||||
int comp_type; /* type of compression used by folder */ |
||||
int (*decompress)(void *, off_t); /* decompressor code */ |
||||
void *state; /* decompressor state */ |
||||
struct mscabd_cabinet_p *incab; /* cabinet where input data comes from */ |
||||
struct mspack_file *infh; /* input file handle */ |
||||
struct mspack_file *outfh; /* output file handle */ |
||||
unsigned char *i_ptr, *i_end; /* input data consumed, end */ |
||||
unsigned char input[CAB_INPUTMAX]; /* one input block of data */ |
||||
}; |
||||
|
||||
struct mscab_decompressor_p { |
||||
struct mscab_decompressor base; |
||||
struct mscabd_decompress_state *d; |
||||
struct mspack_system *system; |
||||
int param[3]; /* !!! MATCH THIS TO NUM OF PARAMS IN MSPACK.H !!! */ |
||||
int error; |
||||
}; |
||||
|
||||
struct mscabd_cabinet_p { |
||||
struct mscabd_cabinet base; |
||||
off_t blocks_off; /* offset to data blocks */ |
||||
int block_resv; /* reserved space in data blocks */ |
||||
}; |
||||
|
||||
/* there is one of these for every cabinet a folder spans */ |
||||
struct mscabd_folder_data { |
||||
struct mscabd_folder_data *next; |
||||
struct mscabd_cabinet_p *cab; /* cabinet file of this folder span */ |
||||
off_t offset; /* cabinet offset of first datablock */ |
||||
}; |
||||
|
||||
struct mscabd_folder_p { |
||||
struct mscabd_folder base; |
||||
struct mscabd_folder_data data; /* where are the data blocks? */ |
||||
struct mscabd_file *merge_prev; /* do we need to merge backwards? */ |
||||
struct mscabd_file *merge_next; /* do we need to merge forwards? */ |
||||
}; |
||||
|
||||
#endif |
||||
File diff suppressed because it is too large
Load Diff
@ -1,167 +0,0 @@ |
||||
/* This file is part of libmspack.
|
||||
* (C) 2003-2004 Stuart Caie. |
||||
* |
||||
* The LZX method was created by Jonathan Forbes and Tomi Poutanen, adapted |
||||
* by Microsoft Corporation. |
||||
* |
||||
* libmspack is free software; you can redistribute it and/or modify it under |
||||
* the terms of the GNU Lesser General Public License (LGPL) version 2.1 |
||||
* |
||||
* For further details, see the file COPYING.LIB distributed with libmspack |
||||
*/ |
||||
|
||||
#ifndef MSPACK_LZX_H |
||||
#define MSPACK_LZX_H 1 |
||||
|
||||
/* LZX compression / decompression definitions */ |
||||
|
||||
/* some constants defined by the LZX specification */ |
||||
#define LZX_MIN_MATCH (2) |
||||
#define LZX_MAX_MATCH (257) |
||||
#define LZX_NUM_CHARS (256) |
||||
#define LZX_BLOCKTYPE_INVALID (0) /* also blocktypes 4-7 invalid */ |
||||
#define LZX_BLOCKTYPE_VERBATIM (1) |
||||
#define LZX_BLOCKTYPE_ALIGNED (2) |
||||
#define LZX_BLOCKTYPE_UNCOMPRESSED (3) |
||||
#define LZX_PRETREE_NUM_ELEMENTS (20) |
||||
#define LZX_ALIGNED_NUM_ELEMENTS (8) /* aligned offset tree #elements */ |
||||
#define LZX_NUM_PRIMARY_LENGTHS (7) /* this one missing from spec! */ |
||||
#define LZX_NUM_SECONDARY_LENGTHS (249) /* length tree #elements */ |
||||
|
||||
/* LZX huffman defines: tweak tablebits as desired */ |
||||
#define LZX_PRETREE_MAXSYMBOLS (LZX_PRETREE_NUM_ELEMENTS) |
||||
#define LZX_PRETREE_TABLEBITS (6) |
||||
#define LZX_MAINTREE_MAXSYMBOLS (LZX_NUM_CHARS + 50*8) |
||||
#define LZX_MAINTREE_TABLEBITS (12) |
||||
#define LZX_LENGTH_MAXSYMBOLS (LZX_NUM_SECONDARY_LENGTHS+1) |
||||
#define LZX_LENGTH_TABLEBITS (12) |
||||
#define LZX_ALIGNED_MAXSYMBOLS (LZX_ALIGNED_NUM_ELEMENTS) |
||||
#define LZX_ALIGNED_TABLEBITS (7) |
||||
#define LZX_LENTABLE_SAFETY (64) /* table decoding overruns are allowed */ |
||||
|
||||
#define LZX_FRAME_SIZE (32768) /* the size of a frame in LZX */ |
||||
|
||||
struct lzxd_stream { |
||||
struct mspack_system *sys; /* I/O routines */ |
||||
struct mspack_file *input; /* input file handle */ |
||||
struct mspack_file *output; /* output file handle */ |
||||
|
||||
off_t offset; /* number of bytes actually output */ |
||||
off_t length; /* overall decompressed length of stream */ |
||||
|
||||
unsigned char *window; /* decoding window */ |
||||
unsigned int window_size; /* window size */ |
||||
unsigned int window_posn; /* decompression offset within window */ |
||||
unsigned int frame_posn; /* current frame offset within in window */ |
||||
unsigned int frame; /* the number of 32kb frames processed */ |
||||
unsigned int reset_interval; /* which frame do we reset the compressor? */ |
||||
|
||||
unsigned int R0, R1, R2; /* for the LRU offset system */ |
||||
unsigned int block_length; /* uncompressed length of this LZX block */ |
||||
unsigned int block_remaining; /* uncompressed bytes still left to decode */ |
||||
|
||||
signed int intel_filesize; /* magic header value used for transform */ |
||||
signed int intel_curpos; /* current offset in transform space */ |
||||
|
||||
unsigned char intel_started; /* has intel E8 decoding started? */ |
||||
unsigned char block_type; /* type of the current block */ |
||||
unsigned char header_read; /* have we started decoding at all yet? */ |
||||
unsigned char posn_slots; /* how many posn slots in stream? */ |
||||
unsigned char input_end; /* have we reached the end of input? */ |
||||
|
||||
int error; |
||||
|
||||
/* I/O buffering */ |
||||
unsigned char *inbuf, *i_ptr, *i_end, *o_ptr, *o_end; |
||||
unsigned int bit_buffer, bits_left, inbuf_size; |
||||
|
||||
/* huffman code lengths */ |
||||
unsigned char PRETREE_len [LZX_PRETREE_MAXSYMBOLS + LZX_LENTABLE_SAFETY]; |
||||
unsigned char MAINTREE_len [LZX_MAINTREE_MAXSYMBOLS + LZX_LENTABLE_SAFETY]; |
||||
unsigned char LENGTH_len [LZX_LENGTH_MAXSYMBOLS + LZX_LENTABLE_SAFETY]; |
||||
unsigned char ALIGNED_len [LZX_ALIGNED_MAXSYMBOLS + LZX_LENTABLE_SAFETY]; |
||||
|
||||
/* huffman decoding tables */ |
||||
unsigned short PRETREE_table [(1 << LZX_PRETREE_TABLEBITS) + |
||||
(LZX_PRETREE_MAXSYMBOLS * 2)]; |
||||
unsigned short MAINTREE_table[(1 << LZX_MAINTREE_TABLEBITS) + |
||||
(LZX_MAINTREE_MAXSYMBOLS * 2)]; |
||||
unsigned short LENGTH_table [(1 << LZX_LENGTH_TABLEBITS) + |
||||
(LZX_LENGTH_MAXSYMBOLS * 2)]; |
||||
unsigned short ALIGNED_table [(1 << LZX_ALIGNED_TABLEBITS) + |
||||
(LZX_ALIGNED_MAXSYMBOLS * 2)]; |
||||
|
||||
/* this is used purely for doing the intel E8 transform */ |
||||
unsigned char e8_buf[LZX_FRAME_SIZE]; |
||||
}; |
||||
|
||||
/* allocates LZX decompression state for decoding the given stream.
|
||||
* |
||||
* - returns NULL if window_bits is outwith the range 15 to 21 (inclusive). |
||||
* |
||||
* - uses system->alloc() to allocate memory |
||||
* |
||||
* - returns NULL if not enough memory |
||||
* |
||||
* - window_bits is the size of the LZX window, from 32Kb (15) to 2Mb (21). |
||||
* |
||||
* - reset_interval is how often the bitstream is reset, measured in |
||||
* multiples of 32Kb bytes output. For CAB LZX streams, this is always 0 |
||||
* (does not occur). |
||||
* |
||||
* - input_buffer_size is how many bytes to use as an input bitstream buffer |
||||
* |
||||
* - output_length is the length in bytes of the entirely decompressed |
||||
* output stream, if known in advance. It is used to correctly perform |
||||
* the Intel E8 transformation, which must stop 6 bytes before the very |
||||
* end of the decompressed stream. It is not otherwise used or adhered |
||||
* to. If the full decompressed length is known in advance, set it here. |
||||
* If it is NOT known, use the value 0, and call lzxd_set_output_length() |
||||
* once it is known. If never set, 4 of the final 6 bytes of the output |
||||
* stream may be incorrect. |
||||
*/ |
||||
extern struct lzxd_stream *lzxd_init(struct mspack_system *system, |
||||
struct mspack_file *input, |
||||
struct mspack_file *output, |
||||
int window_bits, |
||||
int reset_interval, |
||||
int input_buffer_size, |
||||
off_t output_length); |
||||
|
||||
/* see description of output_length in lzxd_init() */ |
||||
extern void lzxd_set_output_length(struct lzxd_stream *lzx, |
||||
off_t output_length); |
||||
|
||||
/* decompresses, or decompresses more of, an LZX stream.
|
||||
* |
||||
* - out_bytes of data will be decompressed and the function will return |
||||
* with an MSPACK_ERR_OK return code. |
||||
* |
||||
* - decompressing will stop as soon as out_bytes is reached. if the true |
||||
* amount of bytes decoded spills over that amount, they will be kept for |
||||
* a later invocation of lzxd_decompress(). |
||||
* |
||||
* - the output bytes will be passed to the system->write() function given in |
||||
* lzxd_init(), using the output file handle given in lzxd_init(). More |
||||
* than one call may be made to system->write(). |
||||
* |
||||
* - LZX will read input bytes as necessary using the system->read() function |
||||
* given in lzxd_init(), using the input file handle given in lzxd_init(). |
||||
* This will continue until system->read() returns 0 bytes, or an error. |
||||
* input streams should convey an "end of input stream" by refusing to |
||||
* supply all the bytes that LZX asks for when they reach the end of the |
||||
* stream, rather than return an error code. |
||||
* |
||||
* - if an error code other than MSPACK_ERR_OK is returned, the stream should |
||||
* be considered unusable and lzxd_decompress() should not be called again |
||||
* on this stream. |
||||
*/ |
||||
extern int lzxd_decompress(struct lzxd_stream *lzx, off_t out_bytes); |
||||
|
||||
/* frees all state associated with an LZX data stream
|
||||
* |
||||
* - calls system->free() using the system pointer given in lzxd_init() |
||||
*/ |
||||
void lzxd_free(struct lzxd_stream *lzx); |
||||
|
||||
#endif |
||||
@ -1,904 +0,0 @@ |
||||
/* This file is part of libmspack.
|
||||
* (C) 2003-2004 Stuart Caie. |
||||
* |
||||
* The LZX method was created by Jonathan Forbes and Tomi Poutanen, adapted |
||||
* by Microsoft Corporation. |
||||
* |
||||
* libmspack is free software; you can redistribute it and/or modify it under |
||||
* the terms of the GNU Lesser General Public License (LGPL) version 2.1 |
||||
* |
||||
* For further details, see the file COPYING.LIB distributed with libmspack |
||||
*/ |
||||
|
||||
/* LZX decompression implementation */ |
||||
|
||||
#if HAVE_CONFIG_H |
||||
#include "clamav-config.h" |
||||
#endif |
||||
|
||||
#include <mspack.h> |
||||
#include <system.h> |
||||
#include <lzx.h> |
||||
|
||||
#include "others.h" |
||||
|
||||
/* Microsoft's LZX document and their implementation of the
|
||||
* com.ms.util.cab Java package do not concur. |
||||
* |
||||
* In the LZX document, there is a table showing the correlation between |
||||
* window size and the number of position slots. It states that the 1MB |
||||
* window = 40 slots and the 2MB window = 42 slots. In the implementation, |
||||
* 1MB = 42 slots, 2MB = 50 slots. The actual calculation is 'find the |
||||
* first slot whose position base is equal to or more than the required |
||||
* window size'. This would explain why other tables in the document refer |
||||
* to 50 slots rather than 42. |
||||
* |
||||
* The constant NUM_PRIMARY_LENGTHS used in the decompression pseudocode |
||||
* is not defined in the specification. |
||||
* |
||||
* The LZX document does not state the uncompressed block has an |
||||
* uncompressed length field. Where does this length field come from, so |
||||
* we can know how large the block is? The implementation has it as the 24 |
||||
* bits following after the 3 blocktype bits, before the alignment |
||||
* padding. |
||||
* |
||||
* The LZX document states that aligned offset blocks have their aligned |
||||
* offset huffman tree AFTER the main and length trees. The implementation |
||||
* suggests that the aligned offset tree is BEFORE the main and length |
||||
* trees. |
||||
* |
||||
* The LZX document decoding algorithm states that, in an aligned offset |
||||
* block, if an extra_bits value is 1, 2 or 3, then that number of bits |
||||
* should be read and the result added to the match offset. This is |
||||
* correct for 1 and 2, but not 3, where just a huffman symbol (using the |
||||
* aligned tree) should be read. |
||||
* |
||||
* Regarding the E8 preprocessing, the LZX document states 'No translation |
||||
* may be performed on the last 6 bytes of the input block'. This is |
||||
* correct. However, the pseudocode provided checks for the *E8 leader* |
||||
* up to the last 6 bytes. If the leader appears between -10 and -7 bytes |
||||
* from the end, this would cause the next four bytes to be modified, at |
||||
* least one of which would be in the last 6 bytes, which is not allowed |
||||
* according to the spec. |
||||
* |
||||
* The specification states that the huffman trees must always contain at |
||||
* least one element. However, many CAB files contain blocks where the |
||||
* length tree is completely empty (because there are no matches), and |
||||
* this is expected to succeed. |
||||
*/ |
||||
|
||||
|
||||
/* LZX decompressor input macros
|
||||
* |
||||
* STORE_BITS stores bitstream state in lzxd_stream structure |
||||
* RESTORE_BITS restores bitstream state from lzxd_stream structure |
||||
* READ_BITS(var,n) takes N bits from the buffer and puts them in var |
||||
* ENSURE_BITS(n) ensures there are at least N bits in the bit buffer. |
||||
* PEEK_BITS(n) extracts without removing N bits from the bit buffer |
||||
* REMOVE_BITS(n) removes N bits from the bit buffer |
||||
* |
||||
* These bit access routines work by using the area beyond the MSB and the |
||||
* LSB as a free source of zeroes when shifting. This avoids having to |
||||
* mask any bits. So we have to know the bit width of the bit buffer |
||||
* variable. |
||||
* |
||||
* The bit buffer datatype should be at least 32 bits wide: it must be |
||||
* possible to ENSURE_BITS(16), so it must be possible to add 16 new bits |
||||
* to the bit buffer when the bit buffer already has 1 to 15 bits left. |
||||
*/ |
||||
|
||||
#if HAVE_LIMITS_H |
||||
# include <limits.h> |
||||
#endif |
||||
#ifndef CHAR_BIT |
||||
# define CHAR_BIT (8) |
||||
#endif |
||||
#define BITBUF_WIDTH (sizeof(bit_buffer) * CHAR_BIT) |
||||
|
||||
#define STORE_BITS do { \ |
||||
lzx->i_ptr = i_ptr; \
|
||||
lzx->i_end = i_end; \
|
||||
lzx->bit_buffer = bit_buffer; \
|
||||
lzx->bits_left = bits_left; \
|
||||
} while (0) |
||||
|
||||
#define RESTORE_BITS do { \ |
||||
i_ptr = lzx->i_ptr; \
|
||||
i_end = lzx->i_end; \
|
||||
bit_buffer = lzx->bit_buffer; \
|
||||
bits_left = lzx->bits_left; \
|
||||
} while (0) |
||||
|
||||
#define ENSURE_BITS(nbits) \ |
||||
while (bits_left < (nbits)) { \
|
||||
if (i_ptr >= i_end) { \
|
||||
if (lzxd_read_input(lzx)) return lzx->error; \
|
||||
i_ptr = lzx->i_ptr; \
|
||||
i_end = lzx->i_end; \
|
||||
} \
|
||||
bit_buffer |= ((i_ptr[1] << 8) | i_ptr[0]) \
|
||||
<< (BITBUF_WIDTH - 16 - bits_left); \
|
||||
bits_left += 16; \
|
||||
i_ptr += 2; \
|
||||
} |
||||
|
||||
#define PEEK_BITS(nbits) (bit_buffer >> (BITBUF_WIDTH - (nbits))) |
||||
|
||||
#define REMOVE_BITS(nbits) ((bit_buffer <<= (nbits)), (bits_left -= (nbits))) |
||||
|
||||
#define READ_BITS(val, nbits) do { \ |
||||
ENSURE_BITS(nbits); \
|
||||
(val) = PEEK_BITS(nbits); \
|
||||
REMOVE_BITS(nbits); \
|
||||
} while (0) |
||||
|
||||
static int lzxd_read_input(struct lzxd_stream *lzx) { |
||||
int read = lzx->sys->read(lzx->input, &lzx->inbuf[0], (int)lzx->inbuf_size); |
||||
if (read < 0) return lzx->error = MSPACK_ERR_READ; |
||||
|
||||
/* huff decode's ENSURE_BYTES(16) might overrun the input stream, even
|
||||
* if those bits aren't used, so fake 2 more bytes */ |
||||
if (read == 0) { |
||||
if (lzx->input_end) { |
||||
D(("out of input bytes")) |
||||
return lzx->error = MSPACK_ERR_READ; |
||||
} |
||||
else { |
||||
read = 2; |
||||
lzx->inbuf[0] = lzx->inbuf[1] = 0; |
||||
lzx->input_end = 1; |
||||
} |
||||
} |
||||
|
||||
lzx->i_ptr = &lzx->inbuf[0]; |
||||
lzx->i_end = &lzx->inbuf[read]; |
||||
|
||||
return MSPACK_ERR_OK; |
||||
} |
||||
|
||||
/* Huffman decoding macros */ |
||||
|
||||
/* READ_HUFFSYM(tablename, var) decodes one huffman symbol from the
|
||||
* bitstream using the stated table and puts it in var. |
||||
*/ |
||||
#define READ_HUFFSYM(tbl, var) do { \ |
||||
/* huffman symbols can be up to 16 bits long */ \
|
||||
ENSURE_BITS(16); \
|
||||
/* immediate table lookup of [tablebits] bits of the code */ \
|
||||
sym = lzx->tbl##_table[PEEK_BITS(LZX_##tbl##_TABLEBITS)]; \
|
||||
/* is the symbol is longer than [tablebits] bits? (i=node index) */ \
|
||||
if (sym >= LZX_##tbl##_MAXSYMBOLS) { \
|
||||
/* decode remaining bits by tree traversal */ \
|
||||
i = 1 << (BITBUF_WIDTH - LZX_##tbl##_TABLEBITS); \
|
||||
do { \
|
||||
/* one less bit. error if we run out of bits before decode */ \
|
||||
i >>= 1; \
|
||||
if (i == 0) { \
|
||||
D(("out of bits in huffman decode")) \
|
||||
return lzx->error = MSPACK_ERR_DECRUNCH; \
|
||||
} \
|
||||
/* double node index and add 0 (left branch) or 1 (right) */ \
|
||||
sym <<= 1; sym |= (bit_buffer & i) ? 1 : 0; \
|
||||
/* hop to next node index / decoded symbol */ \
|
||||
sym = lzx->tbl##_table[sym]; \
|
||||
/* while we are still in node indicies, not decoded symbols */ \
|
||||
} while (sym >= LZX_##tbl##_MAXSYMBOLS); \
|
||||
} \
|
||||
/* result */ \
|
||||
(var) = sym; \
|
||||
/* look up the code length of that symbol and discard those bits */ \
|
||||
i = lzx->tbl##_len[sym]; \
|
||||
REMOVE_BITS(i); \
|
||||
} while (0) |
||||
|
||||
/* BUILD_TABLE(tbl) builds a huffman lookup table from code lengths */ |
||||
#define BUILD_TABLE(tbl) \ |
||||
if (make_decode_table(LZX_##tbl##_MAXSYMBOLS, LZX_##tbl##_TABLEBITS, \
|
||||
&lzx->tbl##_len[0], &lzx->tbl##_table[0])) \
|
||||
{ \
|
||||
D(("failed to build %s table", #tbl)) \
|
||||
return lzx->error = MSPACK_ERR_DECRUNCH; \
|
||||
} |
||||
|
||||
/* make_decode_table(nsyms, nbits, length[], table[])
|
||||
* |
||||
* This function was coded by David Tritscher. It builds a fast huffman |
||||
* decoding table from a canonical huffman code lengths table. |
||||
* |
||||
* nsyms = total number of symbols in this huffman tree. |
||||
* nbits = any symbols with a code length of nbits or less can be decoded |
||||
* in one lookup of the table. |
||||
* length = A table to get code lengths from [0 to syms-1] |
||||
* table = The table to fill up with decoded symbols and pointers. |
||||
* |
||||
* Returns 0 for OK or 1 for error |
||||
*/ |
||||
|
||||
static int make_decode_table(unsigned int nsyms, unsigned int nbits, |
||||
unsigned char *length, unsigned short *table) |
||||
{ |
||||
register unsigned short sym; |
||||
register unsigned int leaf, fill; |
||||
register unsigned char bit_num; |
||||
unsigned int pos = 0; /* the current position in the decode table */ |
||||
unsigned int table_mask = 1 << nbits; |
||||
unsigned int bit_mask = table_mask >> 1; /* don't do 0 length codes */ |
||||
unsigned int next_symbol = bit_mask; /* base of allocation for long codes */ |
||||
|
||||
/* fill entries for codes short enough for a direct mapping */ |
||||
for (bit_num = 1; bit_num <= nbits; bit_num++) { |
||||
for (sym = 0; sym < nsyms; sym++) { |
||||
if (length[sym] != bit_num) continue; |
||||
leaf = pos; |
||||
if((pos += bit_mask) > table_mask) return 1; /* table overrun */ |
||||
/* fill all possible lookups of this symbol with the symbol itself */ |
||||
for (fill = bit_mask; fill-- > 0;) table[leaf++] = sym; |
||||
} |
||||
bit_mask >>= 1; |
||||
} |
||||
|
||||
/* full table already? */ |
||||
if (pos == table_mask) return 0; |
||||
|
||||
/* clear the remainder of the table */ |
||||
for (sym = pos; sym < table_mask; sym++) table[sym] = 0xFFFF; |
||||
|
||||
/* allow codes to be up to nbits+16 long, instead of nbits */ |
||||
pos <<= 16; |
||||
table_mask <<= 16; |
||||
bit_mask = 1 << 15; |
||||
|
||||
for (bit_num = nbits+1; bit_num <= 16; bit_num++) { |
||||
for (sym = 0; sym < nsyms; sym++) { |
||||
if (length[sym] != bit_num) continue; |
||||
|
||||
leaf = pos >> 16; |
||||
for (fill = 0; fill < bit_num - nbits; fill++) { |
||||
/* if this path hasn't been taken yet, 'allocate' two entries */ |
||||
if (table[leaf] == 0xFFFF) { |
||||
table[(next_symbol << 1)] = 0xFFFF; |
||||
table[(next_symbol << 1) + 1] = 0xFFFF; |
||||
table[leaf] = next_symbol++; |
||||
} |
||||
/* follow the path and select either left or right for next bit */ |
||||
leaf = table[leaf] << 1; |
||||
if ((pos >> (15-fill)) & 1) leaf++; |
||||
} |
||||
table[leaf] = sym; |
||||
|
||||
if ((pos += bit_mask) > table_mask) return 1; /* table overflow */ |
||||
} |
||||
bit_mask >>= 1; |
||||
} |
||||
|
||||
/* full table? */ |
||||
if (pos == table_mask) return 0; |
||||
|
||||
/* either erroneous table, or all elements are 0 - let's find out. */ |
||||
for (sym = 0; sym < nsyms; sym++) if (length[sym]) return 1; |
||||
return 0; |
||||
} |
||||
|
||||
|
||||
/* READ_LENGTHS(tablename, first, last) reads in code lengths for symbols
|
||||
* first to last in the given table. The code lengths are stored in their |
||||
* own special LZX way. |
||||
*/ |
||||
#define READ_LENGTHS(tbl, first, last) do { \ |
||||
STORE_BITS; \
|
||||
if (lzxd_read_lens(lzx, &lzx->tbl##_len[0], (first), \
|
||||
(unsigned int)(last))) return lzx->error; \
|
||||
RESTORE_BITS; \
|
||||
} while (0) |
||||
|
||||
static int lzxd_read_lens(struct lzxd_stream *lzx, unsigned char *lens, |
||||
unsigned int first, unsigned int last) |
||||
{ |
||||
/* bit buffer and huffman symbol decode variables */ |
||||
register unsigned int bit_buffer; |
||||
register int bits_left, i; |
||||
register unsigned short sym; |
||||
unsigned char *i_ptr, *i_end; |
||||
|
||||
unsigned int x, y; |
||||
int z; |
||||
|
||||
RESTORE_BITS; |
||||
|
||||
/* read lengths for pretree (20 symbols, lengths stored in fixed 4 bits) */ |
||||
for (x = 0; x < 20; x++) { |
||||
READ_BITS(y, 4); |
||||
lzx->PRETREE_len[x] = y; |
||||
} |
||||
BUILD_TABLE(PRETREE); |
||||
|
||||
for (x = first; x < last; ) { |
||||
READ_HUFFSYM(PRETREE, z); |
||||
if (z == 17) { |
||||
/* code = 17, run of ([read 4 bits]+4) zeros */ |
||||
READ_BITS(y, 4); y += 4; |
||||
while (y--) lens[x++] = 0; |
||||
} |
||||
else if (z == 18) { |
||||
/* code = 18, run of ([read 5 bits]+20) zeros */ |
||||
READ_BITS(y, 5); y += 20; |
||||
while (y--) lens[x++] = 0; |
||||
} |
||||
else if (z == 19) { |
||||
/* code = 19, run of ([read 1 bit]+4) [read huffman symbol] */ |
||||
READ_BITS(y, 1); y += 4; |
||||
READ_HUFFSYM(PRETREE, z); |
||||
z = lens[x] - z; if (z < 0) z += 17; |
||||
while (y--) lens[x++] = z; |
||||
} |
||||
else { |
||||
/* code = 0 to 16, delta current length entry */ |
||||
z = lens[x] - z; if (z < 0) z += 17; |
||||
lens[x++] = z; |
||||
} |
||||
} |
||||
|
||||
STORE_BITS; |
||||
|
||||
return MSPACK_ERR_OK; |
||||
} |
||||
|
||||
/* LZX static data tables:
|
||||
* |
||||
* LZX uses 'position slots' to represent match offsets. For every match, |
||||
* a small 'position slot' number and a small offset from that slot are |
||||
* encoded instead of one large offset. |
||||
* |
||||
* position_base[] is an index to the position slot bases |
||||
* |
||||
* extra_bits[] states how many bits of offset-from-base data is needed. |
||||
*/ |
||||
static unsigned int position_base[51]; |
||||
static unsigned char extra_bits[51]; |
||||
|
||||
static void lzxd_static_init(void) { |
||||
int i, j; |
||||
|
||||
for (i = 0, j = 0; i < 51; i += 2) { |
||||
extra_bits[i] = j; /* 0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7... */ |
||||
if(i < 50) |
||||
extra_bits[i+1] = j; |
||||
if ((i != 0) && (j < 17)) j++; /* 0,0,1,2,3,4...15,16,17,17,17,17... */ |
||||
} |
||||
|
||||
for (i = 0, j = 0; i < 51; i++) { |
||||
position_base[i] = j; /* 0,1,2,3,4,6,8,12,16,24,32,... */ |
||||
j += 1 << extra_bits[i]; /* 1,1,1,1,2,2,4,4,8,8,16,16,32,32,... */ |
||||
} |
||||
} |
||||
|
||||
static void lzxd_reset_state(struct lzxd_stream *lzx) { |
||||
int i; |
||||
|
||||
lzx->R0 = 1; |
||||
lzx->R1 = 1; |
||||
lzx->R2 = 1; |
||||
lzx->header_read = 0; |
||||
lzx->block_remaining = 0; |
||||
lzx->block_type = LZX_BLOCKTYPE_INVALID; |
||||
|
||||
/* initialise tables to 0 (because deltas will be applied to them) */ |
||||
for (i = 0; i < LZX_MAINTREE_MAXSYMBOLS; i++) lzx->MAINTREE_len[i] = 0; |
||||
for (i = 0; i < LZX_LENGTH_MAXSYMBOLS; i++) lzx->LENGTH_len[i] = 0; |
||||
} |
||||
|
||||
/*-------- main LZX code --------*/ |
||||
|
||||
struct lzxd_stream *lzxd_init(struct mspack_system *system, |
||||
struct mspack_file *input, |
||||
struct mspack_file *output, |
||||
int window_bits, |
||||
int reset_interval, |
||||
int input_buffer_size, |
||||
off_t output_length) |
||||
{ |
||||
unsigned int window_size = 1 << window_bits; |
||||
struct lzxd_stream *lzx; |
||||
|
||||
if (!system) return NULL; |
||||
|
||||
/* LZX supports window sizes of 2^15 (32Kb) through 2^21 (2Mb) */ |
||||
if (window_bits < 15 || window_bits > 21) return NULL; |
||||
|
||||
input_buffer_size = (input_buffer_size + 1) & -2; |
||||
if (!input_buffer_size) return NULL; |
||||
|
||||
/* initialise static data */ |
||||
lzxd_static_init(); |
||||
|
||||
/* allocate decompression state */ |
||||
if (!(lzx = system->alloc(system, sizeof(struct lzxd_stream)))) { |
||||
return NULL; |
||||
} |
||||
|
||||
/* allocate decompression window and input buffer */ |
||||
lzx->window = system->alloc(system, (size_t) window_size); |
||||
lzx->inbuf = system->alloc(system, (size_t) input_buffer_size); |
||||
if (!lzx->window || !lzx->inbuf) { |
||||
system->free(lzx->window); |
||||
system->free(lzx->inbuf); |
||||
system->free(lzx); |
||||
return NULL; |
||||
} |
||||
|
||||
/* initialise decompression state */ |
||||
lzx->sys = system; |
||||
lzx->input = input; |
||||
lzx->output = output; |
||||
lzx->offset = 0; |
||||
lzx->length = output_length; |
||||
|
||||
lzx->inbuf_size = input_buffer_size; |
||||
lzx->window_size = 1 << window_bits; |
||||
lzx->window_posn = 0; |
||||
lzx->frame_posn = 0; |
||||
lzx->frame = 0; |
||||
lzx->reset_interval = reset_interval; |
||||
lzx->intel_filesize = 0; |
||||
lzx->intel_curpos = 0; |
||||
|
||||
/* window bits: 15 16 17 18 19 20 21
|
||||
* position slots: 30 32 34 36 38 42 50 */ |
||||
lzx->posn_slots = ((window_bits == 21) ? 50 : |
||||
((window_bits == 20) ? 42 : (window_bits << 1))); |
||||
lzx->intel_started = 0; |
||||
lzx->input_end = 0; |
||||
|
||||
lzx->error = MSPACK_ERR_OK; |
||||
|
||||
lzx->i_ptr = lzx->i_end = &lzx->inbuf[0]; |
||||
lzx->o_ptr = lzx->o_end = &lzx->e8_buf[0]; |
||||
lzx->bit_buffer = lzx->bits_left = 0; |
||||
|
||||
lzxd_reset_state(lzx); |
||||
return lzx; |
||||
} |
||||
|
||||
void lzxd_set_output_length(struct lzxd_stream *lzx, off_t out_bytes) { |
||||
if (lzx) lzx->length = out_bytes; |
||||
} |
||||
|
||||
int lzxd_decompress(struct lzxd_stream *lzx, off_t out_bytes) { |
||||
/* bitstream reading and huffman variables */ |
||||
register unsigned int bit_buffer; |
||||
register int bits_left, i=0; |
||||
register unsigned short sym; |
||||
unsigned char *i_ptr, *i_end; |
||||
|
||||
int match_length, length_footer, extra, verbatim_bits, bytes_todo; |
||||
int this_run, main_element, aligned_bits, j; |
||||
unsigned char *window, *runsrc, *rundest, buf[12]; |
||||
unsigned int frame_size=0, end_frame, match_offset, window_posn; |
||||
unsigned int R0, R1, R2; |
||||
|
||||
/* easy answers */ |
||||
if (!lzx || (out_bytes < 0)) return MSPACK_ERR_ARGS; |
||||
if (lzx->error) return lzx->error; |
||||
|
||||
/* flush out any stored-up bytes before we begin */ |
||||
i = lzx->o_end - lzx->o_ptr; |
||||
if ((off_t) i > out_bytes) i = (int) out_bytes; |
||||
if (i) { |
||||
if (lzx->sys->write(lzx->output, lzx->o_ptr, i) != i) { |
||||
return lzx->error = MSPACK_ERR_WRITE; |
||||
} |
||||
lzx->o_ptr += i; |
||||
lzx->offset += i; |
||||
out_bytes -= i; |
||||
} |
||||
if (out_bytes == 0) return MSPACK_ERR_OK; |
||||
|
||||
/* restore local state */ |
||||
RESTORE_BITS; |
||||
window = lzx->window; |
||||
window_posn = lzx->window_posn; |
||||
R0 = lzx->R0; |
||||
R1 = lzx->R1; |
||||
R2 = lzx->R2; |
||||
|
||||
end_frame = (unsigned int)((lzx->offset + out_bytes) / LZX_FRAME_SIZE) + 1; |
||||
|
||||
while (lzx->frame < end_frame) { |
||||
/* have we reached the reset interval? (if there is one?) */ |
||||
if (lzx->reset_interval && ((lzx->frame % lzx->reset_interval) == 0)) { |
||||
if (lzx->block_remaining) { |
||||
D(("%d bytes remaining at reset interval", lzx->block_remaining)) |
||||
return lzx->error = MSPACK_ERR_DECRUNCH; |
||||
} |
||||
|
||||
/* re-read the intel header and reset the huffman lengths */ |
||||
lzxd_reset_state(lzx); |
||||
} |
||||
|
||||
/* read header if necessary */ |
||||
if (!lzx->header_read) { |
||||
/* read 1 bit. if bit=0, intel filesize = 0.
|
||||
* if bit=1, read intel filesize (32 bits) */ |
||||
j = 0; READ_BITS(i, 1); if (i) { READ_BITS(i, 16); READ_BITS(j, 16); } |
||||
lzx->intel_filesize = (i << 16) | j; |
||||
lzx->header_read = 1; |
||||
}
|
||||
|
||||
/* calculate size of frame: all frames are 32k except the final frame
|
||||
* which is 32kb or less. this can only be calculated when lzx->length |
||||
* has been filled in. */ |
||||
frame_size = LZX_FRAME_SIZE; |
||||
if (lzx->length && (lzx->length - lzx->offset) < (off_t)frame_size) { |
||||
frame_size = lzx->length - lzx->offset; |
||||
} |
||||
|
||||
/* decode until one more frame is available */ |
||||
bytes_todo = lzx->frame_posn + frame_size - window_posn; |
||||
while (bytes_todo > 0) { |
||||
/* initialise new block, if one is needed */ |
||||
if (lzx->block_remaining == 0) { |
||||
/* realign if previous block was an odd-sized UNCOMPRESSED block */ |
||||
if ((lzx->block_type == LZX_BLOCKTYPE_UNCOMPRESSED) && |
||||
(lzx->block_length & 1)) |
||||
{ |
||||
if (i_ptr == i_end) { |
||||
if (lzxd_read_input(lzx)) return lzx->error; |
||||
i_ptr = lzx->i_ptr; |
||||
i_end = lzx->i_end; |
||||
} |
||||
i_ptr++; |
||||
} |
||||
|
||||
/* read block type (3 bits) and block length (24 bits) */ |
||||
READ_BITS(lzx->block_type, 3); |
||||
READ_BITS(i, 16); READ_BITS(j, 8); |
||||
lzx->block_remaining = lzx->block_length = (i << 8) | j; |
||||
/*D(("new block t%d len %u", lzx->block_type, lzx->block_length))*/ |
||||
|
||||
/* read individual block headers */ |
||||
switch (lzx->block_type) { |
||||
case LZX_BLOCKTYPE_ALIGNED: |
||||
/* read lengths of and build aligned huffman decoding tree */ |
||||
for (i = 0; i < 8; i++) { READ_BITS(j, 3); lzx->ALIGNED_len[i] = j; } |
||||
BUILD_TABLE(ALIGNED); |
||||
/* no break -- rest of aligned header is same as verbatim */ |
||||
case LZX_BLOCKTYPE_VERBATIM: |
||||
/* read lengths of and build main huffman decoding tree */ |
||||
READ_LENGTHS(MAINTREE, 0, 256); |
||||
READ_LENGTHS(MAINTREE, 256, LZX_NUM_CHARS + (lzx->posn_slots << 3)); |
||||
BUILD_TABLE(MAINTREE); |
||||
/* if the literal 0xE8 is anywhere in the block... */ |
||||
if (lzx->MAINTREE_len[0xE8] != 0) lzx->intel_started = 1; |
||||
/* read lengths of and build lengths huffman decoding tree */ |
||||
READ_LENGTHS(LENGTH, 0, LZX_NUM_SECONDARY_LENGTHS); |
||||
BUILD_TABLE(LENGTH); |
||||
break; |
||||
|
||||
case LZX_BLOCKTYPE_UNCOMPRESSED: |
||||
/* because we can't assume otherwise */ |
||||
lzx->intel_started = 1; |
||||
|
||||
/* read 1-16 (not 0-15) bits to align to bytes */ |
||||
ENSURE_BITS(16); |
||||
if (bits_left > 16) i_ptr -= 2; |
||||
bits_left = 0; bit_buffer = 0; |
||||
|
||||
/* read 12 bytes of stored R0 / R1 / R2 values */ |
||||
for (rundest = &buf[0], i = 0; i < 12; i++) { |
||||
if (i_ptr == i_end) { |
||||
if (lzxd_read_input(lzx)) return lzx->error; |
||||
i_ptr = lzx->i_ptr; |
||||
i_end = lzx->i_end; |
||||
} |
||||
*rundest++ = *i_ptr++; |
||||
} |
||||
R0 = buf[0] | (buf[1] << 8) | (buf[2] << 16) | (buf[3] << 24); |
||||
R1 = buf[4] | (buf[5] << 8) | (buf[6] << 16) | (buf[7] << 24); |
||||
R2 = buf[8] | (buf[9] << 8) | (buf[10] << 16) | (buf[11] << 24); |
||||
break; |
||||
|
||||
default: |
||||
D(("bad block type")) |
||||
return lzx->error = MSPACK_ERR_DECRUNCH; |
||||
} |
||||
} |
||||
|
||||
/* decode more of the block:
|
||||
* run = min(what's available, what's needed) */ |
||||
this_run = lzx->block_remaining; |
||||
if (this_run > bytes_todo) this_run = bytes_todo; |
||||
|
||||
/* assume we decode exactly this_run bytes, for now */ |
||||
bytes_todo -= this_run; |
||||
lzx->block_remaining -= this_run; |
||||
|
||||
/* decode at least this_run bytes */ |
||||
switch (lzx->block_type) { |
||||
case LZX_BLOCKTYPE_VERBATIM: |
||||
while (this_run > 0) { |
||||
READ_HUFFSYM(MAINTREE, main_element); |
||||
if (main_element < LZX_NUM_CHARS) { |
||||
/* literal: 0 to LZX_NUM_CHARS-1 */ |
||||
window[window_posn++] = main_element; |
||||
this_run--; |
||||
} |
||||
else { |
||||
/* match: LZX_NUM_CHARS + ((slot<<3) | length_header (3 bits)) */ |
||||
main_element -= LZX_NUM_CHARS; |
||||
|
||||
/* get match length */ |
||||
match_length = main_element & LZX_NUM_PRIMARY_LENGTHS; |
||||
if (match_length == LZX_NUM_PRIMARY_LENGTHS) { |
||||
READ_HUFFSYM(LENGTH, length_footer); |
||||
match_length += length_footer; |
||||
} |
||||
match_length += LZX_MIN_MATCH; |
||||
|
||||
/* get match offset */ |
||||
switch ((match_offset = (main_element >> 3))) { |
||||
case 0: match_offset = R0; break; |
||||
case 1: match_offset = R1; R1=R0; R0 = match_offset; break; |
||||
case 2: match_offset = R2; R2=R0; R0 = match_offset; break; |
||||
case 3: match_offset = 1; R2=R1; R1=R0; R0 = match_offset; break; |
||||
default: |
||||
extra = extra_bits[match_offset]; |
||||
READ_BITS(verbatim_bits, extra); |
||||
match_offset = position_base[match_offset] - 2 + verbatim_bits; |
||||
R2 = R1; R1 = R0; R0 = match_offset; |
||||
} |
||||
|
||||
if ((window_posn + match_length) > lzx->window_size) { |
||||
D(("match ran over window wrap")) |
||||
return lzx->error = MSPACK_ERR_DECRUNCH; |
||||
} |
||||
|
||||
/* copy match */ |
||||
rundest = &window[window_posn]; |
||||
i = match_length; |
||||
/* does match offset wrap the window? */ |
||||
if (match_offset > window_posn) { |
||||
/* j = length from match offset to end of window */ |
||||
j = match_offset - window_posn; |
||||
if (j > (int) lzx->window_size) { |
||||
D(("match offset beyond window boundaries")) |
||||
return lzx->error = MSPACK_ERR_DECRUNCH; |
||||
} |
||||
runsrc = &window[lzx->window_size - j]; |
||||
if (j < i) { |
||||
/* if match goes over the window edge, do two copy runs */ |
||||
i -= j; while (j-- > 0) *rundest++ = *runsrc++; |
||||
runsrc = window; |
||||
} |
||||
while (i-- > 0) *rundest++ = *runsrc++; |
||||
} |
||||
else { |
||||
runsrc = rundest - match_offset; |
||||
while (i-- > 0) *rundest++ = *runsrc++; |
||||
} |
||||
|
||||
this_run -= match_length; |
||||
window_posn += match_length; |
||||
} |
||||
} /* while (this_run > 0) */ |
||||
break; |
||||
|
||||
case LZX_BLOCKTYPE_ALIGNED: |
||||
while (this_run > 0) { |
||||
READ_HUFFSYM(MAINTREE, main_element); |
||||
if (main_element < LZX_NUM_CHARS) { |
||||
/* literal: 0 to LZX_NUM_CHARS-1 */ |
||||
window[window_posn++] = main_element; |
||||
this_run--; |
||||
} |
||||
else { |
||||
/* match: LZX_NUM_CHARS + ((slot<<3) | length_header (3 bits)) */ |
||||
main_element -= LZX_NUM_CHARS; |
||||
|
||||
/* get match length */ |
||||
match_length = main_element & LZX_NUM_PRIMARY_LENGTHS; |
||||
if (match_length == LZX_NUM_PRIMARY_LENGTHS) { |
||||
READ_HUFFSYM(LENGTH, length_footer); |
||||
match_length += length_footer; |
||||
} |
||||
match_length += LZX_MIN_MATCH; |
||||
|
||||
/* get match offset */ |
||||
switch ((match_offset = (main_element >> 3))) { |
||||
case 0: match_offset = R0; break; |
||||
case 1: match_offset = R1; R1 = R0; R0 = match_offset; break; |
||||
case 2: match_offset = R2; R2 = R0; R0 = match_offset; break; |
||||
default: |
||||
extra = extra_bits[match_offset]; |
||||
match_offset = position_base[match_offset] - 2; |
||||
if (extra > 3) { |
||||
/* verbatim and aligned bits */ |
||||
extra -= 3; |
||||
READ_BITS(verbatim_bits, extra); |
||||
match_offset += (verbatim_bits << 3); |
||||
READ_HUFFSYM(ALIGNED, aligned_bits); |
||||
match_offset += aligned_bits; |
||||
} |
||||
else if (extra == 3) { |
||||
/* aligned bits only */ |
||||
READ_HUFFSYM(ALIGNED, aligned_bits); |
||||
match_offset += aligned_bits; |
||||
} |
||||
else if (extra > 0) { /* extra==1, extra==2 */ |
||||
/* verbatim bits only */ |
||||
READ_BITS(verbatim_bits, extra); |
||||
match_offset += verbatim_bits; |
||||
} |
||||
else /* extra == 0 */ { |
||||
/* ??? not defined in LZX specification! */ |
||||
match_offset = 1; |
||||
} |
||||
/* update repeated offset LRU queue */ |
||||
R2 = R1; R1 = R0; R0 = match_offset; |
||||
} |
||||
|
||||
if ((window_posn + match_length) > lzx->window_size) { |
||||
D(("match ran over window wrap")) |
||||
return lzx->error = MSPACK_ERR_DECRUNCH; |
||||
} |
||||
|
||||
/* copy match */ |
||||
rundest = &window[window_posn]; |
||||
i = match_length; |
||||
/* does match offset wrap the window? */ |
||||
if (match_offset > window_posn) { |
||||
/* j = length from match offset to end of window */ |
||||
j = match_offset - window_posn; |
||||
if (j > (int) lzx->window_size) { |
||||
D(("match offset beyond window boundaries")) |
||||
return lzx->error = MSPACK_ERR_DECRUNCH; |
||||
} |
||||
runsrc = &window[lzx->window_size - j]; |
||||
if (j < i) { |
||||
/* if match goes over the window edge, do two copy runs */ |
||||
i -= j; while (j-- > 0) *rundest++ = *runsrc++; |
||||
runsrc = window; |
||||
} |
||||
while (i-- > 0) *rundest++ = *runsrc++; |
||||
} |
||||
else { |
||||
runsrc = rundest - match_offset; |
||||
while (i-- > 0) *rundest++ = *runsrc++; |
||||
} |
||||
|
||||
this_run -= match_length; |
||||
window_posn += match_length; |
||||
} |
||||
} /* while (this_run > 0) */ |
||||
break; |
||||
|
||||
case LZX_BLOCKTYPE_UNCOMPRESSED: |
||||
/* as this_run is limited not to wrap a frame, this also means it
|
||||
* won't wrap the window (as the window is a multiple of 32k) */ |
||||
rundest = &window[window_posn]; |
||||
window_posn += this_run; |
||||
while (this_run > 0) { |
||||
if ((i = i_end - i_ptr)) { |
||||
if (i > this_run) i = this_run; |
||||
lzx->sys->copy(i_ptr, rundest, (size_t) i); |
||||
rundest += i; |
||||
i_ptr += i; |
||||
this_run -= i; |
||||
} |
||||
else { |
||||
if (lzxd_read_input(lzx)) return lzx->error; |
||||
i_ptr = lzx->i_ptr; |
||||
i_end = lzx->i_end; |
||||
} |
||||
} |
||||
break; |
||||
|
||||
default: |
||||
return lzx->error = MSPACK_ERR_DECRUNCH; /* might as well */ |
||||
} |
||||
|
||||
/* did the final match overrun our desired this_run length? */ |
||||
if (this_run < 0) { |
||||
if ((unsigned int)(-this_run) > lzx->block_remaining) { |
||||
D(("overrun went past end of block by %d (%d remaining)", |
||||
-this_run, lzx->block_remaining )) |
||||
return lzx->error = MSPACK_ERR_DECRUNCH; |
||||
} |
||||
lzx->block_remaining -= -this_run; |
||||
} |
||||
} /* while (bytes_todo > 0) */ |
||||
|
||||
/* streams don't extend over frame boundaries */ |
||||
if ((window_posn - lzx->frame_posn) != frame_size) { |
||||
D(("decode beyond output frame limits! %d != %d", |
||||
window_posn - lzx->frame_posn, frame_size)) |
||||
return lzx->error = MSPACK_ERR_DECRUNCH; |
||||
} |
||||
|
||||
/* re-align input bitstream */ |
||||
if (bits_left > 0) ENSURE_BITS(16); |
||||
if (bits_left & 15) REMOVE_BITS(bits_left & 15); |
||||
|
||||
/* check that we've used all of the previous frame first */ |
||||
if (lzx->o_ptr != lzx->o_end) { |
||||
D(("%d avail bytes, new %d frame", lzx->o_end-lzx->o_ptr, frame_size)) |
||||
return lzx->error = MSPACK_ERR_DECRUNCH; |
||||
} |
||||
|
||||
/* does this intel block _really_ need decoding? */ |
||||
if (lzx->intel_started && lzx->intel_filesize && |
||||
(lzx->frame <= 32768) && (frame_size > 10)) |
||||
{ |
||||
unsigned char *data = &lzx->e8_buf[0]; |
||||
unsigned char *dataend = &lzx->e8_buf[frame_size - 10]; |
||||
signed int curpos = lzx->intel_curpos; |
||||
signed int filesize = lzx->intel_filesize; |
||||
signed int abs_off, rel_off; |
||||
|
||||
/* copy e8 block to the e8 buffer and tweak if needed */ |
||||
lzx->o_ptr = data; |
||||
lzx->sys->copy(&lzx->window[lzx->frame_posn], data, frame_size); |
||||
|
||||
while (data < dataend) { |
||||
if (*data++ != 0xE8) { curpos++; continue; } |
||||
abs_off = data[0] | (data[1]<<8) | (data[2]<<16) | (data[3]<<24); |
||||
if ((abs_off >= -curpos) && (abs_off < filesize)) { |
||||
rel_off = (abs_off >= 0) ? abs_off - curpos : abs_off + filesize; |
||||
data[0] = (unsigned char) rel_off; |
||||
data[1] = (unsigned char) (rel_off >> 8); |
||||
data[2] = (unsigned char) (rel_off >> 16); |
||||
data[3] = (unsigned char) (rel_off >> 24); |
||||
} |
||||
data += 4; |
||||
curpos += 5; |
||||
} |
||||
lzx->intel_curpos += frame_size; |
||||
} |
||||
else { |
||||
lzx->o_ptr = &lzx->window[lzx->frame_posn]; |
||||
if (lzx->intel_filesize) lzx->intel_curpos += frame_size; |
||||
} |
||||
lzx->o_end = &lzx->o_ptr[frame_size]; |
||||
|
||||
/* write a frame */ |
||||
i = (out_bytes < (off_t)frame_size) ? (unsigned int)out_bytes : frame_size; |
||||
if (lzx->sys->write(lzx->output, lzx->o_ptr, i) != i) { |
||||
return lzx->error = MSPACK_ERR_WRITE; |
||||
} |
||||
lzx->o_ptr += i; |
||||
lzx->offset += i; |
||||
out_bytes -= i; |
||||
|
||||
/* advance frame start position */ |
||||
lzx->frame_posn += frame_size; |
||||
lzx->frame++; |
||||
|
||||
/* wrap window / frame position pointers */ |
||||
if (window_posn == lzx->window_size) window_posn = 0; |
||||
if (lzx->frame_posn == lzx->window_size) lzx->frame_posn = 0; |
||||
|
||||
} /* while (lzx->frame < end_frame) */ |
||||
|
||||
if (out_bytes) { |
||||
D(("bytes left to output")) |
||||
return lzx->error = MSPACK_ERR_DECRUNCH; |
||||
} |
||||
|
||||
/* store local state */ |
||||
STORE_BITS; |
||||
lzx->window_posn = window_posn; |
||||
lzx->R0 = R0; |
||||
lzx->R1 = R1; |
||||
lzx->R2 = R2; |
||||
|
||||
return MSPACK_ERR_OK; |
||||
} |
||||
|
||||
void lzxd_free(struct lzxd_stream *lzx) { |
||||
struct mspack_system *sys; |
||||
if (lzx) { |
||||
sys = lzx->sys; |
||||
sys->free(lzx->inbuf); |
||||
sys->free(lzx->window); |
||||
sys->free(lzx); |
||||
} |
||||
} |
||||
File diff suppressed because it is too large
Load Diff
@ -1,114 +0,0 @@ |
||||
/* This file is part of libmspack.
|
||||
* (C) 2003-2004 Stuart Caie. |
||||
* |
||||
* The deflate method was created by Phil Katz. MSZIP is equivalent to the |
||||
* deflate method. |
||||
* |
||||
* libmspack is free software; you can redistribute it and/or modify it under |
||||
* the terms of the GNU Lesser General Public License (LGPL) version 2.1 |
||||
* |
||||
* For further details, see the file COPYING.LIB distributed with libmspack |
||||
*/ |
||||
|
||||
#ifndef MSPACK_MSZIP_H |
||||
#define MSPACK_MSZIP_H 1 |
||||
|
||||
/* MSZIP (deflate) compression / (inflate) decompression definitions */ |
||||
|
||||
#define MSZIP_FRAME_SIZE (32768) /* size of LZ history window */ |
||||
#define MSZIP_MAX_HUFFBITS (16) /* maximum huffman code length */ |
||||
#define MSZIP_LITERAL_MAXSYMBOLS (288) /* literal/length huffman tree */ |
||||
#define MSZIP_LITERAL_TABLEBITS (9) |
||||
#define MSZIP_DISTANCE_MAXSYMBOLS (32) /* distance huffman tree */ |
||||
#define MSZIP_DISTANCE_TABLEBITS (6) |
||||
|
||||
/* if there are less direct lookup entries than symbols, the longer
|
||||
* code pointers will be <= maxsymbols. This must not happen, or we |
||||
* will decode entries badly */ |
||||
#if (1 << MSZIP_LITERAL_TABLEBITS) < (MSZIP_LITERAL_MAXSYMBOLS * 2) |
||||
# define MSZIP_LITERAL_TABLESIZE (MSZIP_LITERAL_MAXSYMBOLS * 4) |
||||
#else |
||||
# define MSZIP_LITERAL_TABLESIZE ((1 << MSZIP_LITERAL_TABLEBITS) + \ |
||||
(MSZIP_LITERAL_MAXSYMBOLS * 2)) |
||||
#endif |
||||
|
||||
#if (1 << MSZIP_DISTANCE_TABLEBITS) < (MSZIP_DISTANCE_MAXSYMBOLS * 2) |
||||
# define MSZIP_DISTANCE_TABLESIZE (MSZIP_DISTANCE_MAXSYMBOLS * 4) |
||||
#else |
||||
# define MSZIP_DISTANCE_TABLESIZE ((1 << MSZIP_DISTANCE_TABLEBITS) + \ |
||||
(MSZIP_DISTANCE_MAXSYMBOLS * 2)) |
||||
#endif |
||||
|
||||
struct mszipd_stream { |
||||
struct mspack_system *sys; /* I/O routines */ |
||||
struct mspack_file *input; /* input file handle */ |
||||
struct mspack_file *output; /* output file handle */ |
||||
unsigned int window_posn; /* offset within window */ |
||||
|
||||
/* inflate() will call this whenever the window should be emptied. */ |
||||
int (*flush_window)(struct mszipd_stream *, unsigned int); |
||||
|
||||
int error, repair_mode, bytes_output, input_end; |
||||
|
||||
/* I/O buffering */ |
||||
unsigned char *inbuf, *i_ptr, *i_end, *o_ptr, *o_end; |
||||
unsigned int bit_buffer, bits_left, inbuf_size; |
||||
|
||||
|
||||
/* huffman code lengths */ |
||||
unsigned char LITERAL_len[MSZIP_LITERAL_MAXSYMBOLS]; |
||||
unsigned char DISTANCE_len[MSZIP_DISTANCE_MAXSYMBOLS]; |
||||
|
||||
/* huffman decoding tables */ |
||||
unsigned short LITERAL_table [MSZIP_LITERAL_TABLESIZE]; |
||||
unsigned short DISTANCE_table[MSZIP_DISTANCE_TABLESIZE]; |
||||
|
||||
/* 32kb history window */ |
||||
unsigned char window[MSZIP_FRAME_SIZE]; |
||||
}; |
||||
|
||||
/* allocates MS-ZIP decompression stream for decoding the given stream.
|
||||
* |
||||
* - uses system->alloc() to allocate memory |
||||
* |
||||
* - returns NULL if not enough memory |
||||
* |
||||
* - input_buffer_size is how many bytes to use as an input bitstream buffer |
||||
* |
||||
* - if repair_mode is non-zero, errors in decompression will be skipped |
||||
* and 'holes' left will be filled with zero bytes. This allows at least |
||||
* a partial recovery of erroneous data. |
||||
*/ |
||||
extern struct mszipd_stream *mszipd_init(struct mspack_system *system, |
||||
struct mspack_file *input, |
||||
struct mspack_file *output, |
||||
int input_buffer_size, |
||||
int repair_mode); |
||||
|
||||
/* decompresses, or decompresses more of, an MS-ZIP stream.
|
||||
* |
||||
* - out_bytes of data will be decompressed and the function will return |
||||
* with an MSPACK_ERR_OK return code. |
||||
* |
||||
* - decompressing will stop as soon as out_bytes is reached. if the true |
||||
* amount of bytes decoded spills over that amount, they will be kept for |
||||
* a later invocation of mszipd_decompress(). |
||||
* |
||||
* - the output bytes will be passed to the system->write() function given in |
||||
* mszipd_init(), using the output file handle given in mszipd_init(). More |
||||
* than one call may be made to system->write() |
||||
* |
||||
* - MS-ZIP will read input bytes as necessary using the system->read() |
||||
* function given in mszipd_init(), using the input file handle given in |
||||
* mszipd_init(). This will continue until system->read() returns 0 bytes, |
||||
* or an error. |
||||
*/ |
||||
extern int mszipd_decompress(struct mszipd_stream *zip, off_t out_bytes); |
||||
|
||||
/* frees all stream associated with an MS-ZIP data stream
|
||||
* |
||||
* - calls system->free() using the system pointer given in mszipd_init() |
||||
*/ |
||||
void mszipd_free(struct mszipd_stream *zip); |
||||
|
||||
#endif |
||||
@ -1,668 +0,0 @@ |
||||
/* This file is part of libmspack.
|
||||
* (C) 2003-2004 Stuart Caie. |
||||
* |
||||
* The deflate method was created by Phil Katz. MSZIP is equivalent to the |
||||
* deflate method. |
||||
* |
||||
* libmspack is free software; you can redistribute it and/or modify it under |
||||
* the terms of the GNU Lesser General Public License (LGPL) version 2.1 |
||||
* |
||||
* For further details, see the file COPYING.LIB distributed with libmspack |
||||
*/ |
||||
|
||||
/* MS-ZIP decompression implementation. */ |
||||
|
||||
#if HAVE_CONFIG_H |
||||
#include "clamav-config.h" |
||||
#endif |
||||
|
||||
#include <mspack.h> |
||||
#include <system.h> |
||||
#include <mszip.h> |
||||
|
||||
#include "others.h" |
||||
|
||||
/* match lengths for literal codes 257.. 285 */ |
||||
static const unsigned short lit_lengths[29] = { |
||||
3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, |
||||
31, 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258 |
||||
}; |
||||
|
||||
/* match offsets for distance codes 0 .. 29 */ |
||||
static const unsigned short dist_offsets[30] = { |
||||
1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385, |
||||
513, 769, 1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577 |
||||
}; |
||||
|
||||
/* extra bits required for literal codes 257.. 285 */ |
||||
static const unsigned char lit_extrabits[29] = { |
||||
0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, |
||||
2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0 |
||||
}; |
||||
|
||||
/* extra bits required for distance codes 0 .. 29 */ |
||||
static const unsigned char dist_extrabits[30] = { |
||||
0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, |
||||
6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13 |
||||
}; |
||||
|
||||
/* the order of the bit length Huffman code lengths */ |
||||
static const unsigned char bitlen_order[19] = { |
||||
16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15 |
||||
}; |
||||
|
||||
/* ANDing with bit_mask[n] masks the lower n bits */ |
||||
static const unsigned short bit_mask[17] = { |
||||
0x0000, 0x0001, 0x0003, 0x0007, 0x000f, 0x001f, 0x003f, 0x007f, 0x00ff, |
||||
0x01ff, 0x03ff, 0x07ff, 0x0fff, 0x1fff, 0x3fff, 0x7fff, 0xffff |
||||
}; |
||||
|
||||
#define STORE_BITS do { \ |
||||
zip->i_ptr = i_ptr; \
|
||||
zip->i_end = i_end; \
|
||||
zip->bit_buffer = bit_buffer; \
|
||||
zip->bits_left = bits_left; \
|
||||
} while (0) |
||||
|
||||
#define RESTORE_BITS do { \ |
||||
i_ptr = zip->i_ptr; \
|
||||
i_end = zip->i_end; \
|
||||
bit_buffer = zip->bit_buffer; \
|
||||
bits_left = zip->bits_left; \
|
||||
} while (0) |
||||
|
||||
#define ENSURE_BITS(nbits) do { \ |
||||
while (bits_left < (nbits)) { \
|
||||
if (i_ptr >= i_end) { \
|
||||
if (zipd_read_input(zip)) return zip->error; \
|
||||
i_ptr = zip->i_ptr; \
|
||||
i_end = zip->i_end; \
|
||||
} \
|
||||
bit_buffer |= *i_ptr++ << bits_left; bits_left += 8; \
|
||||
} \
|
||||
} while (0) |
||||
|
||||
#define PEEK_BITS(nbits) (bit_buffer & ((1<<(nbits))-1)) |
||||
#define PEEK_BITS_T(nbits) (bit_buffer & bit_mask[(nbits)]) |
||||
|
||||
#define REMOVE_BITS(nbits) ((bit_buffer >>= (nbits)), (bits_left -= (nbits))) |
||||
|
||||
#define READ_BITS(val, nbits) do { \ |
||||
ENSURE_BITS(nbits); (val) = PEEK_BITS(nbits); REMOVE_BITS(nbits); \
|
||||
} while (0) |
||||
|
||||
#define READ_BITS_T(val, nbits) do { \ |
||||
ENSURE_BITS(nbits); (val) = PEEK_BITS_T(nbits); REMOVE_BITS(nbits); \
|
||||
} while (0) |
||||
|
||||
static int zipd_read_input(struct mszipd_stream *zip) { |
||||
int read = zip->sys->read(zip->input, &zip->inbuf[0], (int)zip->inbuf_size); |
||||
if (read < 0) return zip->error = MSPACK_ERR_READ; |
||||
|
||||
if (read == 0) { |
||||
if (zip->input_end) { |
||||
D(("out of input bytes")) |
||||
return zip->error = MSPACK_ERR_READ; |
||||
} |
||||
else { |
||||
read = 1; |
||||
zip->inbuf[0] = 0; |
||||
zip->input_end = 1; |
||||
} |
||||
} |
||||
|
||||
zip->i_ptr = &zip->inbuf[0]; |
||||
zip->i_end = &zip->inbuf[read]; |
||||
|
||||
return MSPACK_ERR_OK; |
||||
} |
||||
|
||||
/* inflate() error codes */ |
||||
#define INF_ERR_BLOCKTYPE (-1) /* unknown block type */ |
||||
#define INF_ERR_COMPLEMENT (-2) /* block size complement mismatch */ |
||||
#define INF_ERR_FLUSH (-3) /* error from flush_window() callback */ |
||||
#define INF_ERR_BITBUF (-4) /* too many bits in bit buffer */ |
||||
#define INF_ERR_SYMLENS (-5) /* too many symbols in blocktype 2 header */ |
||||
#define INF_ERR_BITLENTBL (-6) /* failed to build bitlens huffman table */ |
||||
#define INF_ERR_LITERALTBL (-7) /* failed to build literals huffman table */ |
||||
#define INF_ERR_DISTANCETBL (-8) /* failed to build distance huffman table */ |
||||
#define INF_ERR_BITOVERRUN (-9) /* bitlen RLE code goes over table size */ |
||||
#define INF_ERR_BADBITLEN (-10) /* invalid bit-length code */ |
||||
#define INF_ERR_LITCODE (-11) /* out-of-range literal code */ |
||||
#define INF_ERR_DISTCODE (-12) /* out-of-range distance code */ |
||||
#define INF_ERR_DISTANCE (-13) /* somehow, distance is beyond 32k */ |
||||
#define INF_ERR_HUFFSYM (-14) /* out of bits decoding huffman symbol */ |
||||
|
||||
/* make_decode_table(nsyms, nbits, length[], table[])
|
||||
* |
||||
* This function was coded by David Tritscher. It builds a fast huffman |
||||
* decoding table out of just a canonical huffman code lengths table. |
||||
* |
||||
* NOTE: this is NOT identical to the make_decode_table() in lzxd.c. This |
||||
* one reverses the quick-lookup bit pattern. Bits are read MSB to LSB in LZX, |
||||
* but LSB to MSB in MSZIP. |
||||
* |
||||
* nsyms = total number of symbols in this huffman tree. |
||||
* nbits = any symbols with a code length of nbits or less can be decoded |
||||
* in one lookup of the table. |
||||
* length = A table to get code lengths from [0 to nsyms-1] |
||||
* table = The table to fill up with decoded symbols and pointers. |
||||
* |
||||
* Returns 0 for OK or 1 for error |
||||
*/ |
||||
static int make_decode_table(unsigned int nsyms, unsigned int nbits, |
||||
unsigned char *length, unsigned short *table) |
||||
{ |
||||
register unsigned int leaf, reverse, fill; |
||||
register unsigned short sym, next_sym; |
||||
register unsigned char bit_num; |
||||
unsigned int pos = 0; /* the current position in the decode table */ |
||||
unsigned int table_mask = 1 << nbits; |
||||
unsigned int bit_mask = table_mask >> 1; /* don't do 0 length codes */ |
||||
|
||||
/* fill entries for codes short enough for a direct mapping */ |
||||
for (bit_num = 1; bit_num <= nbits; bit_num++) { |
||||
for (sym = 0; sym < nsyms; sym++) { |
||||
if (length[sym] != bit_num) continue; |
||||
|
||||
/* reverse the significant bits */ |
||||
fill = length[sym]; reverse = pos >> (nbits - fill); leaf = 0; |
||||
do {leaf <<= 1; leaf |= reverse & 1; reverse >>= 1;} while (--fill); |
||||
|
||||
if((pos += bit_mask) > table_mask) return 1; /* table overrun */ |
||||
|
||||
/* fill all possible lookups of this symbol with the symbol itself */ |
||||
fill = bit_mask; next_sym = 1 << bit_num; |
||||
do { table[leaf] = sym; leaf += next_sym; } while (--fill); |
||||
} |
||||
bit_mask >>= 1; |
||||
} |
||||
|
||||
/* exit with success if table is now complete */ |
||||
if (pos == table_mask) return 0; |
||||
|
||||
/* mark all remaining table entries as unused */ |
||||
for (sym = pos; sym < table_mask; sym++) { |
||||
reverse = sym; leaf = 0; fill = nbits; |
||||
do { leaf <<= 1; leaf |= reverse & 1; reverse >>= 1; } while (--fill); |
||||
table[leaf] = 0xFFFF; |
||||
} |
||||
|
||||
/* where should the longer codes be allocated from? */ |
||||
next_sym = ((table_mask >> 1) < nsyms) ? nsyms : (table_mask >> 1); |
||||
|
||||
/* give ourselves room for codes to grow by up to 16 more bits.
|
||||
* codes now start at bit nbits+16 and end at (nbits+16-codelength) */ |
||||
pos <<= 16; |
||||
table_mask <<= 16; |
||||
bit_mask = 1 << 15; |
||||
|
||||
for (bit_num = nbits+1; bit_num <= MSZIP_MAX_HUFFBITS; bit_num++) { |
||||
for (sym = 0; sym < nsyms; sym++) { |
||||
if (length[sym] != bit_num) continue; |
||||
|
||||
/* leaf = the first nbits of the code, reversed */ |
||||
reverse = pos >> 16; leaf = 0; fill = nbits; |
||||
do {leaf <<= 1; leaf |= reverse & 1; reverse >>= 1;} while (--fill); |
||||
|
||||
for (fill = 0; fill < (bit_num - nbits); fill++) { |
||||
/* if this path hasn't been taken yet, 'allocate' two entries */ |
||||
if (table[leaf] == 0xFFFF) { |
||||
table[(next_sym << 1) ] = 0xFFFF; |
||||
table[(next_sym << 1) + 1 ] = 0xFFFF; |
||||
table[leaf] = next_sym++; |
||||
} |
||||
/* follow the path and select either left or right for next bit */ |
||||
leaf = (table[leaf] << 1) | ((pos >> (15 - fill)) & 1); |
||||
} |
||||
table[leaf] = sym; |
||||
|
||||
if ((pos += bit_mask) > table_mask) return 1; /* table overflow */ |
||||
} |
||||
bit_mask >>= 1; |
||||
} |
||||
|
||||
/* full table? */ |
||||
return (pos != table_mask) ? 1 : 0; |
||||
} |
||||
|
||||
/* READ_HUFFSYM(tablename, var) decodes one huffman symbol from the
|
||||
* bitstream using the stated table and puts it in var. |
||||
*/ |
||||
#define READ_HUFFSYM(tbl, var) do { \ |
||||
/* huffman symbols can be up to 16 bits long */ \
|
||||
ENSURE_BITS(MSZIP_MAX_HUFFBITS); \
|
||||
/* immediate table lookup of [tablebits] bits of the code */ \
|
||||
sym = zip->tbl##_table[PEEK_BITS(MSZIP_##tbl##_TABLEBITS)]; \
|
||||
/* is the symbol is longer than [tablebits] bits? (i=node index) */ \
|
||||
if (sym >= MSZIP_##tbl##_MAXSYMBOLS) { \
|
||||
/* decode remaining bits by tree traversal */ \
|
||||
i = MSZIP_##tbl##_TABLEBITS - 1; \
|
||||
do { \
|
||||
/* check next bit. error if we run out of bits before decode */ \
|
||||
if (i++ > MSZIP_MAX_HUFFBITS) { \
|
||||
D(("out of bits in huffman decode")) \
|
||||
return INF_ERR_HUFFSYM; \
|
||||
} \
|
||||
/* double node index and add 0 (left branch) or 1 (right) */ \
|
||||
sym = zip->tbl##_table[(sym << 1) | ((bit_buffer >> i) & 1)]; \
|
||||
/* while we are still in node indicies, not decoded symbols */ \
|
||||
} while (sym >= MSZIP_##tbl##_MAXSYMBOLS); \
|
||||
} \
|
||||
/* result */ \
|
||||
(var) = sym; \
|
||||
/* look up the code length of that symbol and discard those bits */ \
|
||||
i = zip->tbl##_len[sym]; \
|
||||
REMOVE_BITS(i); \
|
||||
} while (0) |
||||
|
||||
static int zip_read_lens(struct mszipd_stream *zip) { |
||||
/* for the bit buffer and huffman decoding */ |
||||
register unsigned int bit_buffer; |
||||
register int bits_left; |
||||
unsigned char *i_ptr, *i_end; |
||||
|
||||
/* bitlen Huffman codes -- immediate lookup, 7 bit max code length */ |
||||
unsigned short bl_table[(1 << 7)]; |
||||
unsigned char bl_len[19]; |
||||
|
||||
unsigned char lens[MSZIP_LITERAL_MAXSYMBOLS + MSZIP_DISTANCE_MAXSYMBOLS]; |
||||
unsigned int lit_codes, dist_codes, code, last_code=0, bitlen_codes, i, run; |
||||
|
||||
RESTORE_BITS; |
||||
|
||||
/* read the number of codes */ |
||||
READ_BITS(lit_codes, 5); lit_codes += 257; |
||||
READ_BITS(dist_codes, 5); dist_codes += 1; |
||||
READ_BITS(bitlen_codes, 4); bitlen_codes += 4; |
||||
if (lit_codes > MSZIP_LITERAL_MAXSYMBOLS) return INF_ERR_SYMLENS; |
||||
if (dist_codes > MSZIP_DISTANCE_MAXSYMBOLS) return INF_ERR_SYMLENS; |
||||
|
||||
/* read in the bit lengths in their unusual order */ |
||||
for (i = 0; i < bitlen_codes; i++) READ_BITS(bl_len[bitlen_order[i]], 3); |
||||
while (i < 19) bl_len[bitlen_order[i++]] = 0; |
||||
|
||||
/* create decoding table with an immediate lookup */ |
||||
if (make_decode_table(19, 7, &bl_len[0], &bl_table[0])) { |
||||
return INF_ERR_BITLENTBL; |
||||
} |
||||
|
||||
/* read literal / distance code lengths */ |
||||
for (i = 0; i < (lit_codes + dist_codes); i++) { |
||||
/* single-level huffman lookup */ |
||||
ENSURE_BITS(7); |
||||
code = bl_table[PEEK_BITS(7)]; |
||||
REMOVE_BITS(bl_len[code]); |
||||
|
||||
if (code < 16) lens[i] = last_code = code; |
||||
else { |
||||
switch (code) { |
||||
case 16: READ_BITS(run, 2); run += 3; code = last_code; break; |
||||
case 17: READ_BITS(run, 3); run += 3; code = 0; break; |
||||
case 18: READ_BITS(run, 7); run += 11; code = 0; break; |
||||
default: D(("bad code!: %u", code)) return INF_ERR_BADBITLEN; |
||||
} |
||||
if ((i + run) > (lit_codes + dist_codes)) return INF_ERR_BITOVERRUN; |
||||
while (run--) lens[i++] = code; |
||||
i--; |
||||
} |
||||
} |
||||
|
||||
/* copy LITERAL code lengths and clear any remaining */ |
||||
i = lit_codes; |
||||
zip->sys->copy(&lens[0], &zip->LITERAL_len[0], i); |
||||
while (i < MSZIP_LITERAL_MAXSYMBOLS) zip->LITERAL_len[i++] = 0; |
||||
|
||||
i = dist_codes; |
||||
zip->sys->copy(&lens[lit_codes], &zip->DISTANCE_len[0], i); |
||||
while (i < MSZIP_DISTANCE_MAXSYMBOLS) zip->DISTANCE_len[i++] = 0; |
||||
|
||||
STORE_BITS; |
||||
return 0; |
||||
} |
||||
|
||||
/* a clean implementation of RFC 1951 / inflate */ |
||||
static int inflate(struct mszipd_stream *zip) { |
||||
unsigned int last_block, block_type, distance, length, this_run, i; |
||||
|
||||
/* for the bit buffer and huffman decoding */ |
||||
register unsigned int bit_buffer; |
||||
register int bits_left; |
||||
register unsigned short sym; |
||||
unsigned char *i_ptr, *i_end; |
||||
|
||||
RESTORE_BITS; |
||||
|
||||
do { |
||||
/* read in last block bit */ |
||||
READ_BITS(last_block, 1); |
||||
|
||||
/* read in block type */ |
||||
READ_BITS(block_type, 2); |
||||
D(("block_type=%u last_block=%u", block_type, last_block)) |
||||
|
||||
if (block_type == 0) { |
||||
/* uncompressed block */ |
||||
unsigned char lens_buf[4]; |
||||
|
||||
/* go to byte boundary */ |
||||
i = bits_left & 7; REMOVE_BITS(i); |
||||
|
||||
/* read 4 bytes of data, emptying the bit-buffer if necessary */ |
||||
for (i = 0; (bits_left >= 8); i++) { |
||||
if (i == 4) return INF_ERR_BITBUF; |
||||
lens_buf[i] = PEEK_BITS(8); |
||||
REMOVE_BITS(8); |
||||
} |
||||
if (bits_left != 0) return INF_ERR_BITBUF; |
||||
while (i < 4) { |
||||
if (i_ptr >= i_end) { |
||||
if (zipd_read_input(zip)) return zip->error; |
||||
i_ptr = zip->i_ptr; |
||||
i_end = zip->i_end; |
||||
} |
||||
lens_buf[i++] = *i_ptr++; |
||||
} |
||||
|
||||
/* get the length and its complement */ |
||||
length = lens_buf[0] | (lens_buf[1] << 8); |
||||
i = lens_buf[2] | (lens_buf[3] << 8); |
||||
if (length != (~i & 0xFFFF)) return INF_ERR_COMPLEMENT; |
||||
|
||||
/* read and copy the uncompressed data into the window */ |
||||
while (length > 0) { |
||||
if (i_ptr >= i_end) { |
||||
if (zipd_read_input(zip)) return zip->error; |
||||
i_ptr = zip->i_ptr; |
||||
i_end = zip->i_end; |
||||
} |
||||
|
||||
this_run = length; |
||||
if (this_run > (unsigned int)(i_end - i_ptr)) this_run = i_end - i_ptr; |
||||
if (this_run > (MSZIP_FRAME_SIZE - zip->window_posn)) |
||||
this_run = MSZIP_FRAME_SIZE - zip->window_posn; |
||||
|
||||
zip->sys->copy(i_ptr, &zip->window[zip->window_posn], this_run); |
||||
zip->window_posn += this_run; |
||||
i_ptr += this_run; |
||||
length -= this_run; |
||||
|
||||
if (zip->window_posn == MSZIP_FRAME_SIZE) { |
||||
if (zip->flush_window(zip, MSZIP_FRAME_SIZE)) return INF_ERR_FLUSH; |
||||
zip->window_posn = 0; |
||||
} |
||||
} |
||||
} |
||||
else if ((block_type == 1) || (block_type == 2)) { |
||||
/* Huffman-compressed LZ77 block */ |
||||
unsigned int window_posn, match_posn, code; |
||||
|
||||
if (block_type == 1) { |
||||
/* block with fixed Huffman codes */ |
||||
i = 0; |
||||
while (i < 144) zip->LITERAL_len[i++] = 8; |
||||
while (i < 256) zip->LITERAL_len[i++] = 9; |
||||
while (i < 280) zip->LITERAL_len[i++] = 7; |
||||
while (i < 288) zip->LITERAL_len[i++] = 8; |
||||
for (i = 0; i < 32; i++) zip->DISTANCE_len[i] = 5; |
||||
} |
||||
else { |
||||
/* block with dynamic Huffman codes */ |
||||
STORE_BITS; |
||||
if ((i = zip_read_lens(zip))) return i; |
||||
RESTORE_BITS; |
||||
} |
||||
|
||||
/* now huffman lengths are read for either kind of block,
|
||||
* create huffman decoding tables */ |
||||
if (make_decode_table(MSZIP_LITERAL_MAXSYMBOLS, MSZIP_LITERAL_TABLEBITS, |
||||
&zip->LITERAL_len[0], &zip->LITERAL_table[0])) |
||||
{ |
||||
return INF_ERR_LITERALTBL; |
||||
} |
||||
|
||||
if (make_decode_table(MSZIP_DISTANCE_MAXSYMBOLS,MSZIP_DISTANCE_TABLEBITS, |
||||
&zip->DISTANCE_len[0], &zip->DISTANCE_table[0])) |
||||
{ |
||||
return INF_ERR_DISTANCETBL; |
||||
} |
||||
|
||||
/* decode forever until end of block code */ |
||||
window_posn = zip->window_posn; |
||||
while (1) { |
||||
READ_HUFFSYM(LITERAL, code); |
||||
if (code < 256) { |
||||
zip->window[window_posn++] = (unsigned char) code; |
||||
if (window_posn == MSZIP_FRAME_SIZE) { |
||||
if (zip->flush_window(zip, MSZIP_FRAME_SIZE)) return INF_ERR_FLUSH; |
||||
window_posn = 0; |
||||
} |
||||
} |
||||
else if (code == 256) { |
||||
/* END OF BLOCK CODE: loop break point */ |
||||
break; |
||||
} |
||||
else { |
||||
code -= 257; |
||||
if (code > 29) return INF_ERR_LITCODE; |
||||
READ_BITS_T(length, lit_extrabits[code]); |
||||
length += lit_lengths[code]; |
||||
|
||||
READ_HUFFSYM(DISTANCE, code); |
||||
if (code > 30) return INF_ERR_DISTCODE; |
||||
READ_BITS_T(distance, dist_extrabits[code]); |
||||
distance += dist_offsets[code]; |
||||
|
||||
/* match position is window position minus distance. If distance
|
||||
* is more than window position numerically, it must 'wrap |
||||
* around' the frame size. */
|
||||
match_posn = ((distance > window_posn) ? MSZIP_FRAME_SIZE : 0) |
||||
+ window_posn - distance; |
||||
|
||||
/* copy match */ |
||||
if (length < 12) { |
||||
/* short match, use slower loop but no loop setup code */ |
||||
while (length--) { |
||||
zip->window[window_posn++] = zip->window[match_posn++]; |
||||
match_posn &= MSZIP_FRAME_SIZE - 1; |
||||
|
||||
if (window_posn == MSZIP_FRAME_SIZE) { |
||||
if (zip->flush_window(zip, MSZIP_FRAME_SIZE)) |
||||
return INF_ERR_FLUSH; |
||||
window_posn = 0; |
||||
} |
||||
} |
||||
} |
||||
else { |
||||
/* longer match, use faster loop but with setup expense */ |
||||
unsigned char *runsrc, *rundest; |
||||
do { |
||||
this_run = length; |
||||
if ((match_posn + this_run) > MSZIP_FRAME_SIZE) |
||||
this_run = MSZIP_FRAME_SIZE - match_posn; |
||||
if ((window_posn + this_run) > MSZIP_FRAME_SIZE) |
||||
this_run = MSZIP_FRAME_SIZE - window_posn; |
||||
|
||||
rundest = &zip->window[window_posn]; window_posn += this_run; |
||||
runsrc = &zip->window[match_posn]; match_posn += this_run; |
||||
length -= this_run; |
||||
while (this_run--) *rundest++ = *runsrc++; |
||||
|
||||
/* flush if necessary */ |
||||
if (window_posn == MSZIP_FRAME_SIZE) { |
||||
if (zip->flush_window(zip, MSZIP_FRAME_SIZE)) |
||||
return INF_ERR_FLUSH; |
||||
window_posn = 0; |
||||
} |
||||
if (match_posn == MSZIP_FRAME_SIZE) match_posn = 0; |
||||
} while (length > 0); |
||||
} |
||||
|
||||
} /* else (code >= 257) */ |
||||
|
||||
} /* while (forever) -- break point at 'code == 256' */ |
||||
zip->window_posn = window_posn; |
||||
} |
||||
else { |
||||
/* block_type == 3 -- bad block type */ |
||||
return INF_ERR_BLOCKTYPE; |
||||
} |
||||
} while (!last_block); |
||||
|
||||
/* flush the remaining data */ |
||||
if (zip->window_posn) { |
||||
if (zip->flush_window(zip, zip->window_posn)) return INF_ERR_FLUSH; |
||||
} |
||||
STORE_BITS; |
||||
|
||||
/* return success */ |
||||
return 0; |
||||
} |
||||
|
||||
/* inflate() calls this whenever the window should be flushed. As
|
||||
* MSZIP only expands to the size of the window, the implementation used |
||||
* simply keeps track of the amount of data flushed, and if more than 32k |
||||
* is flushed, an error is raised. |
||||
*/
|
||||
static int mszipd_flush_window(struct mszipd_stream *zip, |
||||
unsigned int data_flushed) |
||||
{ |
||||
zip->bytes_output += data_flushed; |
||||
if (zip->bytes_output > MSZIP_FRAME_SIZE) { |
||||
D(("overflow: %u bytes flushed, total is now %u", |
||||
data_flushed, zip->bytes_output)) |
||||
return 1; |
||||
} |
||||
return 0; |
||||
} |
||||
|
||||
struct mszipd_stream *mszipd_init(struct mspack_system *system, |
||||
struct mspack_file *input, |
||||
struct mspack_file *output, |
||||
int input_buffer_size, |
||||
int repair_mode) |
||||
{ |
||||
struct mszipd_stream *zip; |
||||
|
||||
if (!system) return NULL; |
||||
|
||||
input_buffer_size = (input_buffer_size + 1) & -2; |
||||
if (!input_buffer_size) return NULL; |
||||
|
||||
/* allocate decompression state */ |
||||
if (!(zip = system->alloc(system, sizeof(struct mszipd_stream)))) { |
||||
return NULL; |
||||
} |
||||
|
||||
/* allocate input buffer */ |
||||
zip->inbuf = system->alloc(system, (size_t) input_buffer_size); |
||||
if (!zip->inbuf) { |
||||
system->free(zip); |
||||
return NULL; |
||||
} |
||||
|
||||
/* initialise decompression state */ |
||||
zip->sys = system; |
||||
zip->input = input; |
||||
zip->output = output; |
||||
zip->inbuf_size = input_buffer_size; |
||||
zip->error = MSPACK_ERR_OK; |
||||
zip->repair_mode = repair_mode; |
||||
zip->flush_window = &mszipd_flush_window; |
||||
zip->input_end = 0; |
||||
|
||||
zip->i_ptr = zip->i_end = &zip->inbuf[0]; |
||||
zip->o_ptr = zip->o_end = NULL; |
||||
zip->bit_buffer = 0; zip->bits_left = 0; |
||||
return zip; |
||||
} |
||||
|
||||
int mszipd_decompress(struct mszipd_stream *zip, off_t out_bytes) { |
||||
/* for the bit buffer */ |
||||
register unsigned int bit_buffer; |
||||
register int bits_left; |
||||
unsigned char *i_ptr, *i_end; |
||||
|
||||
int i, state, error; |
||||
|
||||
/* easy answers */ |
||||
if (!zip || (out_bytes < 0)) return MSPACK_ERR_ARGS; |
||||
if (zip->error) return zip->error; |
||||
|
||||
/* flush out any stored-up bytes before we begin */ |
||||
i = zip->o_end - zip->o_ptr; |
||||
if ((off_t) i > out_bytes) i = (int) out_bytes; |
||||
if (i) { |
||||
if (zip->sys->write(zip->output, zip->o_ptr, i) != i) { |
||||
return zip->error = MSPACK_ERR_WRITE; |
||||
} |
||||
zip->o_ptr += i; |
||||
out_bytes -= i; |
||||
} |
||||
if (out_bytes == 0) return MSPACK_ERR_OK; |
||||
|
||||
|
||||
while (out_bytes > 0) { |
||||
/* unpack another block */ |
||||
RESTORE_BITS; |
||||
|
||||
/* skip to next read 'CK' header */ |
||||
i = bits_left & 7; REMOVE_BITS(i); /* align to bytestream */ |
||||
state = 0; |
||||
do { |
||||
READ_BITS(i, 8); |
||||
if (i == 'C') state = 1; |
||||
else if ((state == 1) && (i == 'K')) state = 2; |
||||
else state = 0; |
||||
} while (state != 2); |
||||
|
||||
/* inflate a block, repair and realign if necessary */ |
||||
zip->window_posn = 0; |
||||
zip->bytes_output = 0; |
||||
STORE_BITS; |
||||
if ((error = inflate(zip))) { |
||||
D(("inflate error %d", i)) |
||||
if (zip->repair_mode) { |
||||
zip->sys->message(NULL, "MSZIP error, %u bytes of data lost.", |
||||
MSZIP_FRAME_SIZE - zip->bytes_output); |
||||
for (i = zip->bytes_output; i < MSZIP_FRAME_SIZE; i++) { |
||||
zip->window[i] = '\0'; |
||||
} |
||||
zip->bytes_output = MSZIP_FRAME_SIZE; |
||||
} |
||||
else { |
||||
return zip->error = (error > 0) ? error : MSPACK_ERR_DECRUNCH; |
||||
} |
||||
} |
||||
zip->o_ptr = &zip->window[0]; |
||||
zip->o_end = &zip->o_ptr[zip->bytes_output]; |
||||
|
||||
/* write a frame */ |
||||
i = (out_bytes < (off_t)zip->bytes_output) ? |
||||
(int)out_bytes : zip->bytes_output; |
||||
if (zip->sys->write(zip->output, zip->o_ptr, i) != i) { |
||||
return zip->error = MSPACK_ERR_WRITE; |
||||
} |
||||
|
||||
/* mspack errors (i.e. read errors) are fatal and can't be recovered */ |
||||
if ((error > 0) && zip->repair_mode) return error; |
||||
|
||||
zip->o_ptr += i; |
||||
out_bytes -= i; |
||||
} |
||||
|
||||
if (out_bytes) { |
||||
D(("bytes left to output")) |
||||
return zip->error = MSPACK_ERR_DECRUNCH; |
||||
} |
||||
return MSPACK_ERR_OK; |
||||
} |
||||
|
||||
void mszipd_free(struct mszipd_stream *zip) { |
||||
struct mspack_system *sys; |
||||
if (zip) { |
||||
sys = zip->sys; |
||||
sys->free(zip->inbuf); |
||||
sys->free(zip); |
||||
} |
||||
} |
||||
@ -1,120 +0,0 @@ |
||||
/* This file is part of libmspack.
|
||||
* (C) 2003-2004 Stuart Caie. |
||||
* |
||||
* The Quantum method was created by David Stafford, adapted by Microsoft |
||||
* Corporation. |
||||
* |
||||
* libmspack is free software; you can redistribute it and/or modify it under |
||||
* the terms of the GNU Lesser General Public License (LGPL) version 2.1 |
||||
* |
||||
* For further details, see the file COPYING.LIB distributed with libmspack |
||||
*/ |
||||
|
||||
#ifndef MSPACK_QTM_H |
||||
#define MSPACK_QTM_H 1 |
||||
|
||||
/* Quantum compression / decompression definitions */ |
||||
|
||||
#define QTM_FRAME_SIZE (32768) |
||||
|
||||
struct qtmd_modelsym { |
||||
unsigned short sym, cumfreq; |
||||
}; |
||||
|
||||
struct qtmd_model { |
||||
int shiftsleft, entries; |
||||
struct qtmd_modelsym *syms; |
||||
}; |
||||
|
||||
struct qtmd_stream { |
||||
struct mspack_system *sys; /* I/O routines */ |
||||
struct mspack_file *input; /* input file handle */ |
||||
struct mspack_file *output; /* output file handle */ |
||||
|
||||
unsigned char *window; /* decoding window */ |
||||
unsigned int window_size; /* window size */ |
||||
unsigned int window_posn; /* decompression offset within window */ |
||||
unsigned int frame_start; /* start of current frame within window */ |
||||
|
||||
unsigned short H, L, C; /* high/low/current: arith coding state */ |
||||
unsigned char header_read; /* have we started decoding a new frame? */ |
||||
|
||||
int error; |
||||
|
||||
/* I/O buffers */ |
||||
unsigned char *inbuf, *i_ptr, *i_end, *o_ptr, *o_end; |
||||
unsigned int bit_buffer, inbuf_size; |
||||
unsigned char bits_left; |
||||
|
||||
/* four literal models, each representing 64 symbols
|
||||
* model0 for literals from 0 to 63 (selector = 0) |
||||
* model1 for literals from 64 to 127 (selector = 1) |
||||
* model2 for literals from 128 to 191 (selector = 2) |
||||
* model3 for literals from 129 to 255 (selector = 3) */ |
||||
struct qtmd_model model0, model1, model2, model3; |
||||
|
||||
/* three match models.
|
||||
* model4 for match with fixed length of 3 bytes |
||||
* model5 for match with fixed length of 4 bytes |
||||
* model6 for variable length match, encoded with model6len model */ |
||||
struct qtmd_model model4, model5, model6, model6len; |
||||
|
||||
/* selector model. 0-6 to say literal (0,1,2,3) or match (4,5,6) */ |
||||
struct qtmd_model model7; |
||||
|
||||
/* symbol arrays for all models */ |
||||
struct qtmd_modelsym m0sym[64 + 1]; |
||||
struct qtmd_modelsym m1sym[64 + 1]; |
||||
struct qtmd_modelsym m2sym[64 + 1]; |
||||
struct qtmd_modelsym m3sym[64 + 1]; |
||||
struct qtmd_modelsym m4sym[24 + 1]; |
||||
struct qtmd_modelsym m5sym[36 + 1]; |
||||
struct qtmd_modelsym m6sym[42 + 1], m6lsym[27 + 1]; |
||||
struct qtmd_modelsym m7sym[7 + 1]; |
||||
}; |
||||
|
||||
/* allocates Quantum decompression state for decoding the given stream.
|
||||
* |
||||
* - returns NULL if window_bits is outwith the range 10 to 21 (inclusive). |
||||
* |
||||
* - uses system->alloc() to allocate memory |
||||
* |
||||
* - returns NULL if not enough memory |
||||
* |
||||
* - window_bits is the size of the Quantum window, from 1Kb (10) to 2Mb (21). |
||||
* |
||||
* - input_buffer_size is the number of bytes to use to store bitstream data. |
||||
*/ |
||||
extern struct qtmd_stream *qtmd_init(struct mspack_system *system, |
||||
struct mspack_file *input, |
||||
struct mspack_file *output, |
||||
int window_bits, |
||||
int input_buffer_size); |
||||
|
||||
/* decompresses, or decompresses more of, a Quantum stream.
|
||||
* |
||||
* - out_bytes of data will be decompressed and the function will return |
||||
* with an MSPACK_ERR_OK return code. |
||||
* |
||||
* - decompressing will stop as soon as out_bytes is reached. if the true |
||||
* amount of bytes decoded spills over that amount, they will be kept for |
||||
* a later invocation of qtmd_decompress(). |
||||
* |
||||
* - the output bytes will be passed to the system->write() function given in |
||||
* qtmd_init(), using the output file handle given in qtmd_init(). More |
||||
* than one call may be made to system->write() |
||||
* |
||||
* - Quantum will read input bytes as necessary using the system->read() |
||||
* function given in qtmd_init(), using the input file handle given in |
||||
* qtmd_init(). This will continue until system->read() returns 0 bytes, |
||||
* or an error. |
||||
*/ |
||||
extern int qtmd_decompress(struct qtmd_stream *qtm, off_t out_bytes); |
||||
|
||||
/* frees all state associated with a Quantum data stream
|
||||
* |
||||
* - calls system->free() using the system pointer given in qtmd_init() |
||||
*/ |
||||
void qtmd_free(struct qtmd_stream *qtm); |
||||
|
||||
#endif |
||||
@ -1,492 +0,0 @@ |
||||
/* This file is part of libmspack.
|
||||
* (C) 2003-2004 Stuart Caie. |
||||
* |
||||
* The Quantum method was created by David Stafford, adapted by Microsoft |
||||
* Corporation. |
||||
* |
||||
* This decompressor is based on an implementation by Matthew Russotto, used |
||||
* with permission. |
||||
* |
||||
* libmspack is free software; you can redistribute it and/or modify it under |
||||
* the terms of the GNU Lesser General Public License (LGPL) version 2.1 |
||||
* |
||||
* For further details, see the file COPYING.LIB distributed with libmspack |
||||
*/ |
||||
|
||||
/* Quantum decompression implementation */ |
||||
|
||||
/* This decompressor was researched and implemented by Matthew Russotto. It
|
||||
* has since been tidied up by Stuart Caie. More information can be found at |
||||
* http://www.speakeasy.org/~russotto/quantumcomp.html
|
||||
*/ |
||||
|
||||
#if HAVE_CONFIG_H |
||||
#include "clamav-config.h" |
||||
#endif |
||||
|
||||
#include <mspack.h> |
||||
#include <system.h> |
||||
#include <qtm.h> |
||||
|
||||
#include "others.h" |
||||
|
||||
/* Quantum decompressor bitstream reading macros
|
||||
* |
||||
* STORE_BITS stores bitstream state in qtmd_stream structure |
||||
* RESTORE_BITS restores bitstream state from qtmd_stream structure |
||||
* READ_BITS(var,n) takes N bits from the buffer and puts them in var |
||||
* FILL_BUFFER if there is room for another 16 bits, reads another |
||||
* 16 bits from the input stream. |
||||
* PEEK_BITS(n) extracts without removing N bits from the bit buffer |
||||
* REMOVE_BITS(n) removes N bits from the bit buffer |
||||
* |
||||
* These bit access routines work by using the area beyond the MSB and the |
||||
* LSB as a free source of zeroes. This avoids having to mask any bits. |
||||
* So we have to know the bit width of the bitbuffer variable. |
||||
*/ |
||||
|
||||
#ifdef HAVE_LIMITS_H |
||||
# include <limits.h> |
||||
#endif |
||||
#ifndef CHAR_BIT |
||||
# define CHAR_BIT (8) |
||||
#endif |
||||
#define BITBUF_WIDTH (sizeof(unsigned int) * CHAR_BIT) |
||||
|
||||
#define STORE_BITS do { \ |
||||
qtm->i_ptr = i_ptr; \
|
||||
qtm->i_end = i_end; \
|
||||
qtm->bit_buffer = bit_buffer; \
|
||||
qtm->bits_left = bits_left; \
|
||||
} while (0) |
||||
|
||||
#define RESTORE_BITS do { \ |
||||
i_ptr = qtm->i_ptr; \
|
||||
i_end = qtm->i_end; \
|
||||
bit_buffer = qtm->bit_buffer; \
|
||||
bits_left = qtm->bits_left; \
|
||||
} while (0) |
||||
|
||||
/* adds 16 bits to bit buffer, if there's space for the new bits */ |
||||
#define FILL_BUFFER do { \ |
||||
if (bits_left <= (BITBUF_WIDTH - 16)) { \
|
||||
if (i_ptr >= i_end) { \
|
||||
if (qtmd_read_input(qtm)) return qtm->error; \
|
||||
i_ptr = qtm->i_ptr; \
|
||||
i_end = qtm->i_end; \
|
||||
} \
|
||||
bit_buffer |= ((i_ptr[0] << 8) | i_ptr[1]) \
|
||||
<< (BITBUF_WIDTH - 16 - bits_left); \
|
||||
bits_left += 16; \
|
||||
i_ptr += 2; \
|
||||
} \
|
||||
} while (0) |
||||
|
||||
#define PEEK_BITS(n) (bit_buffer >> (BITBUF_WIDTH - (n))) |
||||
#define REMOVE_BITS(n) ((bit_buffer <<= (n)), (bits_left -= (n))) |
||||
|
||||
#define READ_BITS(val, bits) do { \ |
||||
(val) = 0; \
|
||||
for (bits_needed = (bits); bits_needed > 0; bits_needed -= bit_run) { \
|
||||
FILL_BUFFER; \
|
||||
bit_run = (bits_left < bits_needed) ? bits_left : bits_needed; \
|
||||
(val) = ((val) << bit_run) | PEEK_BITS(bit_run); \
|
||||
REMOVE_BITS(bit_run); \
|
||||
} \
|
||||
} while (0) |
||||
|
||||
static int qtmd_read_input(struct qtmd_stream *qtm) { |
||||
int read = qtm->sys->read(qtm->input, &qtm->inbuf[0], (int)qtm->inbuf_size); |
||||
if (read < 0) return qtm->error = MSPACK_ERR_READ; |
||||
|
||||
qtm->i_ptr = &qtm->inbuf[0]; |
||||
qtm->i_end = &qtm->inbuf[read]; |
||||
return MSPACK_ERR_OK; |
||||
} |
||||
|
||||
/* Quantum static data tables:
|
||||
* |
||||
* Quantum uses 'position slots' to represent match offsets. For every |
||||
* match, a small 'position slot' number and a small offset from that slot |
||||
* are encoded instead of one large offset. |
||||
* |
||||
* position_base[] is an index to the position slot bases |
||||
* |
||||
* extra_bits[] states how many bits of offset-from-base data is needed. |
||||
* |
||||
* length_base[] and length_extra[] are equivalent in function, but are |
||||
* used for encoding selector 6 (variable length match) match lengths, |
||||
* instead of match offsets. |
||||
*/ |
||||
static unsigned int position_base[42]; |
||||
static unsigned char extra_bits[42], length_base[27], length_extra[27]; |
||||
|
||||
static void qtmd_static_init(void) { |
||||
unsigned int i, offset; |
||||
|
||||
for (i = 0, offset = 0; i < 42; i++) { |
||||
position_base[i] = offset; |
||||
extra_bits[i] = ((i < 2) ? 0 : (i - 2)) >> 1; |
||||
offset += 1 << extra_bits[i]; |
||||
} |
||||
|
||||
for (i = 0, offset = 0; i < 26; i++) { |
||||
length_base[i] = offset; |
||||
length_extra[i] = (i < 2 ? 0 : i - 2) >> 2; |
||||
offset += 1 << length_extra[i]; |
||||
} |
||||
length_base[26] = 254; length_extra[26] = 0; |
||||
} |
||||
|
||||
|
||||
/* Arithmetic decoder:
|
||||
*
|
||||
* GET_SYMBOL(model, var) fetches the next symbol from the stated model |
||||
* and puts it in var. |
||||
* |
||||
* If necessary, qtmd_update_model() is called. |
||||
*/ |
||||
#define GET_SYMBOL(model, var) do { \ |
||||
range = ((H - L) & 0xFFFF) + 1; \
|
||||
symf = ((((C - L + 1) * model.syms[0].cumfreq)-1) / range) & 0xFFFF; \
|
||||
\
|
||||
for (i = 1; i < model.entries; i++) { \
|
||||
if (model.syms[i].cumfreq <= symf) break; \
|
||||
} \
|
||||
(var) = model.syms[i-1].sym; \
|
||||
\
|
||||
range = (H - L) + 1; \
|
||||
symf = model.syms[0].cumfreq; \
|
||||
H = L + ((model.syms[i-1].cumfreq * range) / symf) - 1; \
|
||||
L = L + ((model.syms[i].cumfreq * range) / symf); \
|
||||
\
|
||||
do { model.syms[--i].cumfreq += 8; } while (i > 0); \
|
||||
if (model.syms[0].cumfreq > 3800) qtmd_update_model(&model); \
|
||||
\
|
||||
while (1) { \
|
||||
if ((L & 0x8000) != (H & 0x8000)) { \
|
||||
if ((L & 0x4000) && !(H & 0x4000)) { \
|
||||
/* underflow case */ \
|
||||
C ^= 0x4000; L &= 0x3FFF; H |= 0x4000; \
|
||||
} \
|
||||
else break; \
|
||||
} \
|
||||
L <<= 1; H = (H << 1) | 1; \
|
||||
FILL_BUFFER; \
|
||||
C = (C << 1) | PEEK_BITS(1); \
|
||||
REMOVE_BITS(1); \
|
||||
} \
|
||||
} while (0) |
||||
|
||||
static void qtmd_update_model(struct qtmd_model *model) { |
||||
struct qtmd_modelsym tmp; |
||||
int i, j; |
||||
|
||||
if (--model->shiftsleft) { |
||||
for (i = model->entries - 1; i >= 0; i--) { |
||||
/* -1, not -2; the 0 entry saves this */ |
||||
model->syms[i].cumfreq >>= 1; |
||||
if (model->syms[i].cumfreq <= model->syms[i+1].cumfreq) { |
||||
model->syms[i].cumfreq = model->syms[i+1].cumfreq + 1; |
||||
} |
||||
} |
||||
} |
||||
else { |
||||
model->shiftsleft = 50; |
||||
for (i = 0; i < model->entries; i++) { |
||||
/* no -1, want to include the 0 entry */ |
||||
/* this converts cumfreqs into frequencies, then shifts right */ |
||||
model->syms[i].cumfreq -= model->syms[i+1].cumfreq; |
||||
model->syms[i].cumfreq++; /* avoid losing things entirely */ |
||||
model->syms[i].cumfreq >>= 1; |
||||
} |
||||
|
||||
/* now sort by frequencies, decreasing order -- this must be an
|
||||
* inplace selection sort, or a sort with the same (in)stability |
||||
* characteristics */ |
||||
for (i = 0; i < model->entries - 1; i++) { |
||||
for (j = i + 1; j < model->entries; j++) { |
||||
if (model->syms[i].cumfreq < model->syms[j].cumfreq) { |
||||
tmp = model->syms[i]; |
||||
model->syms[i] = model->syms[j]; |
||||
model->syms[j] = tmp; |
||||
} |
||||
} |
||||
} |
||||
|
||||
/* then convert frequencies back to cumfreq */ |
||||
for (i = model->entries - 1; i >= 0; i--) { |
||||
model->syms[i].cumfreq += model->syms[i+1].cumfreq; |
||||
} |
||||
} |
||||
} |
||||
|
||||
/* Initialises a model to decode symbols from [start] to [start]+[len]-1 */ |
||||
static void qtmd_init_model(struct qtmd_model *model, |
||||
struct qtmd_modelsym *syms, int start, int len) |
||||
{ |
||||
int i; |
||||
|
||||
model->shiftsleft = 4; |
||||
model->entries = len; |
||||
model->syms = syms; |
||||
|
||||
for (i = 0; i <= len; i++) { |
||||
syms[i].sym = start + i; /* actual symbol */ |
||||
syms[i].cumfreq = len - i; /* current frequency of that symbol */ |
||||
} |
||||
} |
||||
|
||||
|
||||
/*-------- main Quantum code --------*/ |
||||
|
||||
struct qtmd_stream *qtmd_init(struct mspack_system *system, |
||||
struct mspack_file *input, |
||||
struct mspack_file *output, |
||||
int window_bits, int input_buffer_size) |
||||
{ |
||||
unsigned int window_size = 1 << window_bits; |
||||
struct qtmd_stream *qtm; |
||||
int i; |
||||
|
||||
if (!system) return NULL; |
||||
|
||||
/* Quantum supports window sizes of 2^10 (1Kb) through 2^21 (2Mb) */ |
||||
|
||||
/* tk: temporary fix: only process 32KB+ window sizes */ |
||||
if (window_bits < 15 || window_bits > 21) return NULL; |
||||
|
||||
input_buffer_size = (input_buffer_size + 1) & -2; |
||||
if (input_buffer_size < 2) return NULL; |
||||
|
||||
/* initialise static data */ |
||||
qtmd_static_init(); |
||||
|
||||
/* allocate decompression state */ |
||||
if (!(qtm = system->alloc(system, sizeof(struct qtmd_stream)))) { |
||||
return NULL; |
||||
} |
||||
|
||||
/* allocate decompression window and input buffer */ |
||||
qtm->window = system->alloc(system, (size_t) window_size); |
||||
qtm->inbuf = system->alloc(system, (size_t) input_buffer_size); |
||||
if (!qtm->window || !qtm->inbuf) { |
||||
system->free(qtm->window); |
||||
system->free(qtm->inbuf); |
||||
system->free(qtm); |
||||
return NULL; |
||||
} |
||||
|
||||
/* initialise decompression state */ |
||||
qtm->sys = system; |
||||
qtm->input = input; |
||||
qtm->output = output; |
||||
qtm->inbuf_size = input_buffer_size; |
||||
qtm->window_size = window_size; |
||||
qtm->window_posn = 0; |
||||
qtm->frame_start = 0; |
||||
qtm->header_read = 0; |
||||
qtm->error = MSPACK_ERR_OK; |
||||
|
||||
qtm->i_ptr = qtm->i_end = &qtm->inbuf[0]; |
||||
qtm->o_ptr = qtm->o_end = &qtm->window[0]; |
||||
qtm->bits_left = 0; |
||||
qtm->bit_buffer = 0; |
||||
|
||||
/* initialise arithmetic coding models
|
||||
* - model 4 depends on window size, ranges from 20 to 24 |
||||
* - model 5 depends on window size, ranges from 20 to 36 |
||||
* - model 6pos depends on window size, ranges from 20 to 42 |
||||
*/ |
||||
i = window_bits * 2; |
||||
qtmd_init_model(&qtm->model0, &qtm->m0sym[0], 0, 64); |
||||
qtmd_init_model(&qtm->model1, &qtm->m1sym[0], 64, 64); |
||||
qtmd_init_model(&qtm->model2, &qtm->m2sym[0], 128, 64); |
||||
qtmd_init_model(&qtm->model3, &qtm->m3sym[0], 192, 64); |
||||
qtmd_init_model(&qtm->model4, &qtm->m4sym[0], 0, (i > 24) ? 24 : i); |
||||
qtmd_init_model(&qtm->model5, &qtm->m5sym[0], 0, (i > 36) ? 36 : i); |
||||
qtmd_init_model(&qtm->model6, &qtm->m6sym[0], 0, i); |
||||
qtmd_init_model(&qtm->model6len, &qtm->m6lsym[0], 0, 27); |
||||
qtmd_init_model(&qtm->model7, &qtm->m7sym[0], 0, 7); |
||||
|
||||
/* all ok */ |
||||
return qtm; |
||||
} |
||||
|
||||
int qtmd_decompress(struct qtmd_stream *qtm, off_t out_bytes) { |
||||
unsigned int frame_start, frame_end, window_posn, match_offset, range; |
||||
unsigned char *window, *i_ptr, *i_end, *runsrc, *rundest; |
||||
int i, j, selector, extra, sym, match_length; |
||||
unsigned short H, L, C, symf; |
||||
|
||||
register unsigned int bit_buffer; |
||||
register unsigned char bits_left; |
||||
unsigned char bits_needed, bit_run; |
||||
|
||||
/* easy answers */ |
||||
if (!qtm || (out_bytes < 0)) return MSPACK_ERR_ARGS; |
||||
if (qtm->error) return qtm->error; |
||||
|
||||
/* flush out any stored-up bytes before we begin */ |
||||
i = qtm->o_end - qtm->o_ptr; |
||||
if ((off_t) i > out_bytes) i = (int) out_bytes; |
||||
if (i) { |
||||
if (qtm->sys->write(qtm->output, qtm->o_ptr, i) != i) { |
||||
return qtm->error = MSPACK_ERR_WRITE; |
||||
} |
||||
qtm->o_ptr += i; |
||||
out_bytes -= i; |
||||
} |
||||
if (out_bytes == 0) return MSPACK_ERR_OK; |
||||
|
||||
/* restore local state */ |
||||
RESTORE_BITS; |
||||
window = qtm->window; |
||||
window_posn = qtm->window_posn; |
||||
frame_start = qtm->frame_start; |
||||
H = qtm->H; |
||||
L = qtm->L; |
||||
C = qtm->C; |
||||
|
||||
/* while we do not have enough decoded bytes in reserve: */ |
||||
while ((qtm->o_end - qtm->o_ptr) < out_bytes) { |
||||
|
||||
/* read header if necessary. Initialises H, L and C */ |
||||
if (!qtm->header_read) { |
||||
H = 0xFFFF; L = 0; READ_BITS(C, 16); |
||||
qtm->header_read = 1; |
||||
} |
||||
|
||||
/* decode more, at most up to to frame boundary */ |
||||
frame_end = window_posn + (out_bytes - (qtm->o_end - qtm->o_ptr)); |
||||
if ((frame_start + QTM_FRAME_SIZE) < frame_end) { |
||||
frame_end = frame_start + QTM_FRAME_SIZE; |
||||
} |
||||
|
||||
while (window_posn < frame_end) { |
||||
GET_SYMBOL(qtm->model7, selector); |
||||
if (selector < 4) { |
||||
struct qtmd_model *mdl = (selector == 0) ? &qtm->model0 : |
||||
((selector == 1) ? &qtm->model1 : |
||||
((selector == 2) ? &qtm->model2 : |
||||
&qtm->model3)); |
||||
GET_SYMBOL((*mdl), sym); |
||||
window[window_posn++] = sym; |
||||
} |
||||
else { |
||||
switch (selector) { |
||||
case 4: /* selector 4 = fixed length match (3 bytes) */ |
||||
GET_SYMBOL(qtm->model4, sym); |
||||
READ_BITS(extra, extra_bits[sym]); |
||||
match_offset = position_base[sym] + extra + 1; |
||||
match_length = 3; |
||||
break; |
||||
|
||||
case 5: /* selector 5 = fixed length match (4 bytes) */ |
||||
GET_SYMBOL(qtm->model5, sym); |
||||
READ_BITS(extra, extra_bits[sym]); |
||||
match_offset = position_base[sym] + extra + 1; |
||||
match_length = 4; |
||||
break; |
||||
|
||||
case 6: /* selector 6 = variable length match */ |
||||
GET_SYMBOL(qtm->model6len, sym); |
||||
READ_BITS(extra, length_extra[sym]); |
||||
match_length = length_base[sym] + extra + 5; |
||||
|
||||
GET_SYMBOL(qtm->model6, sym); |
||||
READ_BITS(extra, extra_bits[sym]); |
||||
match_offset = position_base[sym] + extra + 1; |
||||
break; |
||||
|
||||
default: |
||||
/* should be impossible, model7 can only return 0-6 */ |
||||
return qtm->error = MSPACK_ERR_DECRUNCH; |
||||
} |
||||
|
||||
rundest = &window[window_posn]; |
||||
i = match_length; |
||||
/* does match offset wrap the window? */ |
||||
if (match_offset > window_posn) { |
||||
/* j = length from match offset to end of window */ |
||||
j = match_offset - window_posn; |
||||
if (j > (int) qtm->window_size) { |
||||
D(("match offset beyond window boundaries")) |
||||
return qtm->error = MSPACK_ERR_DECRUNCH; |
||||
} |
||||
runsrc = &window[qtm->window_size - j]; |
||||
if (j < i) { |
||||
/* if match goes over the window edge, do two copy runs */ |
||||
i -= j; while (j-- > 0) *rundest++ = *runsrc++; |
||||
runsrc = window; |
||||
} |
||||
while (i-- > 0) *rundest++ = *runsrc++; |
||||
} |
||||
else { |
||||
runsrc = rundest - match_offset; |
||||
while (i-- > 0) *rundest++ = *runsrc++; |
||||
} |
||||
window_posn += match_length; |
||||
} |
||||
} /* while (window_posn < frame_end) */ |
||||
|
||||
qtm->o_end = &window[window_posn]; |
||||
|
||||
/* another frame completed? */ |
||||
if ((window_posn - frame_start) >= QTM_FRAME_SIZE) { |
||||
if ((window_posn - frame_start) != QTM_FRAME_SIZE) { |
||||
D(("overshot frame alignment")) |
||||
return qtm->error = MSPACK_ERR_DECRUNCH; |
||||
} |
||||
|
||||
/* re-align input */ |
||||
if (bits_left & 7) REMOVE_BITS(bits_left & 7); |
||||
do { READ_BITS(i, 8); } while (i != 0xFF); |
||||
qtm->header_read = 0; |
||||
|
||||
/* window wrap? */ |
||||
if (window_posn == qtm->window_size) { |
||||
/* flush all currently stored data */ |
||||
i = (qtm->o_end - qtm->o_ptr); |
||||
if (qtm->sys->write(qtm->output, qtm->o_ptr, i) != i) { |
||||
return qtm->error = MSPACK_ERR_WRITE; |
||||
} |
||||
out_bytes -= i; |
||||
qtm->o_ptr = &window[0]; |
||||
qtm->o_end = &window[0]; |
||||
window_posn = 0; |
||||
} |
||||
|
||||
frame_start = window_posn; |
||||
} |
||||
|
||||
} /* while (more bytes needed) */ |
||||
|
||||
if (out_bytes) { |
||||
i = (int) out_bytes; |
||||
if (qtm->sys->write(qtm->output, qtm->o_ptr, i) != i) { |
||||
return qtm->error = MSPACK_ERR_WRITE; |
||||
} |
||||
qtm->o_ptr += i; |
||||
} |
||||
|
||||
/* store local state */ |
||||
STORE_BITS; |
||||
qtm->window_posn = window_posn; |
||||
qtm->frame_start = frame_start; |
||||
qtm->H = H; |
||||
qtm->L = L; |
||||
qtm->C = C; |
||||
|
||||
return MSPACK_ERR_OK; |
||||
} |
||||
|
||||
void qtmd_free(struct qtmd_stream *qtm) { |
||||
struct mspack_system *sys; |
||||
if (qtm) { |
||||
sys = qtm->sys; |
||||
sys->free(qtm->window); |
||||
sys->free(qtm->inbuf); |
||||
sys->free(qtm); |
||||
} |
||||
} |
||||
@ -1,252 +0,0 @@ |
||||
/* This file is part of libmspack.
|
||||
* (C) 2003-2004 Stuart Caie. |
||||
* |
||||
* libmspack is free software; you can redistribute it and/or modify it under |
||||
* the terms of the GNU Lesser General Public License (LGPL) version 2.1 |
||||
* |
||||
* For further details, see the file COPYING.LIB distributed with libmspack |
||||
*/ |
||||
|
||||
#if HAVE_CONFIG_H |
||||
#include "clamav-config.h" |
||||
#endif |
||||
|
||||
#include <mspack.h> |
||||
#include "others.h" |
||||
#include "system.h" |
||||
|
||||
int mspack_version(int entity) { |
||||
switch (entity) { |
||||
case MSPACK_VER_LIBRARY: |
||||
case MSPACK_VER_SYSTEM: |
||||
case MSPACK_VER_MSCABD: |
||||
case MSPACK_VER_MSCHMD: |
||||
return 1; |
||||
case MSPACK_VER_MSCABC: |
||||
case MSPACK_VER_MSCHMC: |
||||
case MSPACK_VER_MSLITD: |
||||
case MSPACK_VER_MSLITC: |
||||
case MSPACK_VER_MSHLPD: |
||||
case MSPACK_VER_MSHLPC: |
||||
case MSPACK_VER_MSSZDDD: |
||||
case MSPACK_VER_MSSZDDC: |
||||
case MSPACK_VER_MSKWAJD: |
||||
case MSPACK_VER_MSKWAJC: |
||||
return 0; |
||||
} |
||||
return -1; |
||||
} |
||||
|
||||
int mspack_sys_selftest_internal(int offt_size) { |
||||
return (sizeof(off_t) == offt_size) ? MSPACK_ERR_OK : MSPACK_ERR_SEEK; |
||||
} |
||||
|
||||
/* validates a system structure */ |
||||
int mspack_valid_system(struct mspack_system *sys) { |
||||
return (sys != NULL) && (sys->open != NULL) && (sys->close != NULL) && |
||||
(sys->read != NULL) && (sys->write != NULL) && (sys->seek != NULL) && |
||||
(sys->tell != NULL) && (sys->message != NULL) && (sys->alloc != NULL) && |
||||
(sys->free != NULL) && (sys->copy != NULL) && (sys->null_ptr == NULL); |
||||
} |
||||
|
||||
/* returns the length of a file opened for reading */ |
||||
int mspack_sys_filelen(struct mspack_system *system, |
||||
struct mspack_file *file, off_t *length) |
||||
{ |
||||
off_t current; |
||||
|
||||
if (!system || !file || !length) return MSPACK_ERR_OPEN; |
||||
|
||||
/* get current offset */ |
||||
current = system->tell(file); |
||||
|
||||
/* seek to end of file */ |
||||
if (system->seek(file, (off_t) 0, MSPACK_SYS_SEEK_END)) { |
||||
return MSPACK_ERR_SEEK; |
||||
} |
||||
|
||||
/* get offset of end of file */ |
||||
*length = system->tell(file); |
||||
|
||||
/* seek back to original offset */ |
||||
if (system->seek(file, current, MSPACK_SYS_SEEK_START)) { |
||||
return MSPACK_ERR_SEEK; |
||||
} |
||||
|
||||
return MSPACK_ERR_OK; |
||||
} |
||||
|
||||
|
||||
|
||||
/* definition of mspack_default_system -- if the library is compiled with
|
||||
* MSPACK_NO_DEFAULT_SYSTEM, no default system will be provided. Otherwise, |
||||
* an appropriate default system (e.g. the standard C library, or some native |
||||
* API calls) |
||||
*/ |
||||
|
||||
#ifdef MSPACK_NO_DEFAULT_SYSTEM |
||||
struct mspack_system *mspack_default_system = NULL; |
||||
#else |
||||
|
||||
/* implementation of mspack_default_system for standard C library */ |
||||
|
||||
#include <stdio.h> |
||||
#include <stdlib.h> |
||||
#include <string.h> |
||||
#include <stdarg.h> |
||||
|
||||
struct mspack_file_p { |
||||
FILE *fh; |
||||
const char *name; |
||||
int desc; |
||||
}; |
||||
|
||||
static struct mspack_file *msp_open(struct mspack_system *this, |
||||
char *filename, int mode) |
||||
{ |
||||
struct mspack_file_p *fh; |
||||
char *fmode; |
||||
|
||||
switch (mode) { |
||||
case MSPACK_SYS_OPEN_READ: fmode = "rb"; break; |
||||
case MSPACK_SYS_OPEN_WRITE: fmode = "wb"; break; |
||||
case MSPACK_SYS_OPEN_UPDATE: fmode = "r+b"; break; |
||||
case MSPACK_SYS_OPEN_APPEND: fmode = "ab"; break; |
||||
default: return NULL; |
||||
} |
||||
|
||||
if ((fh = cli_malloc(sizeof(struct mspack_file_p)))) { |
||||
fh->name = filename; |
||||
fh->desc = 0; |
||||
if ((fh->fh = fopen(filename, fmode))) return (struct mspack_file *) fh; |
||||
free(fh); |
||||
} |
||||
return NULL; |
||||
} |
||||
|
||||
static struct mspack_file *msp_dopen(struct mspack_system *this, |
||||
int desc, int mode) |
||||
{ |
||||
struct mspack_file_p *fh; |
||||
char *fmode; |
||||
|
||||
switch (mode) { |
||||
case MSPACK_SYS_OPEN_READ: fmode = "rb"; break; |
||||
case MSPACK_SYS_OPEN_WRITE: fmode = "wb"; break; |
||||
case MSPACK_SYS_OPEN_UPDATE: fmode = "r+b"; break; |
||||
case MSPACK_SYS_OPEN_APPEND: fmode = "ab"; break; |
||||
default: return NULL; |
||||
} |
||||
|
||||
if ((fh = cli_malloc(sizeof(struct mspack_file_p)))) { |
||||
fh->name = "descriptor"; |
||||
fh->desc = dup(desc); |
||||
if ((fh->fh = fdopen(fh->desc, fmode))) return (struct mspack_file *) fh; |
||||
free(fh); |
||||
} |
||||
return NULL; |
||||
} |
||||
|
||||
static void msp_close(struct mspack_file *file) { |
||||
struct mspack_file_p *this = (struct mspack_file_p *) file; |
||||
if (this) { |
||||
fclose(this->fh); |
||||
free(this); |
||||
} |
||||
} |
||||
|
||||
static int msp_read(struct mspack_file *file, void *buffer, int bytes) { |
||||
struct mspack_file_p *this = (struct mspack_file_p *) file; |
||||
if (this) { |
||||
size_t count = fread(buffer, 1, (size_t) bytes, this->fh); |
||||
if (!ferror(this->fh)) return (int) count; |
||||
} |
||||
return -1; |
||||
} |
||||
|
||||
static int msp_write(struct mspack_file *file, void *buffer, int bytes) { |
||||
struct mspack_file_p *this = (struct mspack_file_p *) file; |
||||
if (this) { |
||||
size_t count = fwrite(buffer, 1, (size_t) bytes, this->fh); |
||||
if (!ferror(this->fh)) return (int) count; |
||||
} |
||||
return -1; |
||||
} |
||||
|
||||
static int msp_seek(struct mspack_file *file, off_t offset, int mode) { |
||||
struct mspack_file_p *this = (struct mspack_file_p *) file; |
||||
if (this) { |
||||
switch (mode) { |
||||
case MSPACK_SYS_SEEK_START: mode = SEEK_SET; break; |
||||
case MSPACK_SYS_SEEK_CUR: mode = SEEK_CUR; break; |
||||
case MSPACK_SYS_SEEK_END: mode = SEEK_END; break; |
||||
default: return -1; |
||||
} |
||||
#ifdef HAVE_FSEEKO |
||||
return fseeko(this->fh, offset, mode); |
||||
#else |
||||
return fseek(this->fh, offset, mode); |
||||
#endif |
||||
} |
||||
return -1; |
||||
} |
||||
|
||||
static off_t msp_tell(struct mspack_file *file) { |
||||
struct mspack_file_p *this = (struct mspack_file_p *) file; |
||||
#ifdef HAVE_FSEEKO |
||||
return (this) ? (off_t) ftello(this->fh) : 0; |
||||
#else |
||||
return (this) ? (off_t) ftell(this->fh) : 0; |
||||
#endif |
||||
} |
||||
|
||||
static void msp_msg(struct mspack_file *file, char *format, ...) { |
||||
va_list ap; |
||||
char buff[512]; |
||||
|
||||
va_start(ap, format); |
||||
vsnprintf(buff, 512, format, ap); |
||||
va_end(ap); |
||||
cli_dbgmsg("libmspack: %s\n", buff); |
||||
} |
||||
|
||||
static void *msp_alloc(struct mspack_system *this, size_t bytes) { |
||||
#ifdef DEBUG |
||||
/* make uninitialised data obvious */ |
||||
char *buf = cli_malloc(bytes + 8); |
||||
if (buf) memset(buf, 0xDC, bytes); |
||||
*((size_t *)buf) = bytes; |
||||
return &buf[8]; |
||||
#else |
||||
return cli_calloc(bytes, 1); |
||||
#endif |
||||
} |
||||
|
||||
static void msp_free(void *buffer) { |
||||
#ifdef DEBUG |
||||
char *buf = buffer; |
||||
size_t bytes; |
||||
if (buf) { |
||||
buf -= 8; |
||||
bytes = *((size_t *)buf); |
||||
/* make freed data obvious */ |
||||
memset(buf, 0xED, bytes); |
||||
free(buf); |
||||
} |
||||
#else |
||||
free(buffer); |
||||
#endif |
||||
} |
||||
|
||||
static void msp_copy(void *src, void *dest, size_t bytes) { |
||||
memcpy(dest, src, bytes); |
||||
} |
||||
|
||||
static struct mspack_system msp_system = { |
||||
&msp_open, &msp_dopen, &msp_close, &msp_read, &msp_write, &msp_seek, |
||||
&msp_tell, &msp_msg, &msp_alloc, &msp_free, &msp_copy, NULL |
||||
}; |
||||
|
||||
struct mspack_system *mspack_default_system = &msp_system; |
||||
|
||||
#endif |
||||
@ -1,60 +0,0 @@ |
||||
/* This file is part of libmspack.
|
||||
* (C) 2003-2004 Stuart Caie. |
||||
* |
||||
* libmspack is free software; you can redistribute it and/or modify it under |
||||
* the terms of the GNU Lesser General Public License (LGPL) version 2.1 |
||||
* |
||||
* For further details, see the file COPYING.LIB distributed with libmspack |
||||
*/ |
||||
|
||||
#ifndef MSPACK_SYSTEM_H |
||||
#define MSPACK_SYSTEM_H 1 |
||||
|
||||
#ifdef DEBUG |
||||
# include <stdio.h> |
||||
# define D(x) do { printf("%s:%d (%s) ",__FILE__, __LINE__, __FUNCTION__); \ |
||||
printf x ; fputc('\n', stdout); fflush(stdout);} while (0); |
||||
#else |
||||
# define D(x) cli_dbgmsg x ; |
||||
#endif |
||||
|
||||
/* endian-neutral reading of little-endian data */ |
||||
#define __egi32(a,n) ( (((a)[n+3]) << 24) | (((a)[n+2]) << 16) | \ |
||||
(((a)[n+1]) << 8) | ((a)[n+0]) ) |
||||
#define EndGetI64(a) ((((unsigned long long int) __egi32(a,4)) << 32) | \ |
||||
((unsigned int) __egi32(a,0))) |
||||
#define EndGetI32(a) __egi32(a,0) |
||||
#define EndGetI16(a) ((((a)[1])<<8)|((a)[0])) |
||||
|
||||
/* endian-neutral reading of big-endian data */ |
||||
#define EndGetM32(a) ((((a)[0])<<24)|(((a)[1])<<16)|(((a)[2])<<8)|((a)[3])) |
||||
#define EndGetM16(a) ((((a)[0])<<8)|((a)[1])) |
||||
|
||||
extern struct mspack_system *mspack_default_system; |
||||
|
||||
/* returns the length of a file opened for reading */ |
||||
extern int mspack_sys_filelen(struct mspack_system *system, |
||||
struct mspack_file *file, off_t *length); |
||||
|
||||
/* validates a system structure */ |
||||
extern int mspack_valid_system(struct mspack_system *sys); |
||||
|
||||
/* inline memcmp() */ |
||||
#ifndef C_WINDOWS |
||||
static inline int memcmp(const void *s1, const void *s2, size_t n) { |
||||
unsigned char *c1 = (unsigned char *) s1; |
||||
unsigned char *c2 = (unsigned char *) s2; |
||||
if (n == 0) return 0; |
||||
while (--n && (*c1 == *c2)) c1++, c2++; |
||||
return *c1 - *c2; |
||||
} |
||||
|
||||
/* inline strlen() */ |
||||
static inline size_t strlen(const char *s) { |
||||
const char *e = s; |
||||
while (*e) e++; |
||||
return e - s; |
||||
} |
||||
#endif |
||||
|
||||
#endif |
||||
Loading…
Reference in new issue