You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
977 lines
31 KiB
977 lines
31 KiB
/*
|
|
** winlzexp.c - Windows LZExpand library routines for manipulating compressed
|
|
** files.
|
|
**
|
|
** Author: DavidDi
|
|
*/
|
|
|
|
|
|
/*
|
|
** Notes:
|
|
** -----
|
|
**
|
|
** The LZInit() function returns either DOS handles or LZFile struct
|
|
** identifiers of some kind, depending upon how it is called. The LZ
|
|
** functions LZSeek(), LZRead(), and LZClose() needed some way to
|
|
** differentiate between DOS file handles and the LZFile struct identifiers.
|
|
** As the functions stand now, they use DOS file handles as themselves, and
|
|
** table offsets as LZFile identifiers. The table offsets are incremented by
|
|
** some base value, LZ_TABLE_BIAS, in order to push their values past all
|
|
** possible DOS file handle values. The table offsets (- LZ_TABLE_BIAS) are
|
|
** used as indices in rghLZFileTable[] to retrieve a global handle to an
|
|
** LZFile struct. The table of global handles is allocated statically from
|
|
** the DLL's data segment. The LZFile struct's are allocated from global
|
|
** heap space and are moveable. This scheme might also be implemented as a
|
|
** linked list of global handles.
|
|
**
|
|
** Now the resulting benefit from this scheme is that DOS file handles and
|
|
** LZFile struct identifiers can be differentiated, since DOS file handles
|
|
** are always < LZ_TABLE_BIAS, and LZFile struct identifiers are always
|
|
** >= LZ_TABLE_BIAS. This dichotomy may be used in macros, like the sample
|
|
** ones provided in lzexpand.h, to select the appropriate function to call
|
|
** (e.g., LZSeek() or _llseek()) in order to avoid the overhead of an extra
|
|
** function call for uncompressed files. LZSeek(), LZRead(), and LZClose()
|
|
** are, however, "smart" enough to figure out whether they are dealing with
|
|
** DOS file handles or table offsets, and take action appropriately. As an
|
|
** extreme example, LZOpenFile(), LZSeek(), LZRead, and LZClose() can be used
|
|
** as replacements for OpenFile(), _llseek(), _lread(), and _lclose. In this
|
|
** case, the program using the DLL functions could call them without ever
|
|
** caring whether the files it was reading were LZ compressed or not.
|
|
*/
|
|
|
|
|
|
/* WIN32 MODS
|
|
|
|
** Since the above is a DOS only hack, I have to change the logic for
|
|
** for the 0-255 file handle deal'o. The original code, tests greater than
|
|
** LZ_TABLE_BIAS for file structures. What I will do, is convert file handles
|
|
** returned from OpenFile, to a range 0-255. Once the test is complete, I'll
|
|
** use the file handle as an offset into a 255 element array, which will
|
|
** contain the WIN32 file handle. So there will be an additional array
|
|
** fhWin32File[255], which will be allocated sequencially starting at 0.
|
|
** Unfortunately, this means everywhere the file handle is used, must be converted
|
|
*/
|
|
|
|
// Headers
|
|
///////////
|
|
#include <basedll.h>
|
|
#define LZA_DLL
|
|
#include "lz_common.h"
|
|
#include "lz_buffers.h"
|
|
#include "lz_header.h"
|
|
#include "lzcommon.h"
|
|
|
|
#include "lzpriv.h"
|
|
#include "wchar.h"
|
|
|
|
#if DEBUG
|
|
#include "stdio.h"
|
|
#endif
|
|
|
|
// Globals
|
|
///////////
|
|
|
|
// table of handles to LZFile structs
|
|
HANDLE rghLZFileTable[MAX_LZFILES] = {0};
|
|
|
|
// next free entry in rghLZFileTable[]
|
|
static INT iNextLZFileEntry = 0;
|
|
|
|
HFILE fhWin32File[MAX_LZFILES] = {0};
|
|
|
|
/*
|
|
** int APIENTRY LZInit(int hWin32File);
|
|
**
|
|
** Sets up LZFile struct for a file that has already been opened by
|
|
** OpenFile().
|
|
**
|
|
** Arguments: hWin32File - source DOS file handle
|
|
**
|
|
** Returns: int - LZFile struct table offset or DOS file handle if
|
|
** successful. One of the LZERROR_ codes if unsuccessful.
|
|
**
|
|
** Globals: iNextLZFile entry advanced, or returned to beginning from end.
|
|
*/
|
|
INT APIENTRY LZInit(INT hWin32File)
|
|
{
|
|
HANDLE hLZFile; // handle to new LZFile struct
|
|
LZFile *lpLZ; // pointer to new LZFile struct
|
|
FH FHComp; // header info structure from input file
|
|
BOOL bHdr; // holds GetHdr() return value
|
|
INT iTableIndex, // holds rghLZFileTable[] slot to be filled by
|
|
// new LZFile struct handle
|
|
iStartEntry; // original value of iNextLZFileEntry
|
|
|
|
LONG cblInSize = 0;
|
|
INT nRet;
|
|
|
|
// Did the read succeed?
|
|
if ((bHdr = GetHdr((FH *)&FHComp, hWin32File, &cblInSize)) != TRUE
|
|
&& cblInSize >= (LONG)HEADER_LEN) {
|
|
|
|
return(LZERROR_BADINHANDLE);
|
|
}
|
|
|
|
// Check for uncompressed input file.
|
|
if (bHdr != TRUE || IsCompressed(& FHComp) != TRUE)
|
|
{
|
|
// This is an uncompressed file - rewind it.
|
|
if (FSEEK(hWin32File, 0L, SEEK_SET) != 0L) {
|
|
return(LZERROR_BADINHANDLE);
|
|
}
|
|
else {
|
|
// And return DOS file handle.
|
|
return(ConvertWin32FHToDos(hWin32File));
|
|
}
|
|
}
|
|
|
|
// Check compression algorithm used.
|
|
if (RecognizeCompAlg(FHComp.byteAlgorithm) != TRUE) {
|
|
return(LZERROR_UNKNOWNALG);
|
|
}
|
|
|
|
// Find next free rghLZFileTable[] entry. N.b., we depend upon LZClose()
|
|
// to free unused entries up.
|
|
RtlEnterCriticalSection(&BaseLZSemTable);
|
|
|
|
iStartEntry = iNextLZFileEntry;
|
|
|
|
while (rghLZFileTable[iNextLZFileEntry] != NULL)
|
|
{
|
|
if (++iNextLZFileEntry >= MAX_LZFILES)
|
|
// Return to beginning of table.
|
|
iNextLZFileEntry = 0;
|
|
|
|
if (iNextLZFileEntry == iStartEntry) {
|
|
// We've gone full circle through rghLZFileTable[].
|
|
// It's full, so bail out.
|
|
nRet = LZERROR_GLOBALLOC;
|
|
goto LZInitExit;
|
|
}
|
|
}
|
|
|
|
// Keep track of the rghLZFileTable() slot to be filled by a handle to the
|
|
// new LZFile struct.
|
|
iTableIndex = iNextLZFileEntry;
|
|
|
|
// Allocate global storage for the new LZFile struct, initializing all
|
|
// fields to 0.
|
|
|
|
hLZFile = GlobalAlloc(GMEM_MOVEABLE | GMEM_ZEROINIT, (DWORD)sizeof(LZFile));
|
|
if (!hLZFile) {
|
|
|
|
nRet = LZERROR_GLOBALLOC;
|
|
goto LZInitExit;
|
|
}
|
|
|
|
// Lock that baby up.
|
|
if ((lpLZ = (LZFile *)GlobalLock(hLZFile)) == NULL)
|
|
{
|
|
GlobalFree(hLZFile);
|
|
|
|
nRet =LZERROR_GLOBLOCK;
|
|
goto LZInitExit;
|
|
}
|
|
|
|
// Initialize the new LZFile struct's general information fields.
|
|
lpLZ->dosh = hWin32File;
|
|
lpLZ->byteAlgorithm = FHComp.byteAlgorithm;
|
|
lpLZ->wFlags = 0;
|
|
lpLZ->cbulUncompSize = FHComp.cbulUncompSize;
|
|
lpLZ->cbulCompSize = FHComp.cbulCompSize;
|
|
lpLZ->lCurSeekPos = 0L;
|
|
|
|
// LZRead/LZSeeks expansion data is kept on a per file basis
|
|
lpLZ->pLZI = NULL;
|
|
|
|
// Enter new handle in table of handles.
|
|
rghLZFileTable[iTableIndex] = hLZFile;
|
|
|
|
/* WIN32 NOTE, dont need convert below, as forces a non file handle
|
|
* to the API.
|
|
*/
|
|
|
|
GlobalUnlock(hLZFile);
|
|
|
|
// Advance to next free entry.
|
|
if (++iNextLZFileEntry >= MAX_LZFILES)
|
|
iNextLZFileEntry = 0;
|
|
|
|
nRet = LZ_TABLE_BIAS + iTableIndex;
|
|
|
|
LZInitExit:
|
|
|
|
RtlLeaveCriticalSection(&BaseLZSemTable);
|
|
|
|
// Return rghLZFileTable[] offset of the new LZFile struct's handle's
|
|
// entry + the table bias.
|
|
return(nRet);
|
|
}
|
|
|
|
|
|
/*
|
|
** int APIENTRY GetExpandedNameA(LPSTR lpszSource, LPSTR lpszBuffer);
|
|
**
|
|
** Looks in the header of a compressed file to find its original expanded
|
|
** name.
|
|
**
|
|
** Arguments: lpszSource - name of input file
|
|
** lpszBuffer - pointer to a buffer that will be filled in with
|
|
** the expanded name of the compressed source file
|
|
**
|
|
** Returns: int - TRUE if successful. One of the LZERROR_ codes if
|
|
** unsuccessful.
|
|
**
|
|
** Globals: none
|
|
*/
|
|
INT APIENTRY GetExpandedNameA(LPSTR lpszSource, LPSTR lpszBuffer)
|
|
{
|
|
INT doshSource, // source DOS file handle
|
|
bHdr; // holds GetHdr() return value
|
|
FH FHComp; // header info structure from input file
|
|
OFSTRUCT ofOpenBuf; // source struct for OpenFile() call
|
|
LONG cblInSize = 0;
|
|
|
|
// Try to open the source file.
|
|
if ((doshSource = (HFILE)MOpenFile(lpszSource, (LPOFSTRUCT)(& ofOpenBuf), OF_READ))
|
|
== -1)
|
|
return(LZERROR_BADVALUE);
|
|
|
|
// Get the compressed file header.
|
|
if ((bHdr = GetHdr((FH *)&FHComp, doshSource, &cblInSize)) != TRUE
|
|
&& cblInSize >= (LONG)HEADER_LEN)
|
|
{
|
|
FCLOSE(doshSource);
|
|
return(LZERROR_BADVALUE);
|
|
}
|
|
|
|
// Close source file.
|
|
FCLOSE(doshSource);
|
|
|
|
// Return expanded name same as source name for uncompressed files.
|
|
STRCPY(lpszBuffer, lpszSource);
|
|
|
|
// Check for compressed input file.
|
|
if (bHdr == TRUE && IsCompressed(& FHComp) == TRUE)
|
|
MakeExpandedName(lpszBuffer, FHComp.byteExtensionChar);
|
|
|
|
return(TRUE);
|
|
}
|
|
|
|
/*
|
|
** int APIENTRY GetExpandedNameW(LPSTR lpszSource, LPSTR lpszBuffer);
|
|
**
|
|
** Wide Character version of GetExpandedName. Converts the filename to
|
|
** the ANSI Character set and calls the ANSI version.
|
|
**
|
|
*/
|
|
INT APIENTRY GetExpandedNameW(LPWSTR lpszSource, LPWSTR lpszBuffer)
|
|
{
|
|
UNICODE_STRING TempW;
|
|
ANSI_STRING TempA;
|
|
NTSTATUS Status;
|
|
NTSTATUS StatusR;
|
|
CHAR szBuffer[MAX_PATH + 2];
|
|
|
|
|
|
TempW.Buffer = lpszSource;
|
|
TempW.Length = wcslen(lpszSource)*sizeof(WCHAR);
|
|
TempW.MaximumLength = TempW.Length + sizeof(WCHAR);
|
|
|
|
TempA.Buffer = szBuffer;
|
|
TempA.MaximumLength = MAX_PATH;
|
|
StatusR = RtlUnicodeStringToAnsiString(&TempA, &TempW, FALSE);
|
|
if (!NT_SUCCESS(StatusR))
|
|
return LZERROR_GLOBALLOC;
|
|
|
|
Status = GetExpandedNameA(szBuffer, (LPSTR)lpszBuffer);
|
|
|
|
if (Status != -1) {
|
|
szBuffer[MAX_PATH] = ANSI_NULL;
|
|
lstrcpyn(szBuffer, (LPSTR)lpszBuffer, sizeof(szBuffer));
|
|
if (szBuffer[MAX_PATH]) {
|
|
return LZERROR_BADVALUE;
|
|
}
|
|
TempA.Length = (USHORT) strlen(szBuffer);
|
|
TempA.MaximumLength = TempA.Length+sizeof(CHAR);
|
|
|
|
TempW.Buffer = lpszBuffer;
|
|
TempW.MaximumLength = MAX_PATH;
|
|
StatusR = RtlAnsiStringToUnicodeString(&TempW, &TempA, FALSE);
|
|
if (!NT_SUCCESS(StatusR))
|
|
return LZERROR_GLOBALLOC;
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
|
|
//
|
|
// INT LZCreateFileW(LPCWSTR lpFileName, DWORD fdwAccess)
|
|
//
|
|
// Opens a file (using CreateFile) and sets up an LZFile struct for
|
|
// expanding it.
|
|
//
|
|
// Arguments: lpFileName - name of input file
|
|
// fdwAccess - CreateFile access type - (e.g. GENERIC_READ)
|
|
// fdwShareMode - Share mode - (e.g. FILE_SHARE_READ)
|
|
// fdwCreate - Action to be taken - (e.g. OPEN_EXISTING)
|
|
//
|
|
// Returns: INT - LZFile struct table offset or WIN32 file HANDLE if
|
|
// successful. One of the LZERROR_ codes if unsuccessful.
|
|
//
|
|
INT
|
|
LZCreateFileW(
|
|
LPWSTR lpFileName,
|
|
DWORD fdwAccess,
|
|
DWORD fdwShareMode,
|
|
DWORD fdwCreate,
|
|
LPWSTR lpCompressedName)
|
|
{
|
|
HANDLE hWin32; // WIN32 file HANDLE returned from CreateFileW()
|
|
INT lzh; // LZ File struct ID returned from LZInit()
|
|
static WCHAR pszCompName[MAX_PATH + 2]; // buffer for compressed name
|
|
|
|
pszCompName[MAX_PATH] = UNICODE_NULL;
|
|
lstrcpynW((LPWSTR)pszCompName, lpFileName,
|
|
sizeof(pszCompName) / sizeof(WCHAR));
|
|
if (pszCompName[MAX_PATH]) {
|
|
return LZERROR_BADVALUE;
|
|
}
|
|
|
|
// Just for Vlad, only try to open the compressed version of the original
|
|
// file name if we can't find the original file. All other errors get
|
|
// returned immediately.
|
|
|
|
hWin32 = CreateFileW(pszCompName, fdwAccess, fdwShareMode, NULL, fdwCreate,
|
|
FILE_ATTRIBUTE_NORMAL, NULL);
|
|
|
|
if (hWin32 == INVALID_HANDLE_VALUE) {
|
|
DWORD dwErr = GetLastError();
|
|
|
|
if (dwErr == ERROR_FILE_NOT_FOUND) {
|
|
|
|
// Let's try to open the file of the corresponding compressed name.
|
|
MakeCompressedNameW((LPWSTR)pszCompName);
|
|
|
|
hWin32 = CreateFileW(pszCompName, fdwAccess, fdwShareMode,
|
|
NULL, fdwCreate, FILE_ATTRIBUTE_NORMAL, NULL);
|
|
}
|
|
}
|
|
|
|
// Error opening file?
|
|
if (hWin32 == INVALID_HANDLE_VALUE) {
|
|
return(LZERROR_BADINHANDLE);
|
|
}
|
|
|
|
// Don't call LZinit() on files opened in other read only mode
|
|
|
|
if (fdwCreate != OPEN_EXISTING) {
|
|
lzh = ConvertWin32FHToDos((HFILE)((DWORD_PTR)hWin32));
|
|
if (lzh == LZERROR_GLOBALLOC) {
|
|
CloseHandle(hWin32);
|
|
}
|
|
|
|
return(lzh);
|
|
}
|
|
|
|
// File has been opened with read-only action - call LZInit() to detect
|
|
// whether or not it's an LZ file, and to create structures for expansion
|
|
// if it is an LZ file.
|
|
lzh = LZInit((INT)((DWORD_PTR)hWin32));
|
|
|
|
// Close DOS file handle if LZInit() is unsuccessful.
|
|
if (lzh < 0)
|
|
CloseHandle(hWin32);
|
|
|
|
// Pass real file name to caller
|
|
//
|
|
// we believe the caller have enough buffer.
|
|
//
|
|
if( lpCompressedName != NULL )
|
|
lstrcpyW(lpCompressedName,pszCompName);
|
|
|
|
// Return LZ struct ID or LZERROR_ code.
|
|
return(lzh);
|
|
}
|
|
|
|
|
|
/*
|
|
** int APIENTRY LZOpenFileA(LPCSTR lpFileName, LPOFSTRUCT lpReOpenBuf,
|
|
** WORD wStyle);
|
|
**
|
|
** Opens a file and sets up an LZFile struct for expanding it.
|
|
**
|
|
** Arguments: lpFileName - name of input file
|
|
** lpReOpenBuf - pointer to LPOFSTRUCT to be used by OpenFile()
|
|
** wStyle - OpenFile() action to take
|
|
**
|
|
** Returns: int - LZFile struct table offset or DOS file handle if
|
|
** successful. One of the LZERROR_ codes if unsuccessful.
|
|
**
|
|
** Globals: none
|
|
*/
|
|
INT APIENTRY LZOpenFileA(LPSTR lpFileName, LPOFSTRUCT lpReOpenBuf, WORD wStyle)
|
|
{
|
|
INT dosh, // DOS file handle returned from OpenFile()
|
|
lzh; // LZ File struct ID returned from LZInit()
|
|
CHAR pszCompName[MAX_PATH + 2]; // buffer for compressed name
|
|
|
|
pszCompName[MAX_PATH] = UNICODE_NULL;
|
|
lstrcpyn((LPSTR)pszCompName, lpFileName, sizeof(pszCompName));
|
|
if (pszCompName[MAX_PATH]) {
|
|
return LZERROR_BADVALUE;
|
|
}
|
|
|
|
// Just for Vlad, only try to open the compressed version of the original
|
|
// file name if we can't find the original file. All other errors get
|
|
// returned immediately.
|
|
|
|
if ((dosh = OpenFile(pszCompName, lpReOpenBuf, wStyle)) == -1 &&
|
|
lpReOpenBuf->nErrCode == DEE_FILENOTFOUND)
|
|
{
|
|
// Let's try to open the file of the corresponding compressed name.
|
|
MakeCompressedName(pszCompName);
|
|
|
|
dosh = (HFILE) MOpenFile((LPSTR)pszCompName, lpReOpenBuf, wStyle);
|
|
}
|
|
|
|
// Error opening file?
|
|
if (dosh == -1)
|
|
return(LZERROR_BADINHANDLE);
|
|
|
|
// Don't call LZinit() on files opened in other than O_RDONLY mode.
|
|
// Ignore the SHARE bits.
|
|
if ((wStyle & STYLE_MASK) != OF_READ) {
|
|
lzh = ConvertWin32FHToDos(dosh);
|
|
if (lzh == LZERROR_GLOBALLOC) {
|
|
FCLOSE(dosh);
|
|
}
|
|
return(lzh);
|
|
}
|
|
|
|
// File has been opened with OF_READ style - call LZInit() to detect
|
|
// whether or not it's an LZ file, and to create structures for expansion
|
|
// if it is an LZ file.
|
|
lzh = LZInit(dosh);
|
|
|
|
// Close DOS file handle if LZInit() is unsuccessful.
|
|
if (lzh < 0)
|
|
FCLOSE(dosh);
|
|
|
|
// Return LZ struct ID or LZERROR_ code.
|
|
return(lzh);
|
|
}
|
|
|
|
/*
|
|
** int APIENTRY LZOpenFileW(LPCWSTR lpFileName, LPOFSTRUCT lpReOpenBuf,
|
|
** WORD wStyle);
|
|
**
|
|
** Wide Character version of LZOpenFile. Converts the filename to
|
|
** the ANSI Character set and calls the ANSI version.
|
|
**
|
|
*/
|
|
INT APIENTRY LZOpenFileW(LPWSTR lpFileName, LPOFSTRUCT lpReOpenBuf, WORD wStyle)
|
|
{
|
|
UNICODE_STRING FileName;
|
|
ANSI_STRING AnsiString;
|
|
NTSTATUS StatusR;
|
|
CHAR szFileName[MAX_PATH];
|
|
|
|
|
|
FileName.Buffer = lpFileName;
|
|
FileName.Length = wcslen(lpFileName)*sizeof(WCHAR);
|
|
FileName.MaximumLength = FileName.Length + sizeof(WCHAR);
|
|
|
|
AnsiString.Buffer = szFileName;
|
|
AnsiString.MaximumLength = MAX_PATH;
|
|
StatusR = RtlUnicodeStringToAnsiString(&AnsiString, &FileName, FALSE);
|
|
if (!NT_SUCCESS(StatusR))
|
|
return LZERROR_GLOBALLOC;
|
|
|
|
return(LZOpenFileA(szFileName, lpReOpenBuf, wStyle));
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
** LONG APIENTRY LZSeek(int oLZFile, long lSeekTo, int nMode);
|
|
**
|
|
** Works like _llseek(), but in the expanded image of a compressed file,
|
|
** without expanding the compressed file to disk.
|
|
**
|
|
** Arguments: oLZFile - source LZFile struct identifier or DOS file handle
|
|
** lSeekTo - number of bytes past nMode target to seek
|
|
** nMode - seek mode as in _llseek()
|
|
**
|
|
** Returns: LONG - Offset of the seek target if successful. One of the
|
|
** LZERROR_ codes if unsuccessful.
|
|
**
|
|
** Globals: none
|
|
*/
|
|
LONG APIENTRY
|
|
LZSeek(
|
|
INT oLZFile,
|
|
LONG lSeekTo,
|
|
INT nMode)
|
|
{
|
|
HANDLE hSourceStruct; // handle to LZFile struct
|
|
LZFile *lpLZ; // pointer to LZFile struct
|
|
LONG lExpSeekTarget; // target seek offset
|
|
|
|
// Check input LZFile struct indentifier / DOS file handle.
|
|
if (oLZFile < 0 || oLZFile >= LZ_TABLE_BIAS + MAX_LZFILES)
|
|
return(LZERROR_BADINHANDLE);
|
|
|
|
// We were passed a regular DOS file handle, so just do an _llseek() on it.
|
|
if (oLZFile < LZ_TABLE_BIAS)
|
|
return(FSEEK(ConvertDosFHToWin32(oLZFile), lSeekTo, nMode));
|
|
|
|
// We're dealing with a compressed file. Get the associated LZFile struct.
|
|
hSourceStruct = rghLZFileTable[oLZFile - LZ_TABLE_BIAS];
|
|
|
|
if ((lpLZ = (LZFile *)GlobalLock(hSourceStruct)) == NULL)
|
|
return(LZERROR_GLOBLOCK);
|
|
|
|
// Figure out what our seek target is.
|
|
if (nMode == SEEK_SET)
|
|
lExpSeekTarget = 0L;
|
|
else if (nMode == SEEK_CUR)
|
|
lExpSeekTarget = lpLZ->lCurSeekPos;
|
|
else if (nMode == SEEK_END)
|
|
lExpSeekTarget = (LONG)lpLZ->cbulUncompSize;
|
|
else
|
|
{
|
|
GlobalUnlock(hSourceStruct);
|
|
return(LZERROR_BADVALUE);
|
|
}
|
|
|
|
// Add bias.
|
|
lExpSeekTarget += lSeekTo;
|
|
|
|
// Make sure the desired expanded file position is in the expanded file
|
|
// bounds. It's only an error to seek before the beginning of the file;
|
|
// it's not an error to seek after the end of the file, as in _llseek().
|
|
if (lExpSeekTarget < 0L)
|
|
{
|
|
GlobalUnlock(hSourceStruct);
|
|
return(LZERROR_BADVALUE);
|
|
}
|
|
|
|
// Seek target is ok. Set the file pointer for the expanded file image.
|
|
lpLZ->lCurSeekPos = lExpSeekTarget;
|
|
|
|
GlobalUnlock(hSourceStruct);
|
|
|
|
// Return the offset of the seek target.
|
|
return(lExpSeekTarget);
|
|
}
|
|
|
|
|
|
/*
|
|
** int APIENTRY LZRead(int oLZFile, LPSTR lpBuf, int nCount);
|
|
**
|
|
** Works like _lread(), but in the expanded image of a compressed file,
|
|
** without expanding the compressed file to disk.
|
|
**
|
|
** Arguments: oLZFile - source LZFile struct identifier or DOS file handle
|
|
** lpBuf - pointer to destination buffer for bytes read
|
|
** nCount - number of bytes to read
|
|
**
|
|
** Returns: int - Number of bytes copied to destination buffer if
|
|
** successful. One of the LZERROR_ codes if unsuccessful.
|
|
**
|
|
** Globals: none
|
|
*/
|
|
INT APIENTRY LZRead(INT oLZFile, LPSTR lpBuf, INT nCount)
|
|
{
|
|
INT f;
|
|
HANDLE hSourceStruct; // handle to LZFile struct
|
|
LZFile *lpLZ; // pointer to LZFile struct
|
|
|
|
INT cbWritten = 0, // total number of bytes copied to
|
|
// destination buffer
|
|
cbCopied, // number of bytes copied to destination
|
|
// buffer during each read iteration
|
|
iCurReadPos, // current read offset in expanded buffer
|
|
nNumExpBufBytes; // number of bytes in expanded data buffer
|
|
LONG lNextDecodeTarget, // expanded file image read target for decoding
|
|
lStartCopyOffset, // expanded file buffer offset where we should
|
|
// start copying to destination buffer (cast
|
|
// to iCurReadPos when this start position
|
|
// is actually in the buffer)
|
|
lNextExpEndOffset; // expanded file offset of the start of the
|
|
// next desired block of expanded data
|
|
BOOL bRestartDecoding; // flag indicating whether or not decoding
|
|
// needs to be restarted, set to TRUE when
|
|
// the current seek position is smaller than
|
|
// the offset of the beginning of the
|
|
// expanded file buffer
|
|
BYTE *lpbyteBuf; // byte pointer version of lpBuf
|
|
|
|
LONG lExpBufStart;
|
|
LONG lExpBufEnd;
|
|
|
|
PLZINFO pLZI;
|
|
|
|
// Check input LZFile struct indentifier / DOS file handle.
|
|
if (oLZFile < 0 || oLZFile >= LZ_TABLE_BIAS + MAX_LZFILES)
|
|
return(LZERROR_BADINHANDLE);
|
|
|
|
// Can't read a negative number of bytes.
|
|
if (nCount < 0)
|
|
return(LZERROR_BADVALUE);
|
|
|
|
// We were passed a regular DOS file handle, so just do an _lread() on it.
|
|
if (oLZFile < LZ_TABLE_BIAS)
|
|
return(FREAD(ConvertDosFHToWin32(oLZFile), lpBuf, nCount));
|
|
|
|
// We're dealing with a compressed file. Get the associated LZFile struct.
|
|
hSourceStruct = rghLZFileTable[oLZFile - LZ_TABLE_BIAS];
|
|
|
|
if ((lpLZ = (LZFile *)GlobalLock(hSourceStruct)) == NULL)
|
|
return(LZERROR_GLOBLOCK);
|
|
|
|
if (!(pLZI = lpLZ->pLZI)) {
|
|
// Initialize buffers
|
|
lpLZ->pLZI = InitGlobalBuffers(EXP_BUF_LEN, MAX_RING_BUF_LEN, IN_BUF_LEN + 1);
|
|
|
|
if (!(pLZI = lpLZ->pLZI)) {
|
|
GlobalUnlock(hSourceStruct);
|
|
return(LZERROR_GLOBALLOC);
|
|
}
|
|
|
|
ResetBuffers();
|
|
}
|
|
|
|
lExpBufStart = pLZI->cblOutSize - (LONG)(pLZI->pbyteOutBuf - pLZI->rgbyteOutBuf);
|
|
lExpBufEnd = (LONG)(pLZI->pbyteOutBufEnd - pLZI->rgbyteOutBuf);
|
|
|
|
// Do we need to restart decoding?
|
|
if (! (lpLZ->wFlags & LZF_INITIALIZED))
|
|
{
|
|
lpLZ->wFlags |= LZF_INITIALIZED;
|
|
bRestartDecoding = TRUE;
|
|
}
|
|
else if (lpLZ->lCurSeekPos < lExpBufStart)
|
|
bRestartDecoding = TRUE;
|
|
else
|
|
bRestartDecoding = FALSE;
|
|
|
|
// Set up byte pointer version of lpBuf.
|
|
lpbyteBuf = lpBuf;
|
|
|
|
// Copy bytes until buffer is filled or EOF in expanded file image is
|
|
// reached.
|
|
while (nCount > 0 && lpLZ->lCurSeekPos < (LONG)lpLZ->cbulUncompSize)
|
|
{
|
|
/* How many expanded data bytes are in the expanded data buffer?
|
|
* (pbyteOutBuf points AFTER the last valid byte in rgbyteOutBuf[].)
|
|
*/
|
|
nNumExpBufBytes = (INT)(pLZI->pbyteOutBuf - pLZI->rgbyteOutBuf);
|
|
|
|
/* Is the start of the desired expanded data currently in the bounds of
|
|
* the expanded data buffer?
|
|
*/
|
|
lStartCopyOffset = lpLZ->lCurSeekPos - lExpBufStart;
|
|
if (lStartCopyOffset < lExpBufEnd)
|
|
/* It's ok to set iCurReadPos to a negative value here, since we
|
|
* will only use expanded data from the expanded data buffer if
|
|
* iCurReadPos is non-negative.
|
|
*/
|
|
iCurReadPos = (INT)lStartCopyOffset;
|
|
else
|
|
iCurReadPos = -1;
|
|
|
|
/* Now, if iCurReadPos > 0, some of the expanded data in the expanded
|
|
* data buffer should be copied to the caller's buffer. If not, we
|
|
* need to continue expanding or restart expanding.
|
|
*/
|
|
if (iCurReadPos >= 0)
|
|
{
|
|
/* Copy available expanded data from expanded data buffer. */
|
|
for (cbCopied = 0;
|
|
iCurReadPos < nNumExpBufBytes && nCount > 0;
|
|
cbCopied++, nCount--)
|
|
*lpbyteBuf++ = pLZI->rgbyteOutBuf[iCurReadPos++];
|
|
|
|
// Update expanded file pointer.
|
|
lpLZ->lCurSeekPos += (LONG)cbCopied;
|
|
|
|
// Keep track of bytes written to buffer.
|
|
cbWritten += cbCopied;
|
|
}
|
|
|
|
/* Expand more data, restarting the expansion process first if
|
|
* necessary.
|
|
*/
|
|
if (nCount > 0 && lpLZ->lCurSeekPos < (LONG)lpLZ->cbulUncompSize)
|
|
{
|
|
/* If we get here, we've copied all the available expanded data out
|
|
* of rgbyteOutBuf[], through pbyteOutBuf, and we need to expand
|
|
* more data.
|
|
*/
|
|
|
|
/* Where is the end of the next desired expanded data block? */
|
|
if (bRestartDecoding)
|
|
{
|
|
/* Seek back to start of target data, allowing for buffer
|
|
* overflow.
|
|
*/
|
|
lNextExpEndOffset = lpLZ->lCurSeekPos - MAX_OVERRUN;
|
|
|
|
/* Don't try to read before offset 0! */
|
|
if (lNextExpEndOffset < 0)
|
|
lNextExpEndOffset = 0;
|
|
}
|
|
else
|
|
/* Continue decoding. */
|
|
lNextExpEndOffset = lExpBufStart
|
|
+ (LONG)nNumExpBufBytes
|
|
+ lExpBufEnd
|
|
- MAX_OVERRUN;
|
|
|
|
/* How much farther should we expand? The target decoding offset
|
|
* should be the smallest expanded file offset of the following:
|
|
*
|
|
* 1) the last byte in the largest expanded data block that will
|
|
* safely fit in the expanded data buffer, while guaranteeing
|
|
* that the start of this block is also in the expanded data
|
|
* buffer
|
|
* 2) the last requested expanded data byte
|
|
* 3) the last byte in the expanded file
|
|
*/
|
|
lNextDecodeTarget = MIN(lNextExpEndOffset,
|
|
MIN(lpLZ->lCurSeekPos + (LONG)nCount,
|
|
(LONG)lpLZ->cbulUncompSize - 1L));
|
|
|
|
// Reset expanded data buffer to empty state.
|
|
pLZI->pbyteOutBuf = pLZI->rgbyteOutBuf;
|
|
|
|
// Refill rgbyteOutBuf[] with expanded data.
|
|
switch (lpLZ->byteAlgorithm)
|
|
{
|
|
case ALG_FIRST:
|
|
f = LZDecode(lpLZ->dosh, NO_DOSH, lNextDecodeTarget,
|
|
bRestartDecoding, TRUE, pLZI);
|
|
break;
|
|
|
|
default:
|
|
f = LZERROR_UNKNOWNALG;
|
|
break;
|
|
}
|
|
|
|
// Did the decoding go ok?
|
|
if (f != TRUE)
|
|
{
|
|
// Uh oh. Something went wrong.
|
|
GlobalUnlock(hSourceStruct);
|
|
return(f);
|
|
}
|
|
|
|
/* Now how many expanded data bytes are in the expanded data buffer?
|
|
* (pbyteOutBuf points AFTER the last valid byte in rgbyteOutBuf[].)
|
|
*/
|
|
#if DEBUG
|
|
printf("pbyteOutBuf: 0x%x, rgbyteOutBuf: 0x%x \n", pLZI->pbyteOutBuf, pLZI->rgbyteOutBuf);
|
|
#endif
|
|
|
|
nNumExpBufBytes = (INT)(pLZI->pbyteOutBuf - pLZI->rgbyteOutBuf);
|
|
|
|
/* Check to make sure we actually read some bytes. */
|
|
if (nNumExpBufBytes <= 0)
|
|
{
|
|
GlobalUnlock(hSourceStruct);
|
|
return(LZERROR_READ);
|
|
}
|
|
|
|
/* What is the offset of the start of the expanded data buffer in
|
|
* the expanded file image?
|
|
*/
|
|
lExpBufStart = pLZI->cblOutSize - (LONG)nNumExpBufBytes;
|
|
|
|
/* Did LZDecode() satisfy the read request, or did the compressed
|
|
* file end prematurely?
|
|
*/
|
|
if (pLZI->cblOutSize < lNextDecodeTarget)
|
|
{
|
|
/* Oh oh. lNextDecodeTarget cannot exceed the expanded file
|
|
* bounds, so the compressed file must have ended prematurely.
|
|
*/
|
|
GlobalUnlock(hSourceStruct);
|
|
return(LZERROR_READ);
|
|
}
|
|
|
|
// Reset flag so we continue decoding where we left off.
|
|
bRestartDecoding = FALSE;
|
|
}
|
|
}
|
|
|
|
GlobalUnlock(hSourceStruct);
|
|
|
|
// Return number of bytes copied to destination buffer.
|
|
return(cbWritten);
|
|
}
|
|
|
|
//
|
|
// VOID LZCloseFile(INT oLZFile);
|
|
//
|
|
// Close a file and free the associated LZFile struct.
|
|
//
|
|
// Arguments: oLZFile - source LZFile struct identifier or WIN32 file handle
|
|
//
|
|
// Returns: VOID
|
|
//
|
|
// Globals: rghLZFileTable[] entry cleared.
|
|
//
|
|
|
|
VOID
|
|
LZCloseFile(
|
|
INT oLZFile)
|
|
{
|
|
HANDLE hSourceStruct; // handle to LZFile struct
|
|
LZFile *lpLZ; // pointer to LZFile struct
|
|
|
|
// Check input LZFile struct indentifier / DOS file handle.
|
|
if (oLZFile < 0 || oLZFile >= LZ_TABLE_BIAS + MAX_LZFILES)
|
|
return;
|
|
|
|
// We were passed a regular DOS file handle, so just close it.
|
|
if (oLZFile < LZ_TABLE_BIAS) {
|
|
CloseHandle((HANDLE)IntToPtr(ConvertDosFHToWin32(oLZFile)));
|
|
// also need to clean out the file array entry
|
|
fhWin32File[oLZFile] = 0;
|
|
|
|
return;
|
|
}
|
|
|
|
// We're dealing with a compressed file. Get the associated LZFile struct.
|
|
hSourceStruct = rghLZFileTable[oLZFile - LZ_TABLE_BIAS];
|
|
|
|
// Clear rghLZFIleTable[] entry.
|
|
rghLZFileTable[oLZFile - LZ_TABLE_BIAS] = NULL;
|
|
|
|
// Close the file and free the associated LZFile struct.
|
|
if ((lpLZ = (LZFile *)GlobalLock(hSourceStruct)) != NULL)
|
|
{
|
|
CloseHandle((HANDLE)IntToPtr(lpLZ->dosh));
|
|
|
|
if (lpLZ->pLZI) {
|
|
FreeGlobalBuffers(lpLZ->pLZI);
|
|
}
|
|
|
|
GlobalUnlock(hSourceStruct);
|
|
|
|
GlobalFree(hSourceStruct);
|
|
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
/*
|
|
** VOID APIENTRY LZClose(int oLZFile);
|
|
**
|
|
** Close a file and free the associated LZFile struct.
|
|
**
|
|
** Arguments: oLZFile - source LZFile struct identifier or DOS file handle
|
|
**
|
|
** Returns: VOID
|
|
**
|
|
** Globals: rghLZFileTable[] entry cleared.
|
|
*/
|
|
VOID APIENTRY LZClose(INT oLZFile)
|
|
{
|
|
HANDLE hSourceStruct; // handle to LZFile struct
|
|
LZFile *lpLZ; // pointer to LZFile struct
|
|
|
|
// Check input LZFile struct indentifier / DOS file handle.
|
|
if (oLZFile < 0 || oLZFile >= LZ_TABLE_BIAS + MAX_LZFILES)
|
|
return;
|
|
|
|
// We were passed a regular DOS file handle, so just close it.
|
|
if (oLZFile < LZ_TABLE_BIAS)
|
|
{
|
|
FCLOSE(ConvertDosFHToWin32(oLZFile));
|
|
/* also need to clean out the file array entry */
|
|
fhWin32File[oLZFile] = 0;
|
|
|
|
return;
|
|
}
|
|
|
|
// We're dealing with a compressed file. Get the associated LZFile struct.
|
|
hSourceStruct = rghLZFileTable[oLZFile - LZ_TABLE_BIAS];
|
|
|
|
// Clear rghLZFIleTable[] entry.
|
|
rghLZFileTable[oLZFile - LZ_TABLE_BIAS] = NULL;
|
|
|
|
// Close the file and free the associated LZFile struct.
|
|
if ((lpLZ = (LZFile *)GlobalLock(hSourceStruct)) != NULL)
|
|
{
|
|
FCLOSE(lpLZ->dosh);
|
|
|
|
if (lpLZ->pLZI) {
|
|
FreeGlobalBuffers(lpLZ->pLZI);
|
|
}
|
|
|
|
GlobalUnlock(hSourceStruct);
|
|
|
|
GlobalFree(hSourceStruct);
|
|
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
/* WIN32 MODS */
|
|
|
|
INT ConvertWin32FHToDos(HFILE DoshSource)
|
|
{
|
|
INT x;
|
|
|
|
/* here we are given an NT file handle, need save this into
|
|
* fhWin32File[], test for overflow, also need see
|
|
* if there is a free slot in the array */
|
|
|
|
/* If error, return greater than MAX_LZFILES */
|
|
|
|
RtlEnterCriticalSection(&BaseLZSemTable);
|
|
|
|
/* walk array, looking for a free slot (free slot = 0) */
|
|
for(x = 0; x < MAX_LZFILES; x++){
|
|
if(fhWin32File[x] == 0)
|
|
break;
|
|
}
|
|
if(x < MAX_LZFILES){
|
|
/* no overflow, save into array*/
|
|
fhWin32File[x] = DoshSource;
|
|
}
|
|
else{
|
|
x = LZERROR_GLOBALLOC;
|
|
}
|
|
|
|
RtlLeaveCriticalSection(&BaseLZSemTable);
|
|
|
|
return(x);
|
|
|
|
}
|
|
|
|
|
|
HFILE ConvertDosFHToWin32(INT DoshSource)
|
|
{
|
|
|
|
/* here, we are given the pseudo Dos File Handle, need convert to
|
|
* real file handle, for use by API.
|
|
*/
|
|
|
|
if (DoshSource >= MAX_LZFILES || DoshSource < 0 ||
|
|
fhWin32File[DoshSource] == 0) {
|
|
return (HFILE)DoshSource;
|
|
}
|
|
else{
|
|
return(fhWin32File[DoshSource]);
|
|
}
|
|
|
|
}
|