unace.cpp

来自「zip的全部算法源代码」· C++ 代码 · 共 710 行 · 第 1/2 页

/*************************************************************************
                     ZipALot
**************************************************************************

Copyright (C) December, 2000 Jean-Pierre Bergamin, [e-mail]

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
***************************************************************************/

// Unace.cpp: implementation of the CUnace class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "zipalot.h"
#include "Unace.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif


BOOL CUnace::m_bQuiet = FALSE;
errorCode CUnace::m_OrigError = EX_OK;
extern HANDLE hStop;
extern CStringList g_sListCurZIPfiles;

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

//extern char curfile[_MAX_PATH];
extern CStringList g_sListCurfiles;
extern CStringList g_sListCurZIPfile;
extern char curzipfile[_MAX_PATH];

CUnace::CUnace(CDialog * pUnzipDlg) : CExtract(pUnzipDlg)
{
}

CUnace::~CUnace()
{

}



void CUnace::BuildFileList(LPTSTR * ppsFileList, BOOL bInclude)
{
	LPCTSTR sFilter = NULL;
	if (bInclude) {
		sFilter = unzipInfo.sExFilter;
	}
	else {
		sFilter = unzipInfo.sDontExFilter;
	}


	if (sFilter == NULL) {
		if (bInclude) {
			// Extract all if nothing is set
			*ppsFileList = "*";		
		}
		else {
			// Don't exclude anyting is nothing is set
			*ppsFileList = "";	
		}

		return;
	}

	CString sF(sFilter);
	sF.Replace('/', 0xd);

	*ppsFileList = (LPTSTR)(LPCTSTR)sF;
}

errorCode CUnace::Test(LPCTSTR sFilePath)
{
	m_bQuiet = TRUE;
	tACETestStruc Test = {0};

	Test.Files.SourceDir   = "";        // archive main directory is
									  // base directory for FileList
	Test.Files.FileList= "*";      // set FileList
	Test.Files.ExcludeList = "";        // no files to exclude
	Test.Files.FullMatch   = 0;         // also test files partially matching

	Test.DecryptPassword   = "";        // no encrypted file expected

	int nRet = ACETestProc((LPTSTR)sFilePath, &Test);

	return GetErrorCode(nRet);
}

BOOL CUnace::IsArchive(LPCTSTR sFilePath)
{
	m_bQuiet = TRUE;
	tACETestStruc Test = {0};

	Test.Files.SourceDir   = "";        // archive main directory is
									  // base directory for FileList
	Test.Files.FileList= "*";      // set FileList
	Test.Files.ExcludeList = "";        // no files to exclude
	Test.Files.FullMatch   = 0;         // also test files partially matching

	Test.DecryptPassword   = "";        // no encrypted file expected

	int nRet = ACETestProc((LPTSTR)sFilePath, &Test);

	return GetErrorCode(nRet) == EX_OK;
}


errorCode CUnace::Extract(const LPCTSTR sFileName, const LPCTSTR sDestination)
{
	m_bQuiet = FALSE;
	tACEExtractStruc Extract = {0};
	CString sInc, sEx;

	if (unzipInfo.sExFilter == NULL) {
		Extract.Files.FileList = "*";
	}
	else {
		sInc = unzipInfo.sExFilter;
		sInc.Replace('/', 0xd);
		Extract.Files.FileList = (LPTSTR)(LPCTSTR)sInc;
	}

	if (unzipInfo.sDontExFilter == NULL) {
		Extract.Files.ExcludeList = "";
	}
	else {
		sEx = unzipInfo.sDontExFilter;
		sEx.Replace('/', 0xd);
		Extract.Files.ExcludeList = (LPTSTR)(LPCTSTR)sEx;
	}

	Extract.Files.SourceDir      = "";      // archive main directory is
											// base dir for FileList
	Extract.Files.FullMatch      = 0;       // also extract files
											// partially matching

	Extract.DestinationDir       = (LPTSTR)(LPCTSTR)sDestination; // directory to extract to
	Extract.ExcludePath          = !unzipInfo.bRecreateDir;  // extract files with path?
	Extract.DecryptPassword      = "";             // no encrypted file expected
	
	m_OrigError = EX_OK;

	int nRet = ACEExtractProc((LPTSTR)(LPCTSTR)sFileName, &Extract);

	if (m_OrigError != EX_OK) {
		return m_OrigError;
	}

	return GetErrorCode(nRet);
}

BOOL CUnace::GetProcAddresses(void)
{
	if (m_hDLL)	{
		if (!(ACEInitDllProc               = (int (__stdcall *)(pACEInitDllStruc DllData))
				  GetProcAddress(m_hDLL, "ACEInitDll"))
			|| !(ACEReadArchiveDataProc    = (int (__stdcall *)(LPSTR ArchiveName, pACEReadArchiveDataStruc ArchiveData))
				  GetProcAddress(m_hDLL, "ACEReadArchiveData"))
			|| !(ACEListProc               = (int (__stdcall *)(LPSTR ArchiveName, pACEListStruc List))
				  GetProcAddress(m_hDLL, "ACEList"))
			|| !(ACETestProc               = (int (__stdcall *)(LPSTR ArchiveName, pACETestStruc Test))
				  GetProcAddress(m_hDLL, "ACETest"))
			|| !(ACEExtractProc            =  (int (__stdcall *)(LPSTR ArchiveName, pACEExtractStruc Extract))
				  GetProcAddress(m_hDLL, "ACEExtract"))) {
		  TRACE("\nCould not find function in UnAceV2.Dll!\n\n");
		  FreeDLL();

		  return FALSE;
		}
	}

	return TRUE;
}

