Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2024-12-28 01:55:19 +00:00
Code Issues Projects Releases Packages Wiki Activity

Sync to Wine-20050725:

Browse source 
Francois Gouget <fgouget@free.fr>
- Assorted spelling fixes.
Gerold Jens Wucherpfennig <gjwucherpfennig@gmx.net>
- Support for big-endian systems.
- The fci_get_little_endian... and fci_set_little_endian... functions
  don't really set and unset little endianes, they do the same thing:
  merely swapping bytes from one endianes to the other.
Stefan Huehner <stefan@huehner.org>
- Make some function static.
- Fix some more -Wmissing-declarations warnings.

svn path=/trunk/; revision=17290
This commit is contained in:
Gé van Geldorp 2005-08-11 18:49:40 +00:00
parent fbdd1961c7
commit 9bfc144257
3 changed files with 144 additions and 64 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

72
reactos/lib/cabinet/cabextract.c
View file

@ -51,7 +51,7 @@ THOSE_ZIP_CONSTS;
*/ */
/* try to open a cabinet file, returns success */ /* try to open a cabinet file, returns success */
BOOL cabinet_open(struct cabinet *cab) static BOOL cabinet_open(struct cabinet *cab)
{ {
const char *name = cab->filename; const char *name = cab->filename;
HANDLE fh; HANDLE fh;
@ -89,7 +89,7 @@ BOOL cabinet_open(struct cabinet *cab)
* *
* close the file handle in a struct cabinet. * close the file handle in a struct cabinet.
*/ */
void cabinet_close(struct cabinet *cab) { static void cabinet_close(struct cabinet *cab) {
TRACE("(cab == ^%p)\n", cab); TRACE("(cab == ^%p)\n", cab);
if (cab->fh) CloseHandle(cab->fh); if (cab->fh) CloseHandle(cab->fh);
cab->fh = 0; cab->fh = 0;
@ -98,7 +98,7 @@ void cabinet_close(struct cabinet *cab) {
/******************************************************* /*******************************************************
* ensure_filepath2 (internal) * ensure_filepath2 (internal)
*/ */
BOOL ensure_filepath2(char *path) { static BOOL ensure_filepath2(char *path) {
BOOL ret = TRUE; BOOL ret = TRUE;
int len; int len;
char *new_path; char *new_path;
@ -147,7 +147,7 @@ BOOL ensure_filepath2(char *path) {
* *
* ensure_filepath("a\b\c\d.txt") ensures a, a\b and a\b\c exist as dirs * ensure_filepath("a\b\c\d.txt") ensures a, a\b and a\b\c exist as dirs
*/ */
BOOL ensure_filepath(char *path) { static BOOL ensure_filepath(char *path) {
char new_path[MAX_PATH]; char new_path[MAX_PATH];
int len, i, lastslashpos = -1; int len, i, lastslashpos = -1;
@ -176,7 +176,7 @@ BOOL ensure_filepath(char *path) {
* *
* opens a file for output, returns success * opens a file for output, returns success
*/ */
BOOL file_open(struct cab_file *fi, BOOL lower, LPCSTR dir) static BOOL file_open(struct cab_file *fi, BOOL lower, LPCSTR dir)
{ {
char c, *d, *name; char c, *d, *name;
BOOL ok = FALSE; BOOL ok = FALSE;
@ -239,7 +239,7 @@ BOOL file_open(struct cab_file *fi, BOOL lower, LPCSTR dir)
* *
* closes a completed file * closes a completed file
*/ */
void file_close(struct cab_file *fi) static void file_close(struct cab_file *fi)
{ {
TRACE("(fi == ^%p)\n", fi); TRACE("(fi == ^%p)\n", fi);
@ -255,7 +255,7 @@ void file_close(struct cab_file *fi)
* writes from buf to a file specified as a cab_file struct. * writes from buf to a file specified as a cab_file struct.
* returns success/failure * returns success/failure
*/ */
BOOL file_write(struct cab_file *fi, cab_UBYTE *buf, cab_off_t length) static BOOL file_write(struct cab_file *fi, cab_UBYTE *buf, cab_off_t length)
{ {
DWORD bytes_written; DWORD bytes_written;
@ -276,7 +276,7 @@ BOOL file_write(struct cab_file *fi, cab_UBYTE *buf, cab_off_t length)
* advance the file pointer associated with the cab structure * advance the file pointer associated with the cab structure
* by distance bytes * by distance bytes
*/ */
void cabinet_skip(struct cabinet *cab, cab_off_t distance) static void cabinet_skip(struct cabinet *cab, cab_off_t distance)
{ {
TRACE("(cab == ^%p, distance == %u)\n", cab, distance); TRACE("(cab == ^%p, distance == %u)\n", cab, distance);
if (SetFilePointer(cab->fh, distance, NULL, FILE_CURRENT) == INVALID_SET_FILE_POINTER) { if (SetFilePointer(cab->fh, distance, NULL, FILE_CURRENT) == INVALID_SET_FILE_POINTER) {
@ -290,7 +290,7 @@ void cabinet_skip(struct cabinet *cab, cab_off_t distance)
* *
* seek to the specified absolute offset in a cab * seek to the specified absolute offset in a cab
*/ */
void cabinet_seek(struct cabinet *cab, cab_off_t offset) { static void cabinet_seek(struct cabinet *cab, cab_off_t offset) {
TRACE("(cab == ^%p, offset == %u)\n", cab, offset); TRACE("(cab == ^%p, offset == %u)\n", cab, offset);
if (SetFilePointer(cab->fh, offset, NULL, FILE_BEGIN) != offset) if (SetFilePointer(cab->fh, offset, NULL, FILE_BEGIN) != offset)
ERR("%s seek failure\n", debugstr_a(cab->filename)); ERR("%s seek failure\n", debugstr_a(cab->filename));
@ -301,7 +301,7 @@ void cabinet_seek(struct cabinet *cab, cab_off_t offset) {
* *
* returns the file pointer position of a cab * returns the file pointer position of a cab
*/ */
cab_off_t cabinet_getoffset(struct cabinet *cab) static cab_off_t cabinet_getoffset(struct cabinet *cab)
{ {
return SetFilePointer(cab->fh, 0, NULL, FILE_CURRENT); return SetFilePointer(cab->fh, 0, NULL, FILE_CURRENT);
} }
@ -311,7 +311,7 @@ cab_off_t cabinet_getoffset(struct cabinet *cab)
* *
* read data from a cabinet, returns success * read data from a cabinet, returns success
*/ */
BOOL cabinet_read(struct cabinet *cab, cab_UBYTE *buf, cab_off_t length) static BOOL cabinet_read(struct cabinet *cab, cab_UBYTE *buf, cab_off_t length)
{ {
DWORD bytes_read; DWORD bytes_read;
cab_off_t avail = cab->filelen - cabinet_getoffset(cab); cab_off_t avail = cab->filelen - cabinet_getoffset(cab);
@ -339,7 +339,7 @@ BOOL cabinet_read(struct cabinet *cab, cab_UBYTE *buf, cab_off_t length)
* *
* allocate and read an aribitrarily long string from the cabinet * allocate and read an aribitrarily long string from the cabinet
*/ */
char *cabinet_read_string(struct cabinet *cab) static char *cabinet_read_string(struct cabinet *cab)
{ {
cab_off_t len=256, base = cabinet_getoffset(cab), maxlen = cab->filelen - base; cab_off_t len=256, base = cabinet_getoffset(cab), maxlen = cab->filelen - base;
BOOL ok = FALSE; BOOL ok = FALSE;
@ -387,7 +387,7 @@ char *cabinet_read_string(struct cabinet *cab)
* *
* reads the header and all folder and file entries in this cabinet * reads the header and all folder and file entries in this cabinet
*/ */
BOOL cabinet_read_entries(struct cabinet *cab) static BOOL cabinet_read_entries(struct cabinet *cab)
{ {
int num_folders, num_files, header_resv, folder_resv = 0, i; int num_folders, num_files, header_resv, folder_resv = 0, i;
struct cab_folder *fol, *linkfol = NULL; struct cab_folder *fol, *linkfol = NULL;
@ -525,7 +525,7 @@ BOOL cabinet_read_entries(struct cabinet *cab)
* file [name]. Returns a cabinet structure if successful, or NULL * file [name]. Returns a cabinet structure if successful, or NULL
* otherwise. * otherwise.
*/ */
struct cabinet *load_cab_offset(LPCSTR name, cab_off_t offset) static struct cabinet *load_cab_offset(LPCSTR name, cab_off_t offset)
{ {
struct cabinet *cab = (struct cabinet *) calloc(1, sizeof(struct cabinet)); struct cabinet *cab = (struct cabinet *) calloc(1, sizeof(struct cabinet));
int ok; int ok;
@ -553,7 +553,7 @@ struct cabinet *load_cab_offset(LPCSTR name, cab_off_t offset)
/******************************************************** /********************************************************
* Ziphuft_free (internal) * Ziphuft_free (internal)
*/ */
void Ziphuft_free(struct Ziphuft *t) static void Ziphuft_free(struct Ziphuft *t)
{ {
register struct Ziphuft *p, *q; register struct Ziphuft *p, *q;
@ -570,7 +570,7 @@ void Ziphuft_free(struct Ziphuft *t)
/********************************************************* /*********************************************************
* Ziphuft_build (internal) * Ziphuft_build (internal)
*/ */
cab_LONG Ziphuft_build(cab_ULONG *b, cab_ULONG n, cab_ULONG s, cab_UWORD *d, cab_UWORD *e, static cab_LONG Ziphuft_build(cab_ULONG *b, cab_ULONG n, cab_ULONG s, cab_UWORD *d, cab_UWORD *e,
struct Ziphuft **t, cab_LONG *m, cab_decomp_state *decomp_state) struct Ziphuft **t, cab_LONG *m, cab_decomp_state *decomp_state)
{ {
cab_ULONG a; /* counter for codes of length k */ cab_ULONG a; /* counter for codes of length k */
@ -750,7 +750,7 @@ struct Ziphuft **t, cab_LONG *m, cab_decomp_state *decomp_state)
/********************************************************* /*********************************************************
* Zipinflate_codes (internal) * Zipinflate_codes (internal)
*/ */
cab_LONG Zipinflate_codes(struct Ziphuft *tl, struct Ziphuft *td, static cab_LONG Zipinflate_codes(struct Ziphuft *tl, struct Ziphuft *td,
cab_LONG bl, cab_LONG bd, cab_decomp_state *decomp_state) cab_LONG bl, cab_LONG bd, cab_decomp_state *decomp_state)
{ {
register cab_ULONG e; /* table entry flag/number of extra bits */ register cab_ULONG e; /* table entry flag/number of extra bits */
@ -833,7 +833,7 @@ cab_LONG Zipinflate_codes(struct Ziphuft *tl, struct Ziphuft *td,
/*********************************************************** /***********************************************************
* Zipinflate_stored (internal) * Zipinflate_stored (internal)
*/ */
cab_LONG Zipinflate_stored(cab_decomp_state *decomp_state) static cab_LONG Zipinflate_stored(cab_decomp_state *decomp_state)
/* "decompress" an inflated type 0 (stored) block. */ /* "decompress" an inflated type 0 (stored) block. */
{ {
cab_ULONG n; /* number of bytes in block */ cab_ULONG n; /* number of bytes in block */
@ -877,7 +877,7 @@ cab_LONG Zipinflate_stored(cab_decomp_state *decomp_state)
/****************************************************** /******************************************************
* Zipinflate_fixed (internal) * Zipinflate_fixed (internal)
*/ */
cab_LONG Zipinflate_fixed(cab_decomp_state *decomp_state) static cab_LONG Zipinflate_fixed(cab_decomp_state *decomp_state)
{ {
struct Ziphuft *fixed_tl; struct Ziphuft *fixed_tl;
struct Ziphuft *fixed_td; struct Ziphuft *fixed_td;
@ -923,7 +923,7 @@ cab_LONG Zipinflate_fixed(cab_decomp_state *decomp_state)
/************************************************************** /**************************************************************
* Zipinflate_dynamic (internal) * Zipinflate_dynamic (internal)
*/ */
cab_LONG Zipinflate_dynamic(cab_decomp_state *decomp_state) static cab_LONG Zipinflate_dynamic(cab_decomp_state *decomp_state)
/* decompress an inflated type 2 (dynamic Huffman codes) block. */ /* decompress an inflated type 2 (dynamic Huffman codes) block. */
{ {
cab_LONG i; /* temporary variables */ cab_LONG i; /* temporary variables */
@ -1058,7 +1058,7 @@ cab_LONG Zipinflate_dynamic(cab_decomp_state *decomp_state)
/***************************************************** /*****************************************************
* Zipinflate_block (internal) * Zipinflate_block (internal)
*/ */
cab_LONG Zipinflate_block(cab_LONG *e, cab_decomp_state *decomp_state) /* e == last block flag */ static cab_LONG Zipinflate_block(cab_LONG *e, cab_decomp_state *decomp_state) /* e == last block flag */
{ /* decompress an inflated block */ { /* decompress an inflated block */
cab_ULONG t; /* block type */ cab_ULONG t; /* block type */
register cab_ULONG b; /* bit buffer */ register cab_ULONG b; /* bit buffer */
@ -1096,7 +1096,7 @@ cab_LONG Zipinflate_block(cab_LONG *e, cab_decomp_state *decomp_state) /* e == l
/**************************************************** /****************************************************
* ZIPdecompress (internal) * ZIPdecompress (internal)
*/ */
int ZIPdecompress(int inlen, int outlen, cab_decomp_state *decomp_state) static int ZIPdecompress(int inlen, int outlen, cab_decomp_state *decomp_state)
{ {
cab_LONG e; /* last block flag */ cab_LONG e; /* last block flag */
@ -1132,7 +1132,7 @@ int ZIPdecompress(int inlen, int outlen, cab_decomp_state *decomp_state)
* *
* Initialise a model which decodes symbols from [s] to [s]+[n]-1 * Initialise a model which decodes symbols from [s] to [s]+[n]-1
*/ */
void QTMinitmodel(struct QTMmodel *m, struct QTMmodelsym *sym, int n, int s) { static void QTMinitmodel(struct QTMmodel *m, struct QTMmodelsym *sym, int n, int s) {
int i; int i;
m->shiftsleft = 4; m->shiftsleft = 4;
m->entries = n; m->entries = n;
@ -1149,7 +1149,7 @@ void QTMinitmodel(struct QTMmodel *m, struct QTMmodelsym *sym, int n, int s) {
/****************************************************************** /******************************************************************
* QTMinit (internal) * QTMinit (internal)
*/ */
int QTMinit(int window, int level, cab_decomp_state *decomp_state) { static int QTMinit(int window, int level, cab_decomp_state *decomp_state) {
unsigned int wndsize = 1 << window; unsigned int wndsize = 1 << window;
int msz = window * 2, i; int msz = window * 2, i;
cab_ULONG j; cab_ULONG j;
@ -1256,7 +1256,7 @@ void QTMupdatemodel(struct QTMmodel *model, int sym) {
/******************************************************************* /*******************************************************************
* QTMdecompress (internal) * QTMdecompress (internal)
*/ */
int QTMdecompress(int inlen, int outlen, cab_decomp_state *decomp_state) static int QTMdecompress(int inlen, int outlen, cab_decomp_state *decomp_state)
{ {
cab_UBYTE *inpos = CAB(inbuf); cab_UBYTE *inpos = CAB(inbuf);
cab_UBYTE *window = QTM(window); cab_UBYTE *window = QTM(window);
@ -1438,7 +1438,7 @@ int QTMdecompress(int inlen, int outlen, cab_decomp_state *decomp_state)
/************************************************************ /************************************************************
* LZXinit (internal) * LZXinit (internal)
*/ */
int LZXinit(int window, cab_decomp_state *decomp_state) { static int LZXinit(int window, cab_decomp_state *decomp_state) {
cab_ULONG wndsize = 1 << window; cab_ULONG wndsize = 1 << window;
int i, j, posn_slots; int i, j, posn_slots;
@ -1579,7 +1579,7 @@ int make_decode_table(cab_ULONG nsyms, cab_ULONG nbits, cab_UBYTE *length, cab_U
/************************************************************ /************************************************************
* lzx_read_lens (internal) * lzx_read_lens (internal)
*/ */
int lzx_read_lens(cab_UBYTE *lens, cab_ULONG first, cab_ULONG last, struct lzx_bits *lb, static int lzx_read_lens(cab_UBYTE *lens, cab_ULONG first, cab_ULONG last, struct lzx_bits *lb,
cab_decomp_state *decomp_state) { cab_decomp_state *decomp_state) {
cab_ULONG i,j, x,y; cab_ULONG i,j, x,y;
int z; int z;
@ -1626,7 +1626,7 @@ int lzx_read_lens(cab_UBYTE *lens, cab_ULONG first, cab_ULONG last, struct lzx_b
/******************************************************* /*******************************************************
* LZXdecompress (internal) * LZXdecompress (internal)
*/ */
int LZXdecompress(int inlen, int outlen, cab_decomp_state *decomp_state) { static int LZXdecompress(int inlen, int outlen, cab_decomp_state *decomp_state) {
cab_UBYTE *inpos = CAB(inbuf); cab_UBYTE *inpos = CAB(inbuf);
cab_UBYTE *endinp = inpos + inlen; cab_UBYTE *endinp = inpos + inlen;
cab_UBYTE *window = LZX(window); cab_UBYTE *window = LZX(window);
@ -1949,7 +1949,7 @@ int LZXdecompress(int inlen, int outlen, cab_decomp_state *decomp_state) {
/********************************************************* /*********************************************************
* find_cabs_in_file (internal) * find_cabs_in_file (internal)
*/ */
struct cabinet *find_cabs_in_file(LPCSTR name, cab_UBYTE search_buf[]) static struct cabinet *find_cabs_in_file(LPCSTR name, cab_UBYTE search_buf[])
{ {
struct cabinet *cab, *cab2, *firstcab = NULL, *linkcab = NULL; struct cabinet *cab, *cab2, *firstcab = NULL, *linkcab = NULL;
cab_UBYTE *pstart = &search_buf[0], *pend, *p; cab_UBYTE *pstart = &search_buf[0], *pend, *p;
@ -2067,7 +2067,7 @@ struct cabinet *find_cabs_in_file(LPCSTR name, cab_UBYTE search_buf[])
* tries to find *cabname, from the directory path of origcab, correcting the * tries to find *cabname, from the directory path of origcab, correcting the
* case of *cabname if necessary, If found, writes back to *cabname. * case of *cabname if necessary, If found, writes back to *cabname.
*/ */
void find_cabinet_file(char **cabname, LPCSTR origcab) { static void find_cabinet_file(char **cabname, LPCSTR origcab) {
char *tail, *cab, *name, *nextpart, nametmp[MAX_PATH]; char *tail, *cab, *name, *nextpart, nametmp[MAX_PATH];
int found = 0; int found = 0;
@ -2156,7 +2156,7 @@ void find_cabinet_file(char **cabname, LPCSTR origcab) {
* in CAB.c) for an implementation of this that correctly frees the discarded * in CAB.c) for an implementation of this that correctly frees the discarded
* file entries. * file entries.
*/ */
struct cab_file *process_files(struct cabinet *basecab) { static struct cab_file *process_files(struct cabinet *basecab) {
struct cabinet *cab; struct cabinet *cab;
struct cab_file *outfi = NULL, *linkfi = NULL, *nextfi, *fi, *cfi; struct cab_file *outfi = NULL, *linkfi = NULL, *nextfi, *fi, *cfi;
struct cab_folder *fol, *firstfol, *lastfol = NULL, *predfol; struct cab_folder *fol, *firstfol, *lastfol = NULL, *predfol;
@ -2259,7 +2259,7 @@ struct cab_file *process_files(struct cabinet *basecab) {
* *
* FIXME: use a winapi to do this * FIXME: use a winapi to do this
*/ */
int convertUTF(cab_UBYTE *in) { static int convertUTF(cab_UBYTE *in) {
cab_UBYTE c, *out = in, *end = in + strlen((char *) in) + 1; cab_UBYTE c, *out = in, *end = in + strlen((char *) in) + 1;
cab_ULONG x; cab_ULONG x;
@ -2291,7 +2291,7 @@ int convertUTF(cab_UBYTE *in) {
/**************************************************** /****************************************************
* NONEdecompress (internal) * NONEdecompress (internal)
*/ */
int NONEdecompress(int inlen, int outlen, cab_decomp_state *decomp_state) static int NONEdecompress(int inlen, int outlen, cab_decomp_state *decomp_state)
{ {
if (inlen != outlen) return DECR_ILLEGALDATA; if (inlen != outlen) return DECR_ILLEGALDATA;
memcpy(CAB(outbuf), CAB(inbuf), (size_t) inlen); memcpy(CAB(outbuf), CAB(inbuf), (size_t) inlen);
@ -2322,7 +2322,7 @@ cab_ULONG checksum(cab_UBYTE *data, cab_UWORD bytes, cab_ULONG csum) {
/********************************************************** /**********************************************************
* decompress (internal) * decompress (internal)
*/ */
int decompress(struct cab_file *fi, int savemode, int fix, cab_decomp_state *decomp_state) static int decompress(struct cab_file *fi, int savemode, int fix, cab_decomp_state *decomp_state)
{ {
cab_ULONG bytes = savemode ? fi->length : fi->offset - CAB(offset); cab_ULONG bytes = savemode ? fi->length : fi->offset - CAB(offset);
struct cabinet *cab = CAB(current)->cab[CAB(split)]; struct cabinet *cab = CAB(current)->cab[CAB(split)];
@ -2412,7 +2412,7 @@ int decompress(struct cab_file *fi, int savemode, int fix, cab_decomp_state *dec
* *
* workhorse to extract a particular file from a cab * workhorse to extract a particular file from a cab
*/ */
void extract_file(struct cab_file *fi, int lower, int fix, LPCSTR dir, cab_decomp_state *decomp_state) static void extract_file(struct cab_file *fi, int lower, int fix, LPCSTR dir, cab_decomp_state *decomp_state)
{ {
struct cab_folder *fol = fi->folder, *oldfol = CAB(current); struct cab_folder *fol = fi->folder, *oldfol = CAB(current);
cab_LONG err = DECR_OK; cab_LONG err = DECR_OK;
@ -2523,7 +2523,7 @@ exit_handler:
/********************************************************* /*********************************************************
* print_fileinfo (internal) * print_fileinfo (internal)
*/ */
void print_fileinfo(struct cab_file *fi) { static void print_fileinfo(struct cab_file *fi) {
char *fname = NULL; char *fname = NULL;
if (fi->attribs & cffile_A_NAME_IS_UTF) { if (fi->attribs & cffile_A_NAME_IS_UTF) {

98
reactos/lib/cabinet/fci.c
View file

@ -23,7 +23,6 @@
There is still some work to be done: There is still some work to be done:
- currently no support for big-endian machines
- the ERF error structure aren't used on error - the ERF error structure aren't used on error
- no real compression yet - no real compression yet
- unknown behaviour if files>4GB or cabinet >4GB - unknown behaviour if files>4GB or cabinet >4GB
@ -44,11 +43,22 @@ There is still some work to be done:
#include "windef.h" #include "windef.h"
#include "winbase.h" #include "winbase.h"
#include "winerror.h" #include "winerror.h"
#include "winternl.h"
#include "fci.h" #include "fci.h"
#include "cabinet.h" #include "cabinet.h"
#include "wine/debug.h" #include "wine/debug.h"
#ifdef WORDS_BIGENDIAN
#define fci_endian_ulong(x) RtlUlongByteSwap(x)
#define fci_endian_uword(x) RtlUshortByteSwap(x)
#else
#define fci_endian_ulong(x) (x)
#define fci_endian_uword(x) (x)
#endif
WINE_DEFAULT_DEBUG_CHANNEL(cabinet); WINE_DEFAULT_DEBUG_CHANNEL(cabinet);
typedef struct { typedef struct {
@ -556,7 +566,7 @@ static BOOL fci_flushfolder_copy_cfdata(HFCI hfci, char* buffer, UINT cbReserveC
read_result=pcfdata->cbData; read_result=pcfdata->cbData;
/* Modify the size of the compressed data to store only a part of the */ /* Modify the size of the compressed data to store only a part of the */
/* data block into the current cabinet. This is done to prevent */ /* data block into the current cabinet. This is done to prevent */
/* that the maximum cabinet size will be exceeded. The remainer */ /* that the maximum cabinet size will be exceeded. The remainder */
/* will be stored into the next following cabinet. */ /* will be stored into the next following cabinet. */
/* The cabinet will be of size "p_fci_internal->oldCCAB.cb". */ /* The cabinet will be of size "p_fci_internal->oldCCAB.cb". */
@ -599,12 +609,19 @@ static BOOL fci_flushfolder_copy_cfdata(HFCI hfci, char* buffer, UINT cbReserveC
return FALSE; return FALSE;
} }
/* set little endian */
pcfdata->cbData=fci_endian_uword(pcfdata->cbData);
pcfdata->cbUncomp=fci_endian_uword(pcfdata->cbUncomp);
/* get checksum and write to cfdata.csum */ /* get checksum and write to cfdata.csum */
pcfdata->csum = fci_get_checksum( &(pcfdata->cbData), pcfdata->csum = fci_get_checksum( &(pcfdata->cbData),
sizeof(CFDATA)+cbReserveCFData - sizeof(CFDATA)+cbReserveCFData -
sizeof(pcfdata->csum), fci_get_checksum( p_fci_internal->data_out, /*buffer*/ sizeof(pcfdata->csum), fci_get_checksum( p_fci_internal->data_out, /*buffer*/
pcfdata->cbData, 0 ) ); pcfdata->cbData, 0 ) );
/* set little endian */
pcfdata->csum=fci_endian_ulong(pcfdata->csum);
/* write cfdata with checksum to p_fci_internal->handleCFDATA2 */ /* write cfdata with checksum to p_fci_internal->handleCFDATA2 */
if( PFCI_WRITE(hfci, p_fci_internal->handleCFDATA2, /* file handle */ if( PFCI_WRITE(hfci, p_fci_internal->handleCFDATA2, /* file handle */
buffer, /* memory buffer */ buffer, /* memory buffer */
@ -617,6 +634,11 @@ static BOOL fci_flushfolder_copy_cfdata(HFCI hfci, char* buffer, UINT cbReserveC
p_fci_internal->sizeFileCFDATA2 += sizeof(CFDATA)+cbReserveCFData; p_fci_internal->sizeFileCFDATA2 += sizeof(CFDATA)+cbReserveCFData;
/* reset little endian */
pcfdata->cbData=fci_endian_uword(pcfdata->cbData);
pcfdata->cbUncomp=fci_endian_uword(pcfdata->cbUncomp);
pcfdata->csum=fci_endian_ulong(pcfdata->csum);
/* write compressed data into p_fci_internal->handleCFDATA2 */ /* write compressed data into p_fci_internal->handleCFDATA2 */
if( PFCI_WRITE(hfci, p_fci_internal->handleCFDATA2, /* file handle */ if( PFCI_WRITE(hfci, p_fci_internal->handleCFDATA2, /* file handle */
p_fci_internal->data_out, /* memory buffer */ p_fci_internal->data_out, /* memory buffer */
@ -632,7 +654,7 @@ static BOOL fci_flushfolder_copy_cfdata(HFCI hfci, char* buffer, UINT cbReserveC
p_fci_internal->statusFolderCopied += pcfdata->cbData; p_fci_internal->statusFolderCopied += pcfdata->cbData;
(*payload)+=pcfdata->cbUncomp; (*payload)+=pcfdata->cbUncomp;
/* if cabinet size too large and data has been split */ /* if cabinet size too large and data has been split */
/* write the remainer of the data block to the new CFDATA1 file */ /* write the remainder of the data block to the new CFDATA1 file */
if( split_block ) { /* This does not include the */ if( split_block ) { /* This does not include the */
/* abused one (just search for "abused" )*/ /* abused one (just search for "abused" )*/
/* copy all CFDATA structures from handleCFDATA1 to handleCFDATA1new */ /* copy all CFDATA structures from handleCFDATA1 to handleCFDATA1new */
@ -641,7 +663,7 @@ static BOOL fci_flushfolder_copy_cfdata(HFCI hfci, char* buffer, UINT cbReserveC
return FALSE; return FALSE;
} }
/* set cbData the size of the remainer of the data block */ /* set cbData to the size of the remainder of the data block */
pcfdata->cbData = read_result - pcfdata->cbData; pcfdata->cbData = read_result - pcfdata->cbData;
/*recover former value of cfdata.cbData; read_result will be the offset*/ /*recover former value of cfdata.cbData; read_result will be the offset*/
read_result -= pcfdata->cbData; read_result -= pcfdata->cbData;
@ -649,6 +671,7 @@ static BOOL fci_flushfolder_copy_cfdata(HFCI hfci, char* buffer, UINT cbReserveC
/* reset checksum, it will be computed later */ /* reset checksum, it will be computed later */
pcfdata->csum=0; pcfdata->csum=0;
/* write cfdata WITHOUT checksum to handleCFDATA1new */ /* write cfdata WITHOUT checksum to handleCFDATA1new */
if( PFCI_WRITE(hfci, handleCFDATA1new, /* file handle */ if( PFCI_WRITE(hfci, handleCFDATA1new, /* file handle */
buffer, /* memory buffer */ buffer, /* memory buffer */
@ -657,7 +680,7 @@ static BOOL fci_flushfolder_copy_cfdata(HFCI hfci, char* buffer, UINT cbReserveC
/* TODO write error */ /* TODO write error */
return FALSE; return FALSE;
} }
/* TODO error handling of err dont forget PFCI_FREE(hfci, reserved) */ /* TODO error handling of err don't forget PFCI_FREE(hfci, reserved) */
*psizeFileCFDATA1new += sizeof(CFDATA)+cbReserveCFData; *psizeFileCFDATA1new += sizeof(CFDATA)+cbReserveCFData;
@ -676,7 +699,7 @@ static BOOL fci_flushfolder_copy_cfdata(HFCI hfci, char* buffer, UINT cbReserveC
*psizeFileCFDATA1new += pcfdata->cbData; *psizeFileCFDATA1new += pcfdata->cbData;
/* the two blocks of the split data block have been written */ /* the two blocks of the split data block have been written */
/* dont reset split_data yet, because it is still needed see below */ /* don't reset split_data yet, because it is still needed see below */
} }
/* report status with pfnfcis about copied size of folder */ /* report status with pfnfcis about copied size of folder */
@ -721,7 +744,7 @@ static BOOL fci_flushfolder_copy_cfdata(HFCI hfci, char* buffer, UINT cbReserveC
/* TODO read error */ /* TODO read error */
return FALSE; return FALSE;
} }
/* TODO error handling of err dont forget PFCI_FREE(hfci, reserved) */ /* TODO error handling of err don't forget PFCI_FREE(hfci, reserved) */
/* write cfdata with checksum to handleCFDATA1new */ /* write cfdata with checksum to handleCFDATA1new */
if( PFCI_WRITE(hfci, handleCFDATA1new, /* file handle */ if( PFCI_WRITE(hfci, handleCFDATA1new, /* file handle */
@ -731,7 +754,7 @@ static BOOL fci_flushfolder_copy_cfdata(HFCI hfci, char* buffer, UINT cbReserveC
/* TODO write error */ /* TODO write error */
return FALSE; return FALSE;
} }
/* TODO error handling of err dont forget PFCI_FREE(hfci, reserved) */ /* TODO error handling of err don't forget PFCI_FREE(hfci, reserved) */
*psizeFileCFDATA1new += sizeof(CFDATA)+cbReserveCFData; *psizeFileCFDATA1new += sizeof(CFDATA)+cbReserveCFData;
@ -779,7 +802,7 @@ static BOOL fci_flushfolder_copy_cffolder(HFCI hfci, int* err, UINT cbReserveCFF
/* absolute offset cannot be set yet, because the size of cabinet header, */ /* absolute offset cannot be set yet, because the size of cabinet header, */
/* the number of CFFOLDERs and the number of CFFILEs may change. */ /* the number of CFFOLDERs and the number of CFFILEs may change. */
/* Instead the size of all previous data blocks will be stored and */ /* Instead the size of all previous data blocks will be stored and */
/* the remainer of the offset will be added when the cabinet will be */ /* the remainder of the offset will be added when the cabinet will be */
/* flushed to disk. */ /* flushed to disk. */
/* This is exactly the way the original CABINET.DLL works!!! */ /* This is exactly the way the original CABINET.DLL works!!! */
cffolder.coffCabStart=sizeFileCFDATA2old; cffolder.coffCabStart=sizeFileCFDATA2old;
@ -965,6 +988,14 @@ static BOOL fci_flushfolder_copy_cffile(HFCI hfci, int* err, int handleCFFILE1ne
cffile.iFolder=cffileCONTINUED_TO_NEXT; cffile.iFolder=cffileCONTINUED_TO_NEXT;
} }
/* set little endian */
cffile.cbFile=fci_endian_ulong(cffile.cbFile);
cffile.uoffFolderStart=fci_endian_ulong(cffile.uoffFolderStart);
cffile.iFolder=fci_endian_uword(cffile.iFolder);
cffile.date=fci_endian_uword(cffile.date);
cffile.time=fci_endian_uword(cffile.time);
cffile.attribs=fci_endian_uword(cffile.attribs);
/* write cffile to p_fci_internal->handleCFFILE2 */ /* write cffile to p_fci_internal->handleCFFILE2 */
if( PFCI_WRITE(hfci, p_fci_internal->handleCFFILE2, /* file handle */ if( PFCI_WRITE(hfci, p_fci_internal->handleCFFILE2, /* file handle */
&cffile, /* memory buffer */ &cffile, /* memory buffer */
@ -977,6 +1008,14 @@ static BOOL fci_flushfolder_copy_cffile(HFCI hfci, int* err, int handleCFFILE1ne
p_fci_internal->sizeFileCFFILE2 += sizeof(cffile); p_fci_internal->sizeFileCFFILE2 += sizeof(cffile);
/* reset little endian */
cffile.cbFile=fci_endian_ulong(cffile.cbFile);
cffile.uoffFolderStart=fci_endian_ulong(cffile.uoffFolderStart);
cffile.iFolder=fci_endian_uword(cffile.iFolder);
cffile.date=fci_endian_uword(cffile.date);
cffile.time=fci_endian_uword(cffile.time);
cffile.attribs=fci_endian_uword(cffile.attribs);
/* write file name to p_fci_internal->handleCFFILE2 */ /* write file name to p_fci_internal->handleCFFILE2 */
if( PFCI_WRITE(hfci, p_fci_internal->handleCFFILE2, /* file handle */ if( PFCI_WRITE(hfci, p_fci_internal->handleCFFILE2, /* file handle */
p_fci_internal->data_out, /* memory buffer */ p_fci_internal->data_out, /* memory buffer */
@ -1580,6 +1619,18 @@ static BOOL fci_flush_cabinet(
cfheader.iCabinet = p_fci_internal->pccab->iCab-1; cfheader.iCabinet = p_fci_internal->pccab->iCab-1;
} }
/* set little endian */
cfheader.reserved1=fci_endian_ulong(cfheader.reserved1);
cfheader.cbCabinet=fci_endian_ulong(cfheader.cbCabinet);
cfheader.reserved2=fci_endian_ulong(cfheader.reserved2);
cfheader.coffFiles=fci_endian_ulong(cfheader.coffFiles);
cfheader.reserved3=fci_endian_ulong(cfheader.reserved3);
cfheader.cFolders=fci_endian_uword(cfheader.cFolders);
cfheader.cFiles=fci_endian_uword(cfheader.cFiles);
cfheader.flags=fci_endian_uword(cfheader.flags);
cfheader.setID=fci_endian_uword(cfheader.setID);
cfheader.iCabinet=fci_endian_uword(cfheader.iCabinet);
/* write CFHEADER into cabinet file */ /* write CFHEADER into cabinet file */
if( PFCI_WRITE(hfci, handleCABINET, /* file handle */ if( PFCI_WRITE(hfci, handleCABINET, /* file handle */
&cfheader, /* memory buffer */ &cfheader, /* memory buffer */
@ -1590,6 +1641,18 @@ static BOOL fci_flush_cabinet(
} }
/* TODO error handling of err */ /* TODO error handling of err */
/* reset little endian */
cfheader.reserved1=fci_endian_ulong(cfheader.reserved1);
cfheader.cbCabinet=fci_endian_ulong(cfheader.cbCabinet);
cfheader.reserved2=fci_endian_ulong(cfheader.reserved2);
cfheader.coffFiles=fci_endian_ulong(cfheader.coffFiles);
cfheader.reserved3=fci_endian_ulong(cfheader.reserved3);
cfheader.cFolders=fci_endian_uword(cfheader.cFolders);
cfheader.cFiles=fci_endian_uword(cfheader.cFiles);
cfheader.flags=fci_endian_uword(cfheader.flags);
cfheader.setID=fci_endian_uword(cfheader.setID);
cfheader.iCabinet=fci_endian_uword(cfheader.iCabinet);
if( cfheader.flags & cfheadRESERVE_PRESENT ) { if( cfheader.flags & cfheadRESERVE_PRESENT ) {
/* NOTE: No checks for maximum value overflows as designed by MS!!! */ /* NOTE: No checks for maximum value overflows as designed by MS!!! */
cfreserved.cbCFHeader = cbReserveCFHeader; cfreserved.cbCFHeader = cbReserveCFHeader;
@ -1600,6 +1663,10 @@ static BOOL fci_flush_cabinet(
} else { } else {
cfreserved.cbCFData = p_fci_internal->pccab->cbReserveCFData; cfreserved.cbCFData = p_fci_internal->pccab->cbReserveCFData;
} }
/* set little endian */
cfreserved.cbCFHeader=fci_endian_uword(cfreserved.cbCFHeader);
/* write reserved info into cabinet file */ /* write reserved info into cabinet file */
if( PFCI_WRITE(hfci, handleCABINET, /* file handle */ if( PFCI_WRITE(hfci, handleCABINET, /* file handle */
&cfreserved, /* memory buffer */ &cfreserved, /* memory buffer */
@ -1609,6 +1676,9 @@ static BOOL fci_flush_cabinet(
return FALSE; return FALSE;
} }
/* TODO error handling of err */ /* TODO error handling of err */
/* reset little endian */
cfreserved.cbCFHeader=fci_endian_uword(cfreserved.cbCFHeader);
} }
/* add optional reserved area */ /* add optional reserved area */
@ -1735,6 +1805,11 @@ static BOOL fci_flush_cabinet(
} }
} }
/* set little endian */
cffolder.coffCabStart=fci_endian_ulong(cffolder.coffCabStart);
cffolder.cCFData=fci_endian_uword(cffolder.cCFData);
cffolder.typeCompress=fci_endian_uword(cffolder.typeCompress);
/* write cffolder to cabinet file */ /* write cffolder to cabinet file */
if( PFCI_WRITE(hfci, handleCABINET, /* file handle */ if( PFCI_WRITE(hfci, handleCABINET, /* file handle */
&cffolder, /* memory buffer */ &cffolder, /* memory buffer */
@ -1745,6 +1820,11 @@ static BOOL fci_flush_cabinet(
} }
/* TODO error handling of err */ /* TODO error handling of err */
/* reset little endian */
cffolder.coffCabStart=fci_endian_ulong(cffolder.coffCabStart);
cffolder.cCFData=fci_endian_uword(cffolder.cCFData);
cffolder.typeCompress=fci_endian_uword(cffolder.typeCompress);
/* add optional reserved area */ /* add optional reserved area */
/* This allocation and freeing at each CFFolder block is a bit */ /* This allocation and freeing at each CFFolder block is a bit */

38
reactos/lib/cabinet/fdi.c
View file

@ -243,7 +243,7 @@ HFDI __cdecl FDICreate(
* *
* returns the file pointer position of a file handle. * returns the file pointer position of a file handle.
*/ */
long FDI_getoffset(HFDI hfdi, INT_PTR hf) static long FDI_getoffset(HFDI hfdi, INT_PTR hf)
{ {
return PFDI_SEEK(hfdi, hf, 0L, SEEK_CUR); return PFDI_SEEK(hfdi, hf, 0L, SEEK_CUR);
} }
@ -254,7 +254,7 @@ long FDI_getoffset(HFDI hfdi, INT_PTR hf)
* we can't use _msize; the user might not be using malloc, so we require * we can't use _msize; the user might not be using malloc, so we require
* an explicit specification of the previous size. inefficient. * an explicit specification of the previous size. inefficient.
*/ */
void *FDI_realloc(HFDI hfdi, void *mem, size_t prevsize, size_t newsize) static void *FDI_realloc(HFDI hfdi, void *mem, size_t prevsize, size_t newsize)
{ {
void *rslt = NULL; void *rslt = NULL;
char *irslt, *imem; char *irslt, *imem;
@ -273,7 +273,7 @@ void *FDI_realloc(HFDI hfdi, void *mem, size_t prevsize, size_t newsize)
* *
* allocate and read an arbitrarily long string from the cabinet * allocate and read an arbitrarily long string from the cabinet
*/ */
char *FDI_read_string(HFDI hfdi, INT_PTR hf, long cabsize) static char *FDI_read_string(HFDI hfdi, INT_PTR hf, long cabsize)
{ {
size_t len=256, size_t len=256,
oldlen = 0, oldlen = 0,
@ -326,7 +326,7 @@ char *FDI_read_string(HFDI hfdi, INT_PTR hf, long cabsize)
* process the cabinet header in the style of FDIIsCabinet, but * process the cabinet header in the style of FDIIsCabinet, but
* without the sanity checks (and bug) * without the sanity checks (and bug)
*/ */
BOOL FDI_read_entries( static BOOL FDI_read_entries(
HFDI hfdi, HFDI hfdi,
INT_PTR hf, INT_PTR hf,
PFDICABINETINFO pfdici, PFDICABINETINFO pfdici,
@ -632,7 +632,7 @@ BOOL __cdecl FDIIsCabinet(
* *
* Initialize a model which decodes symbols from [s] to [s]+[n]-1 * Initialize a model which decodes symbols from [s] to [s]+[n]-1
*/ */
void QTMfdi_initmodel(struct QTMmodel *m, struct QTMmodelsym *sym, int n, int s) { static void QTMfdi_initmodel(struct QTMmodel *m, struct QTMmodelsym *sym, int n, int s) {
int i; int i;
m->shiftsleft = 4; m->shiftsleft = 4;
m->entries = n; m->entries = n;
@ -649,7 +649,7 @@ void QTMfdi_initmodel(struct QTMmodel *m, struct QTMmodelsym *sym, int n, int s)
/****************************************************************** /******************************************************************
* QTMfdi_init (internal) * QTMfdi_init (internal)
*/ */
int QTMfdi_init(int window, int level, fdi_decomp_state *decomp_state) { static int QTMfdi_init(int window, int level, fdi_decomp_state *decomp_state) {
unsigned int wndsize = 1 << window; unsigned int wndsize = 1 << window;
int msz = window * 2, i; int msz = window * 2, i;
cab_ULONG j; cab_ULONG j;
@ -701,7 +701,7 @@ int QTMfdi_init(int window, int level, fdi_decomp_state *decomp_state) {
/************************************************************ /************************************************************
* LZXfdi_init (internal) * LZXfdi_init (internal)
*/ */
int LZXfdi_init(int window, fdi_decomp_state *decomp_state) { static int LZXfdi_init(int window, fdi_decomp_state *decomp_state) {
cab_ULONG wndsize = 1 << window; cab_ULONG wndsize = 1 << window;
int i, j, posn_slots; int i, j, posn_slots;
@ -755,7 +755,7 @@ int LZXfdi_init(int window, fdi_decomp_state *decomp_state) {
/**************************************************** /****************************************************
* NONEfdi_decomp(internal) * NONEfdi_decomp(internal)
*/ */
int NONEfdi_decomp(int inlen, int outlen, fdi_decomp_state *decomp_state) static int NONEfdi_decomp(int inlen, int outlen, fdi_decomp_state *decomp_state)
{ {
if (inlen != outlen) return DECR_ILLEGALDATA; if (inlen != outlen) return DECR_ILLEGALDATA;
memcpy(CAB(outbuf), CAB(inbuf), (size_t) inlen); memcpy(CAB(outbuf), CAB(inbuf), (size_t) inlen);
@ -765,7 +765,7 @@ int NONEfdi_decomp(int inlen, int outlen, fdi_decomp_state *decomp_state)
/******************************************************** /********************************************************
* Ziphuft_free (internal) * Ziphuft_free (internal)
*/ */
void fdi_Ziphuft_free(HFDI hfdi, struct Ziphuft *t) static void fdi_Ziphuft_free(HFDI hfdi, struct Ziphuft *t)
{ {
register struct Ziphuft *p, *q; register struct Ziphuft *p, *q;
@ -782,7 +782,7 @@ void fdi_Ziphuft_free(HFDI hfdi, struct Ziphuft *t)
/********************************************************* /*********************************************************
* fdi_Ziphuft_build (internal) * fdi_Ziphuft_build (internal)
*/ */
cab_LONG fdi_Ziphuft_build(cab_ULONG *b, cab_ULONG n, cab_ULONG s, cab_UWORD *d, cab_UWORD *e, static cab_LONG fdi_Ziphuft_build(cab_ULONG *b, cab_ULONG n, cab_ULONG s, cab_UWORD *d, cab_UWORD *e,
struct Ziphuft **t, cab_LONG *m, fdi_decomp_state *decomp_state) struct Ziphuft **t, cab_LONG *m, fdi_decomp_state *decomp_state)
{ {
cab_ULONG a; /* counter for codes of length k */ cab_ULONG a; /* counter for codes of length k */
@ -1045,7 +1045,7 @@ cab_LONG fdi_Zipinflate_codes(struct Ziphuft *tl, struct Ziphuft *td,
/*********************************************************** /***********************************************************
* Zipinflate_stored (internal) * Zipinflate_stored (internal)
*/ */
cab_LONG fdi_Zipinflate_stored(fdi_decomp_state *decomp_state) static cab_LONG fdi_Zipinflate_stored(fdi_decomp_state *decomp_state)
/* "decompress" an inflated type 0 (stored) block. */ /* "decompress" an inflated type 0 (stored) block. */
{ {
cab_ULONG n; /* number of bytes in block */ cab_ULONG n; /* number of bytes in block */
@ -1089,7 +1089,7 @@ cab_LONG fdi_Zipinflate_stored(fdi_decomp_state *decomp_state)
/****************************************************** /******************************************************
* fdi_Zipinflate_fixed (internal) * fdi_Zipinflate_fixed (internal)
*/ */
cab_LONG fdi_Zipinflate_fixed(fdi_decomp_state *decomp_state) static cab_LONG fdi_Zipinflate_fixed(fdi_decomp_state *decomp_state)
{ {
struct Ziphuft *fixed_tl; struct Ziphuft *fixed_tl;
struct Ziphuft *fixed_td; struct Ziphuft *fixed_td;
@ -1135,7 +1135,7 @@ cab_LONG fdi_Zipinflate_fixed(fdi_decomp_state *decomp_state)
/************************************************************** /**************************************************************
* fdi_Zipinflate_dynamic (internal) * fdi_Zipinflate_dynamic (internal)
*/ */
cab_LONG fdi_Zipinflate_dynamic(fdi_decomp_state *decomp_state) static cab_LONG fdi_Zipinflate_dynamic(fdi_decomp_state *decomp_state)
/* decompress an inflated type 2 (dynamic Huffman codes) block. */ /* decompress an inflated type 2 (dynamic Huffman codes) block. */
{ {
cab_LONG i; /* temporary variables */ cab_LONG i; /* temporary variables */
@ -1270,7 +1270,7 @@ cab_LONG fdi_Zipinflate_dynamic(fdi_decomp_state *decomp_state)
/***************************************************** /*****************************************************
* fdi_Zipinflate_block (internal) * fdi_Zipinflate_block (internal)
*/ */
cab_LONG fdi_Zipinflate_block(cab_LONG *e, fdi_decomp_state *decomp_state) /* e == last block flag */ static cab_LONG fdi_Zipinflate_block(cab_LONG *e, fdi_decomp_state *decomp_state) /* e == last block flag */
{ /* decompress an inflated block */ { /* decompress an inflated block */
cab_ULONG t; /* block type */ cab_ULONG t; /* block type */
register cab_ULONG b; /* bit buffer */ register cab_ULONG b; /* bit buffer */
@ -1308,7 +1308,7 @@ cab_LONG fdi_Zipinflate_block(cab_LONG *e, fdi_decomp_state *decomp_state) /* e
/**************************************************** /****************************************************
* ZIPfdi_decomp(internal) * ZIPfdi_decomp(internal)
*/ */
int ZIPfdi_decomp(int inlen, int outlen, fdi_decomp_state *decomp_state) static int ZIPfdi_decomp(int inlen, int outlen, fdi_decomp_state *decomp_state)
{ {
cab_LONG e; /* last block flag */ cab_LONG e; /* last block flag */
@ -1336,7 +1336,7 @@ int ZIPfdi_decomp(int inlen, int outlen, fdi_decomp_state *decomp_state)
/******************************************************************* /*******************************************************************
* QTMfdi_decomp(internal) * QTMfdi_decomp(internal)
*/ */
int QTMfdi_decomp(int inlen, int outlen, fdi_decomp_state *decomp_state) static int QTMfdi_decomp(int inlen, int outlen, fdi_decomp_state *decomp_state)
{ {
cab_UBYTE *inpos = CAB(inbuf); cab_UBYTE *inpos = CAB(inbuf);
cab_UBYTE *window = QTM(window); cab_UBYTE *window = QTM(window);
@ -1462,7 +1462,7 @@ int QTMfdi_decomp(int inlen, int outlen, fdi_decomp_state *decomp_state)
/************************************************************ /************************************************************
* fdi_lzx_read_lens (internal) * fdi_lzx_read_lens (internal)
*/ */
int fdi_lzx_read_lens(cab_UBYTE *lens, cab_ULONG first, cab_ULONG last, struct lzx_bits *lb, static int fdi_lzx_read_lens(cab_UBYTE *lens, cab_ULONG first, cab_ULONG last, struct lzx_bits *lb,
fdi_decomp_state *decomp_state) { fdi_decomp_state *decomp_state) {
cab_ULONG i,j, x,y; cab_ULONG i,j, x,y;
int z; int z;
@ -1509,7 +1509,7 @@ int fdi_lzx_read_lens(cab_UBYTE *lens, cab_ULONG first, cab_ULONG last, struct l
/******************************************************* /*******************************************************
* LZXfdi_decomp(internal) * LZXfdi_decomp(internal)
*/ */
int LZXfdi_decomp(int inlen, int outlen, fdi_decomp_state *decomp_state) { static int LZXfdi_decomp(int inlen, int outlen, fdi_decomp_state *decomp_state) {
cab_UBYTE *inpos = CAB(inbuf); cab_UBYTE *inpos = CAB(inbuf);
cab_UBYTE *endinp = inpos + inlen; cab_UBYTE *endinp = inpos + inlen;
cab_UBYTE *window = LZX(window); cab_UBYTE *window = LZX(window);
@ -1841,7 +1841,7 @@ int LZXfdi_decomp(int inlen, int outlen, fdi_decomp_state *decomp_state) {
* is also where we jump to additional cabinets in the case of split * is also where we jump to additional cabinets in the case of split
* cab's, and provide (some of) the NEXT_CABINET notification semantics. * cab's, and provide (some of) the NEXT_CABINET notification semantics.
*/ */
int fdi_decomp(struct fdi_file *fi, int savemode, fdi_decomp_state *decomp_state, static int fdi_decomp(struct fdi_file *fi, int savemode, fdi_decomp_state *decomp_state,
char *pszCabPath, PFNFDINOTIFY pfnfdin, void *pvUser) char *pszCabPath, PFNFDINOTIFY pfnfdin, void *pvUser)
{ {
cab_ULONG bytes = savemode ? fi->length : fi->offset - CAB(offset); cab_ULONG bytes = savemode ? fi->length : fi->offset - CAB(offset);