int main(int argc, char *argv[])
{
OFSTRUCT SourceOpenStruct1, SourceOpenStruct2;
LONG ret;
HFILE hSourceFile, hDestFile;
if (argc < 2)
{
fprintf( stderr, "Usage: %s infile [outfile]\n", argv[0] );
return 1;
}
hSourceFile = LZOpenFile(argv[1], &SourceOpenStruct1, OF_READ);
if (argv[2])
hDestFile = LZOpenFile(argv[2], &SourceOpenStruct2, OF_CREATE | OF_WRITE);
else
{
char OriginalName[MAX_PATH];
GetExpandedName(argv[1], OriginalName);
hDestFile = LZOpenFile(OriginalName, &SourceOpenStruct2, OF_CREATE | OF_WRITE);
}
ret = LZCopy(hSourceFile, hDestFile);
LZClose(hSourceFile);
LZClose(hDestFile);
if (ret <= 0) fprintf(stderr,"LZCopy failed: return is %ld\n",ret);
return (ret <= 0);
}
static DWORD decompress_file_lz( LPCWSTR source, LPCWSTR target )
{
DWORD ret;
LONG error;
INT src, dst;
OFSTRUCT sof, dof;
if ((src = LZOpenFileW( (LPWSTR)source, &sof, OF_READ )) < 0)
{
ERR("cannot open source file for reading\n");
return ERROR_FILE_NOT_FOUND;
}
if ((dst = LZOpenFileW( (LPWSTR)target, &dof, OF_CREATE )) < 0)
{
ERR("cannot open target file for writing\n");
LZClose( src );
return ERROR_FILE_NOT_FOUND;
}
if ((error = LZCopy( src, dst )) >= 0) ret = ERROR_SUCCESS;
else
{
WARN("failed to decompress file %d\n", error);
ret = ERROR_INVALID_DATA;
}
LZClose( src );
LZClose( dst );
return ret;
}
BOOL My_LZClose()
{
INT hFile=NULL;
DWORD error_Real = 0;
DWORD error_Intercepted = 0;
disableInterception();
LZClose (hFile);
error_Real = GetLastError();
enableInterception();
LZClose (hFile);
error_Intercepted = GetLastError();
return (error_Real == error_Intercepted);
}
static BOOL get_file_sizes_lz( LPCWSTR source, DWORD *source_size, DWORD *target_size )
{
DWORD size;
BOOL ret = TRUE;
if (source_size)
{
if (!get_file_size( source, &size )) ret = FALSE;
else *source_size = size;
}
if (target_size)
{
INT file;
OFSTRUCT of;
if ((file = LZOpenFileW( (LPWSTR)source, &of, OF_READ )) < 0)
{
ERR("cannot open source file for reading\n");
return FALSE;
}
*target_size = LZSeek( file, 0, 2 );
LZClose( file );
}
return ret;
}
BOOL My_LZClose()
{
INT hFile=NULL;
DWORD error_Real = 0;
DWORD error_Intercepted = 0;
__try{
disableInterception();
LZClose (hFile);
error_Real = GetLastError();
enableInterception();
LZClose (hFile);
error_Intercepted = GetLastError();
}__except(puts("in filter"), 1){puts("exception caught");}
return (error_Real == error_Intercepted);
}
/***********************************************************************
* LZCopy (KERNEL32.@)
*
* Copies everything from src to dest
* if src is a LZ compressed file, it will be uncompressed.
* will return the number of bytes written to dest or errors.
*/
LONG WINAPI LZCopy( HFILE src, HFILE dest )
{
int usedlzinit = 0, ret, wret;
LONG len;
HFILE oldsrc = src, srcfd;
FILETIME filetime;
struct lzstate *lzs;
#define BUFLEN 1000
CHAR buf[BUFLEN];
/* we need that weird typedef, for i can't seem to get function pointer
* casts right. (Or they probably just do not like WINAPI in general)
*/
typedef UINT (WINAPI *_readfun)(HFILE,LPVOID,UINT);
_readfun xread;
DPRINT("(%d,%d)\n",src,dest);
if (!IS_LZ_HANDLE(src)) {
src = LZInit(src);
if ((INT)src <= 0) return 0;
if (src != oldsrc) usedlzinit=1;
}
/* not compressed? just copy */
if (!IS_LZ_HANDLE(src))
xread=_lread;
else
xread=(_readfun)LZRead;
len=0;
while (1) {
ret=xread(src,buf,BUFLEN);
if (ret<=0) {
if (ret==0)
break;
if (ret==-1)
return LZERROR_READ;
return ret;
}
len += ret;
wret = _hwrite(dest,buf,ret);
if (wret!=ret)
return LZERROR_WRITE;
}
/* Maintain the timestamp of source file to destination file */
srcfd = (!(lzs = GET_LZ_STATE(src))) ? src : lzs->realfd;
GetFileTime( LongToHandle(srcfd), NULL, NULL, &filetime );
SetFileTime( LongToHandle(dest), NULL, NULL, &filetime );
/* close handle */
if (usedlzinit)
LZClose(src);
return len;
#undef BUFLEN
}
// @pymethod |win32lz|Close|Closes a handle to an LZ file.
static PyObject *
PyLZClose(PyObject *self, PyObject *args)
{
int h;
if (!PyArg_ParseTuple(args, "i:Close", &h )) // @pyparm int|handle||The handle of the LZ file to close.
return NULL;
// @pyseeapi LZClose
LZClose(h);
Py_INCREF(Py_None);
return (Py_None);
}
/***********************************************************************
* LZCopy (LZEXPAND.1)
*
*/
LONG WINAPI LZCopy16( HFILE16 src, HFILE16 dest )
{
/* already a LZ handle? */
if (IS_LZ_HANDLE(src)) return LZCopy( src, (HFILE)DosFileHandleToWin32Handle(dest) );
/* no, try to open one */
src = LZInit16(src);
if ((INT16)src <= 0) return 0;
if (IS_LZ_HANDLE(src))
{
LONG ret = LZCopy( src, (HFILE)DosFileHandleToWin32Handle(dest) );
LZClose( src );
return ret;
}
/* it was not a compressed file */
return LZCopy( (HFILE)DosFileHandleToWin32Handle(src), (HFILE)DosFileHandleToWin32Handle(dest) );
}
/***********************************************************************
* LZClose (LZEXPAND.6)
*/
void WINAPI LZClose16( HFILE16 fd )
{
if (IS_LZ_HANDLE(fd)) LZClose( fd );
else DisposeLZ32Handle( DosFileHandleToWin32Handle((HFILE)fd) );
}
int main(int argc, char *argv[])
{
int ret = 0;
char infile[MAX_PATH], outfile[MAX_PATH], actual_name[MAX_PATH];
char outfile_basename[MAX_PATH], *basename_index;
UINT comp;
if (argc < 3)
{
myprintf( "Usage:\n" );
myprintf( "\t%s infile outfile\n", argv[0] );
myprintf( "\t%s /r infile\n", argv[0] );
return 1;
}
if (argc == 3 && (option_equal(argv[1], "R") || option_equal(argv[1], "r")))
GetFullPathNameA( argv[2], sizeof(infile), infile, NULL );
else
GetFullPathNameA( argv[1], sizeof(infile), infile, NULL );
if (!SetupGetFileCompressionInfoExA( infile, actual_name, sizeof(actual_name), NULL, NULL, NULL, &comp ))
{
myprintf( "%s: can't open input file %s\n", argv[0], infile );
return 1;
}
if (argc == 3 && (option_equal(argv[1], "R") || option_equal(argv[1], "r")))
{
switch (comp)
{
case FILE_COMPRESSION_MSZIP:
outfile_basename[0] = 0;
if (!SetupIterateCabinetA( infile, 0, set_outfile, outfile_basename ))
{
myprintf( "%s: can't determine original name\n", argv[0] );
return 1;
}
GetFullPathNameA( infile, sizeof(outfile), outfile, &basename_index );
*basename_index = 0;
strcat( outfile, outfile_basename );
break;
case FILE_COMPRESSION_WINLZA:
GetExpandedNameA( infile, outfile_basename );
break;
default:
myprintf( "%s: can't determine original\n", argv[0] );
return 1;
}
}
else
GetFullPathNameA( argv[2], sizeof(outfile), outfile, NULL );
if (!lstrcmpiA( infile, outfile ))
{
myprintf( "%s: can't expand file to itself\n", argv[0] );
return 1;
}
switch (comp)
{
case FILE_COMPRESSION_MSZIP:
if (!SetupIterateCabinetA( infile, 0, extract_callback, outfile ))
{
myprintf( "%s: cabinet extraction failed\n", argv[0] );
return 1;
}
break;
case FILE_COMPRESSION_WINLZA:
{
INT hin, hout;
OFSTRUCT ofin, ofout;
LONG error;
if ((hin = LZOpenFileA( infile, &ofin, OF_READ )) < 0)
{
myprintf( "%s: can't open input file %s\n", argv[0], infile );
return 1;
}
if ((hout = LZOpenFileA( outfile, &ofout, OF_CREATE | OF_WRITE )) < 0)
{
LZClose( hin );
myprintf( "%s: can't open output file %s\n", argv[0], outfile );
return 1;
}
error = LZCopy( hin, hout );
LZClose( hin );
LZClose( hout );
if (error < 0)
{
myprintf( "%s: LZCopy failed, error is %d\n", argv[0], error );
return 1;
}
break;
}
default:
if (!CopyFileA( infile, outfile, FALSE ))
{
myprintf( "%s: CopyFileA failed\n", argv[0] );
return 1;
}
break;
}
return ret;
}