CString CUnace::GetDLLName(void)
{
	return "UNACEV2.DLL";	
}


/*-----------------HandleStateStartArchive-------------------------------*/

int CUnace::HandleStateStartArchive(pACECallbackArchiveStruc Archive)
{
#ifdef _DEBUG	
	LPSTR     ActionStr;

	switch (Archive->Operation)
	{
		case ACE_CALLBACK_OPERATION_LIST:
		{
		  ActionStr = "Listing %s\n\n";

		  break;
		}

		case ACE_CALLBACK_OPERATION_TEST:
		{
		  ActionStr = "Testing %s\n\n";

		  break;
		}

		case ACE_CALLBACK_OPERATION_EXTRACT:
		{
		  ActionStr = "Extracting %s\n\n";

		  break;
		}

		default:
		{
		  ActionStr = "unknown operation on %s";

		  break;
		}
	}

	//TRACE(ActionStr, Archive->ArchiveData->ArchiveName);
#endif
	/*if (!m_bQuiet && m_pPseudoThis->m_pUnzipDlg) {
		CString sFileName = Archive->ArchiveData->ArchiveName;
		sFileName = sFileName.Right(sFileName.GetLength() - sFileName.ReverseFind('\\') - 1);
		strcpy(curfile, Archive->ArchiveData->ArchiveName);
		m_pPseudoThis->m_pUnzipDlg->PostMessage(WM_EXTRACT_CURFILE, 0, (long)curfile);
	}*/

	return CancelStatus();
}

/*-----------------HandleStateStartFile----------------------------------*/

int CUnace::HandleStateStartFile(pACECallbackArchivedFileStruc ArchivedFile)
{
#ifdef _DEBUG	

	LPSTR     ActionStr;

	switch (ArchivedFile->Operation)
	{
		case ACE_CALLBACK_OPERATION_LIST:
		{
		  ActionStr = "Found";

		  break;
		}

		case ACE_CALLBACK_OPERATION_TEST:
		{
		  ActionStr = "Testing";

		  break;
		}

		case ACE_CALLBACK_OPERATION_ANALYZE:
		{
		  ActionStr = "Analyzing";

		  break;
		}

		case ACE_CALLBACK_OPERATION_EXTRACT:
		{
		  ActionStr = "Extracting";
		  break;
		}

		default:
		{
		  ActionStr = "unknown operation on";

		  break;
		}
	}

/*	TRACE("  %s %s  (%I64d byte uncompressed, %I64d byte compressed)\n",
		 ActionStr, ArchivedFile->FileData->SourceFileName,
		 ArchivedFile->FileData->Size,
		 ArchivedFile->FileData->CompressedSize);*/
#endif
	if (!m_bQuiet && m_pPseudoThis->m_pUnzipDlg) {
		g_sListCurfiles.AddTail(ArchivedFile->FileData->SourceFileName);
		//m_pPseudoThis->m_pUnzipDlg->PostMessage(WM_EXTRACT_CURFILE, 0, (long)ArchivedFile->FileData->SourceFileName);
		m_pPseudoThis->m_pUnzipDlg->PostMessage(WM_EXTRACT_CURFILE, 0, 0);
	}

	return CancelStatus();
}

int CUnace::HandleErrorGlobal(pACECallbackGlobalStruc Error)
{
	int nResult = ACE_CALLBACK_RETURN_OK;
	errorCode error;

	switch (Error->Code) {
		case ACE_CALLBACK_ERROR_MEMORY:
			error = EX_MEM;
			break;
		case ACE_CALLBACK_ERROR_UNCSPACE:
			error = EX_DISK;
			break;

		default:
		  error = EX_UNKNOWN;
		  nResult = ACE_CALLBACK_RETURN_CANCEL;
		  break;
	}
	m_OrigError = error;

	CExtract::ReportError(error);

	return nResult;
}

int CUnace::HandleErrorArchive(pACECallbackArchiveStruc Error)
{
	int nResult = ACE_CALLBACK_RETURN_OK;
	errorCode error;

	switch (Error->Code) {
		case ACE_CALLBACK_ERROR_AV:
			error = EX_ARCHIVE;
			break;

		case ACE_CALLBACK_ERROR_OPENARCHIVEREAD:
			error = EX_OPEN;
			break;

		case ACE_CALLBACK_ERROR_READARCHIVE:
			error = EX_READ;
			break;

		case ACE_CALLBACK_ERROR_ARCHIVEBROKEN:
			error = EX_ARCHIVE;