mirror of https://github.com/tongzx/nt5src
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.
599 lines
18 KiB
599 lines
18 KiB
/*
|
|
** main.c - Main module for DOS command-line LZA file compression / expansion
|
|
** programs.
|
|
**
|
|
** Author: DavidDi
|
|
**
|
|
** This module is compiled twice - once for COMPRESS (COMPRESS defined) and
|
|
** once for EXPAND (COMPRESS not defined).
|
|
*/
|
|
|
|
|
|
// Headers
|
|
///////////
|
|
|
|
#include <malloc.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
|
|
#include "lz_common.h"
|
|
#include "lz_buffers.h"
|
|
#include "lz_header.h"
|
|
|
|
#include "args.h"
|
|
#include "main.h"
|
|
#include "messages.h"
|
|
|
|
//
|
|
// diamond routines
|
|
//
|
|
#include "mydiam.h"
|
|
|
|
// Globals
|
|
///////////
|
|
|
|
CHAR ARG_PTR *pszInFileName, // input file name
|
|
*pszOutFileName, // output file name
|
|
*pszTargetName; // target path name
|
|
|
|
TCHAR ErrorMsg[2048];
|
|
|
|
BOOL bContainsMultipleFiles; // Is source file a multi-file CAB?
|
|
INT nLocalFiles, nTotalFiles = 0; // number of files listed/expanded
|
|
|
|
|
|
// Module Variables
|
|
////////////////////
|
|
|
|
#ifndef COMPRESS
|
|
static BOOL bCopyingFile; // Is current file being copied or expanded?
|
|
#endif
|
|
|
|
|
|
// Local Prototypes
|
|
////////////////////
|
|
|
|
static VOID DisplayErrorMessage(INT fError);
|
|
static VOID MakeDestFileName(CHAR ARG_PTR *argv[], CHAR ARG_PTR *pszDest);
|
|
static BOOL GetCanonicalName(LPSTR lpszFileName, LPSTR lpszCanonicalBuf);
|
|
static BOOL ActuallyTheSameFile(CHAR ARG_PTR *pszFile1,
|
|
CHAR ARG_PTR *pszFile2);
|
|
static BOOL ProcessNotification(CHAR ARG_PTR *pszSource,
|
|
CHAR ARG_PTR *pszDest, WORD wNotification);
|
|
|
|
|
|
/*
|
|
** static void DisplayErrorMessage(int fError);
|
|
**
|
|
** Display error message for given error condition.
|
|
**
|
|
** Arguments: LZERROR_ code
|
|
**
|
|
** Returns: void
|
|
**
|
|
** Globals: none
|
|
*/
|
|
static VOID DisplayErrorMessage(INT fError)
|
|
{
|
|
|
|
switch(fError)
|
|
{
|
|
case LZERROR_BADINHANDLE:
|
|
LoadString(NULL, SID_NO_OPEN_INPUT, ErrorMsg, 2048);
|
|
// WARNING: Cannot call CharToOemW with src=dest
|
|
CharToOem(ErrorMsg, ErrorMsg);
|
|
printf(ErrorMsg, pszInFileName);
|
|
break;
|
|
|
|
case LZERROR_BADOUTHANDLE:
|
|
LoadString(NULL, SID_NO_OPEN_OUTPUT, ErrorMsg, 2048);
|
|
// WARNING: Cannot call CharToOemW with src=dest
|
|
CharToOem(ErrorMsg, ErrorMsg);
|
|
printf(ErrorMsg, pszOutFileName);
|
|
break;
|
|
|
|
case LZERROR_READ:
|
|
LoadString(NULL, SID_FORMAT_ERROR, ErrorMsg, 2048);
|
|
// WARNING: Cannot call CharToOemW with src=dest
|
|
CharToOem(ErrorMsg, ErrorMsg);
|
|
printf(ErrorMsg, pszInFileName);
|
|
break;
|
|
|
|
case LZERROR_WRITE:
|
|
LoadString(NULL, SID_OUT_OF_SPACE, ErrorMsg, 2048);
|
|
// WARNING: Cannot call CharToOemW with src=dest
|
|
CharToOem(ErrorMsg, ErrorMsg);
|
|
printf(ErrorMsg, pszOutFileName);
|
|
break;
|
|
|
|
case LZERROR_UNKNOWNALG:
|
|
LoadString(NULL, SID_UNKNOWN_ALG, ErrorMsg, 2048);
|
|
// WARNING: Cannot call CharToOemW with src=dest
|
|
CharToOem(ErrorMsg, ErrorMsg);
|
|
printf(ErrorMsg, pszInFileName);
|
|
break;
|
|
|
|
case BLANK_ERROR:
|
|
break;
|
|
|
|
default:
|
|
LoadString(NULL, SID_GEN_FAILURE, ErrorMsg, 2048);
|
|
// WARNING: Cannot call CharToOemW with src=dest
|
|
CharToOem(ErrorMsg, ErrorMsg);
|
|
printf(ErrorMsg, pszInFileName, pszOutFileName);
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
** static void MakeDestFileName(char ARG_PTR *argv[], char ARG_PTR *pszDest);
|
|
**
|
|
** Create the appropriate destination file name.
|
|
**
|
|
** Arguments: argv - like argument to main()
|
|
** pszDest - pointer to destination file name buffer to be filled
|
|
** in
|
|
**
|
|
** Returns: void
|
|
**
|
|
** Globals: none
|
|
*/
|
|
static VOID MakeDestFileName(CHAR ARG_PTR *argv[], CHAR ARG_PTR *pszDest)
|
|
{
|
|
CHAR ARG_PTR *pszDestFile;
|
|
|
|
if (nNumFileSpecs == 2 && bTargetIsDir == FALSE && bDoRename == FALSE)
|
|
// Compress a single input file to a single output file. N.b., we must
|
|
// be careful to eat up the output file name command-line argument so
|
|
// it doesn't get processed like another input file!
|
|
STRCPY(pszDest, argv[GetNextFileArg(argv)]);
|
|
else if (bTargetIsDir == TRUE)
|
|
{
|
|
// Prepend output file name with destination directory path name.
|
|
STRCPY(pszDest, pszTargetName);
|
|
|
|
// Isolate source file name from source file specification.
|
|
pszDestFile = ExtractFileName(pszInFileName);
|
|
|
|
// Add destination file name to destination directory path
|
|
// specification.
|
|
MakePathName(pszDest, pszDestFile);
|
|
}
|
|
else
|
|
// Destination file name same as source file name. N.b., this is an
|
|
// error condition if (bDoRename == FALSE).
|
|
STRCPY(pszDest, pszInFileName);
|
|
}
|
|
|
|
|
|
/*
|
|
** static BOOL GetCanonicalName(LPSTR lpszFileName, LPSTR lpszCanonicalBuf);
|
|
**
|
|
** Gets the canonical name for a given file specification.
|
|
**
|
|
** Arguments: pszFileName - file specification
|
|
** szCanonicalBuf - buffer to be filled with canonical name
|
|
**
|
|
** Returns: TRUE if successful. FALSE if unsuccessful.
|
|
**
|
|
** N.b., szCanonicalBuf must be at least 128 bytes long. The contents of
|
|
** szCanonicalBuf are only defined if the funstion returns TRUE.
|
|
**
|
|
*/
|
|
static BOOL GetCanonicalName(LPSTR lpszFileName, LPSTR lpszCanonicalBuf)
|
|
{
|
|
BOOL bRetVal = FALSE;
|
|
LPSTR lpszLastComp;
|
|
|
|
return((BOOL) GetFullPathName(lpszFileName, MAX_PATH, lpszCanonicalBuf, &lpszLastComp));
|
|
}
|
|
|
|
|
|
/*
|
|
** static BOOL ActuallyTheSameFile(char ARG_PTR *pszFile1,
|
|
** char ARG_PTR *pszFile2);
|
|
**
|
|
** Checks to see if two file specifications point to the same physical file.
|
|
**
|
|
** Arguments: pszFile1 - first file specification
|
|
** pszFile2 - second file specification
|
|
**
|
|
** Returns: BOOL - TRUE if the file specifications point to the same
|
|
** physical file. FALSE if not.
|
|
**
|
|
** Globals: none
|
|
*/
|
|
static BOOL ActuallyTheSameFile(CHAR ARG_PTR *pszFile1,
|
|
CHAR ARG_PTR *pszFile2)
|
|
{
|
|
CHAR szCanonicalName1[MAX_PATH],
|
|
szCanonicalName2[MAX_PATH];
|
|
|
|
if (GetCanonicalName(pszFile1, szCanonicalName1) &&
|
|
GetCanonicalName(pszFile2, szCanonicalName2))
|
|
{
|
|
if (! lstrcmpiA(szCanonicalName1, szCanonicalName2))
|
|
return(TRUE);
|
|
}
|
|
|
|
return(FALSE);
|
|
}
|
|
|
|
|
|
/*
|
|
** static BOOL ProcessNotification(char ARG_PTR *pszSource,
|
|
** char ARG_PTR *pszDest,
|
|
** WORD wNotification);
|
|
**
|
|
** Callback function during file processing.
|
|
**
|
|
** Arguments: pszSource - source file name
|
|
** pszDest - destination file name
|
|
** wNotification - process type query
|
|
**
|
|
** Returns: BOOL - (wNotification == NOTIFY_START_*):
|
|
** TRUE if the source file should be "processed" into
|
|
** the destination file. FALSE if not.
|
|
** else
|
|
** TRUE.
|
|
**
|
|
** Globals: none
|
|
*/
|
|
static BOOL ProcessNotification(CHAR ARG_PTR *pszSource,
|
|
CHAR ARG_PTR *pszDest, WORD wNotification)
|
|
{
|
|
switch(wNotification)
|
|
{
|
|
case NOTIFY_START_EXPAND:
|
|
case NOTIFY_START_COPY:
|
|
{
|
|
// If we're listing files, display the name then tell caller to skip.
|
|
|
|
if (bDoListFiles == TRUE)
|
|
{
|
|
PSTR p;
|
|
|
|
//
|
|
// Display just the base name from the target. The prefix of the
|
|
// target path is garbage (the source path.)
|
|
//
|
|
if(p = StringRevChar(pszDest,'\\')) {
|
|
p++;
|
|
} else {
|
|
p = pszDest;
|
|
}
|
|
|
|
LoadString(NULL, SID_LISTING, ErrorMsg, 2048);
|
|
CharToOem(ErrorMsg, ErrorMsg);
|
|
printf(ErrorMsg, pszSource, p);
|
|
|
|
nLocalFiles++; // count files listed
|
|
nTotalFiles++; // count files listed
|
|
|
|
return(FALSE); // always skip file
|
|
}
|
|
|
|
// Fail if the source and destination files are identical.
|
|
if (ActuallyTheSameFile(pszSource, pszDest))
|
|
{
|
|
LoadString(NULL, SID_COLLISION, ErrorMsg, 2048);
|
|
// WARNING: Cannot call CharToOemW with src=dest
|
|
CharToOem(ErrorMsg, ErrorMsg);
|
|
printf(ErrorMsg, pszSource);
|
|
return(FALSE);
|
|
}
|
|
|
|
nLocalFiles++; // count files expanded
|
|
nTotalFiles++; // count files expanded
|
|
|
|
// Display start message.
|
|
if (wNotification == NOTIFY_START_EXPAND) {
|
|
LoadString(NULL, SID_EXPANDING, ErrorMsg, 2048);
|
|
// WARNING: Cannot call CharToOemW with src=dest
|
|
CharToOem(ErrorMsg, ErrorMsg);
|
|
printf(ErrorMsg, pszSource, pszDest);
|
|
}
|
|
else // NOTIFY_START_COPY
|
|
{
|
|
bCopyingFile = TRUE;
|
|
LoadString(NULL, SID_COPYING, ErrorMsg, 2048);
|
|
// WARNING: Cannot call CharToOemW with src=dest
|
|
CharToOem(ErrorMsg, ErrorMsg);
|
|
printf(ErrorMsg, pszSource, pszDest);
|
|
}
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return(TRUE);
|
|
}
|
|
|
|
|
|
/*
|
|
** int main(int argc, char *argv[]);
|
|
**
|
|
** Run command-line file compression program.
|
|
**
|
|
** Arguments: figure it out
|
|
**
|
|
** Returns: int - EXIT_SUCCESS if compression finished successfully,
|
|
** EXIT_FAILURE if not.
|
|
**
|
|
** Globals: none
|
|
*/
|
|
INT __cdecl main(INT argc, CHAR *argv[])
|
|
{
|
|
INT iSourceFileName,
|
|
fError,
|
|
nReturnCode = EXIT_SUCCESS;
|
|
CHAR ARG_PTR pszDestFileName[MAX_PATH];
|
|
LONG cblTotInSize = 0L,
|
|
cblTotOutSize = 0L;
|
|
PLZINFO pLZI;
|
|
BOOL fIsDiamondFile;
|
|
CHAR ARG_PTR *pszFilesSpec;
|
|
BOOL fReportStats = TRUE; // cleared if any multi-file CABs or listing
|
|
|
|
USHORT wLanguageId = LANGIDFROMLCID(GetThreadLocale());
|
|
|
|
if ((LANG_JAPANESE == PRIMARYLANGID(wLanguageId)) ||
|
|
(LANG_KOREAN == PRIMARYLANGID(wLanguageId)) ||
|
|
(LANG_CHINESE == PRIMARYLANGID(wLanguageId)))
|
|
{
|
|
//
|
|
// This used to be #ifdef DBCS. Now a runtime check.
|
|
//
|
|
DWORD dw = GetConsoleOutputCP();
|
|
|
|
// WARNING: in product 1.1 we need to uncomment the SetConsole above
|
|
// LoadString will return Ansi and printf will just pass it on
|
|
// This will let cmd interpret the characters it gets.
|
|
// SetConsoleOutputCP(GetACP());
|
|
|
|
switch (dw) {
|
|
case 932:
|
|
case 936:
|
|
case 949:
|
|
case 950:
|
|
SetThreadLocale(MAKELCID(
|
|
MAKELANGID(
|
|
PRIMARYLANGID(GetSystemDefaultLangID()),
|
|
SUBLANG_ENGLISH_US),
|
|
SORT_DEFAULT));
|
|
break;
|
|
default:
|
|
SetThreadLocale(MAKELCID(
|
|
MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US),
|
|
SORT_DEFAULT));
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Display sign-on banner.
|
|
LoadString(NULL, SID_BANNER_TEXT, ErrorMsg, 2048);
|
|
// WARNING: Cannot call CharToOemW with src=dest
|
|
CharToOem(ErrorMsg, ErrorMsg);
|
|
printf(ErrorMsg);
|
|
|
|
// Parse command-line arguments.
|
|
if (ParseArguments(argc, argv) != TRUE)
|
|
return(EXIT_FAILURE);
|
|
|
|
// Set up global target path name.
|
|
pszTargetName = argv[iTarget];
|
|
|
|
if (bDisplayHelp == TRUE)
|
|
{
|
|
// User asked for help.
|
|
LoadString(NULL, SID_INSTRUCTIONS, ErrorMsg, 2048);
|
|
// WARNING: Cannot call CharToOemW with src=dest
|
|
CharToOem(ErrorMsg, ErrorMsg);
|
|
printf(ErrorMsg);
|
|
return(EXIT_SUCCESS);
|
|
}
|
|
|
|
// Check for command line problems.
|
|
if (CheckArguments() == FALSE)
|
|
return(EXIT_FAILURE);
|
|
|
|
// Set up ring buffer and I/O buffers.
|
|
pLZI = InitGlobalBuffersEx();
|
|
if (!pLZI || !InitDiamond())
|
|
{
|
|
LoadString(NULL, SID_INSUFF_MEM, ErrorMsg, 2048);
|
|
// WARNING: Cannot call CharToOemW with src=dest
|
|
CharToOem(ErrorMsg, ErrorMsg);
|
|
printf(ErrorMsg);
|
|
return(EXIT_FAILURE);
|
|
}
|
|
|
|
// Process each source file.
|
|
while ((iSourceFileName = GetNextFileArg(argv)) != FAIL)
|
|
{
|
|
nLocalFiles = 0;
|
|
pLZI->cblOutSize = 0;
|
|
|
|
// Set up global input file name.
|
|
pszInFileName = CharLowerA(argv[iSourceFileName]);
|
|
|
|
// Set up global output file name.
|
|
MakeDestFileName(argv, pszDestFileName);
|
|
pszOutFileName = CharLowerA(pszDestFileName);
|
|
|
|
// Assume current file will be expanded. The ProcessNotification()
|
|
// callback will change this module global to TRUE if the file is being
|
|
// copied instead of expanded.
|
|
bCopyingFile = FALSE;
|
|
|
|
//
|
|
// Determine whether the file was compressed with diamond.
|
|
// If so, we need to expand it specially.
|
|
//
|
|
fIsDiamondFile = IsDiamondFile(pszInFileName, &bContainsMultipleFiles);
|
|
if (fIsDiamondFile) {
|
|
|
|
if (bContainsMultipleFiles) {
|
|
|
|
if (nNumFileSpecs == 1 && (bDoListFiles == FALSE)) {
|
|
|
|
//
|
|
// The source file is a multi-file CAB, and is the only file
|
|
// on the command line. We'll require an explicit filespec
|
|
// which names the file(s) desired from within the CAB.
|
|
// The Files specification may contain wildcards.
|
|
//
|
|
// If the user included multiple source files on the command
|
|
// line, we'll assume they're expecting a lot of output, and
|
|
// we'll default to all files. It would be pointless to put
|
|
// up a message anyway, since the screen will be scrolling.
|
|
//
|
|
|
|
if (pszSelectiveFilesSpec == NULL) {
|
|
|
|
LoadString(NULL, SID_FILESPEC_REQUIRED, ErrorMsg, 2048);
|
|
// WARNING: Cannot call CharToOemW with src=dest
|
|
CharToOem(ErrorMsg, ErrorMsg);
|
|
printf(ErrorMsg);
|
|
continue; // skip this (the only) source file
|
|
}
|
|
}
|
|
|
|
if (!bTargetIsDir && (bDoListFiles == FALSE)) {
|
|
|
|
//
|
|
// The source file is a multi-file CAB, and the target is
|
|
// a single file. Now this just isn't going to work. We'll
|
|
// display this warning, and hope the user notices it. If
|
|
// a multiple sources were specified, they're going to get
|
|
// a mess anyway. We just won't contribute to it.
|
|
//
|
|
|
|
LoadString(NULL, SID_DEST_REQUIRED, ErrorMsg, 2048);
|
|
// WARNING: Cannot call CharToOemW with src=dest
|
|
CharToOem(ErrorMsg, ErrorMsg);
|
|
printf(ErrorMsg, pszInFileName);
|
|
continue; // skip this source file
|
|
}
|
|
|
|
pszFilesSpec = pszSelectiveFilesSpec;
|
|
|
|
//
|
|
// Don't try to interpret final stats if multi-file CABs are seen.
|
|
// (Because of selective extract and other issues, you'll get silly
|
|
// reports like "20000000 bytes expanded to 16320 bytes".)
|
|
//
|
|
|
|
fReportStats = FALSE;
|
|
|
|
} else {
|
|
|
|
//
|
|
// Legacy: no selective expand from single-file CABs
|
|
//
|
|
|
|
pszFilesSpec = NULL;
|
|
}
|
|
|
|
//
|
|
// Make sure renaming is ON if this is a multi-file CAB.
|
|
//
|
|
|
|
fError = ExpandDiamondFile(ProcessNotification,pszInFileName,
|
|
pszOutFileName,(bDoRename || bContainsMultipleFiles),
|
|
pszFilesSpec,pLZI);
|
|
} else {
|
|
fError = Expand(ProcessNotification, pszInFileName,
|
|
pszOutFileName, bDoRename, pLZI);
|
|
}
|
|
|
|
if (fError != TRUE) {
|
|
// Deal with returned error codes.
|
|
DisplayErrorMessage(nReturnCode = fError);
|
|
|
|
} else if (bContainsMultipleFiles) {
|
|
|
|
if (nLocalFiles == 0) {
|
|
|
|
LoadString(NULL, SID_NO_MATCHES, ErrorMsg, 2048);
|
|
// WARNING: Cannot call CharToOemW with src=dest
|
|
CharToOem(ErrorMsg, ErrorMsg);
|
|
printf(ErrorMsg, pszInFileName, pszSelectiveFilesSpec);
|
|
}
|
|
|
|
} else {
|
|
|
|
if (pLZI && pLZI->cblInSize && pLZI->cblOutSize) {
|
|
|
|
// Keep track of cumulative statistics.
|
|
cblTotInSize += pLZI->cblInSize;
|
|
cblTotOutSize += pLZI->cblOutSize;
|
|
|
|
if (bCopyingFile) {
|
|
LoadString(NULL, SID_COPY_REPORT, ErrorMsg, 2048);
|
|
// WARNING: Cannot call CharToOemW with src=dest
|
|
CharToOem(ErrorMsg, ErrorMsg);
|
|
printf(ErrorMsg, pszInFileName, pLZI->cblInSize);
|
|
}
|
|
else {
|
|
|
|
LoadString(NULL, SID_FILE_REPORT, ErrorMsg, 2048);
|
|
// WARNING: Cannot call CharToOemW with src=dest
|
|
CharToOem(ErrorMsg, ErrorMsg);
|
|
printf(ErrorMsg, pszInFileName, pLZI->cblInSize, pLZI->cblOutSize,
|
|
(INT)(((100 * (LONGLONG) pLZI->cblOutSize) / pLZI->cblInSize) - 100));
|
|
}
|
|
}
|
|
}
|
|
|
|
// Separate individual file processing message blocks by a blank line.
|
|
printf("\n");
|
|
}
|
|
|
|
// Free memory used by ring buffer and I/O buffers.
|
|
FreeGlobalBuffers(pLZI);
|
|
|
|
TermDiamond();
|
|
|
|
if (!fReportStats || bDoListFiles) {
|
|
|
|
if (nTotalFiles > 1) {
|
|
|
|
LoadString(NULL, SID_TOTAL_COUNT, ErrorMsg, 2048);
|
|
// WARNING: Cannot call CharToOemW with src=dest
|
|
CharToOem(ErrorMsg, ErrorMsg);
|
|
printf(ErrorMsg, nTotalFiles);
|
|
}
|
|
|
|
} else {
|
|
|
|
// Display cumulative report for multiple files.
|
|
if ((nTotalFiles > 1) && (cblTotInSize != 0)) {
|
|
|
|
// Scale results to get accurate %
|
|
LONG cblAdjInSize = cblTotInSize,
|
|
cblAdjOutSize = cblTotOutSize;
|
|
while (cblAdjInSize > 100000) {
|
|
cblAdjInSize /= 2;
|
|
cblAdjOutSize /= 2;
|
|
}
|
|
cblAdjOutSize += (cblAdjInSize / 200); // round off (+0.5%)
|
|
if (cblAdjOutSize < 0) {
|
|
cblAdjOutSize = 0;
|
|
}
|
|
|
|
LoadString(NULL, SID_TOTAL_REPORT, ErrorMsg, 2048);
|
|
// WARNING: Cannot call CharToOemW with src=dest
|
|
CharToOem(ErrorMsg, ErrorMsg);
|
|
printf(ErrorMsg, nTotalFiles, cblTotInSize, cblTotOutSize,
|
|
(INT)(100 * cblAdjOutSize / cblAdjInSize - 100));
|
|
}
|
|
|
|
}
|
|
|
|
return(nReturnCode);
|
|
}
|
|
|