unace.cpp

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

			break;

		case ACE_CALLBACK_ERROR_NOFILES:
			error = EX_NO_FILES;
			break;

		case ACE_CALLBACK_ERROR_ISNOTANARCHIVE:
			error = EX_UNSUP;
			break;

		case ACE_CALLBACK_ERROR_HIGHERVERSION:
			error = EX_UNSUP;
			break;

		default:
			error = EX_UNKNOWN;
			nResult   = ACE_CALLBACK_RETURN_CANCEL;
			break;
	}
	if (!m_bQuiet) {
		CExtract::ReportError(error, GetFileName(Error->ArchiveData->ArchiveName));
	}

	m_OrigError = error;

	return nResult;
}

int CUnace::HandleErrorArchivedFile(pACECallbackArchivedFileStruc Error)
{
	int nResult = ACE_CALLBACK_RETURN_OK;
	errorCode error;

	switch (Error->Code) {
		case ACE_CALLBACK_ERROR_CREATIONNAMEINUSE:
			error = EX_CREATE;
			break;

		case ACE_CALLBACK_ERROR_WRITE:
			error = EX_WRITE;
			break;

		case ACE_CALLBACK_ERROR_OPENWRITE:
			error = EX_OPEN;
			break;

		case ACE_CALLBACK_ERROR_METHOD:
			error = EX_UNSUP;
			break;

		case ACE_CALLBACK_ERROR_EXTRACTSPACE:
			error = EX_DISK;
			nResult   = ACE_CALLBACK_RETURN_CANCEL;
			break;

		case ACE_CALLBACK_ERROR_CREATION:
			error = EX_CREATE;
			break;

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

	m_OrigError = error;
	CExtract::ReportError(error, GetFileName(Error->FileData->SourceFileName));

	return nResult;
}


int __stdcall CUnace::ErrorProc(pACEErrorCallbackProcStruc Error)
{
	switch (Error->StructureType) {
		case ACE_CALLBACK_TYPE_GLOBAL:
			return HandleErrorGlobal(&Error->Global);

		case ACE_CALLBACK_TYPE_ARCHIVE:
			return HandleErrorArchive(&Error->Archive);

		case ACE_CALLBACK_TYPE_ARCHIVEDFILE:
			return HandleErrorArchivedFile(&Error->ArchivedFile);

		case ACE_CALLBACK_TYPE_REALFILE:
		case ACE_CALLBACK_TYPE_SPACE:
		case ACE_CALLBACK_TYPE_SFXFILE:
		default:
			ReportError(EX_UNKNOWN);
			return ACE_CALLBACK_RETURN_CANCEL;
	}
}

int CUnace::HandleRequestArchive(pACECallbackArchiveStruc Request)
{
	int nResult = ACE_CALLBACK_RETURN_OK;

	switch (Request->Code)
	{
		case ACE_CALLBACK_REQUEST_CHANGEVOLUME: {
			if (m_bQuiet || m_pPseudoThis->m_pUnzipDlg == NULL) {
				return ACE_CALLBACK_RETURN_OK;
			}
			else {
				CFileFind finder;
				if (!finder.FindFile(Request->ArchiveData->ArchiveName)) {
					if (RequestFile(Request->ArchiveData->ArchiveName) != IDOK) {
						nResult = ACE_CALLBACK_RETURN_CANCEL;
						break;
					}
				}
				LPCTSTR lpszFileName = GetFileName(Request->ArchiveData->ArchiveName);
				g_sListCurZIPfiles.AddTail(lpszFileName);
				m_pPseudoThis->m_pUnzipDlg->PostMessage(WM_EXTRACT_CURZIPFILE, 0, 0);
				m_pPseudoThis->m_pUnzipDlg->SendMessage(WM_EXTRACT_STEPIT, 0, 0);
				break;
			}
		}
		default:
			nResult = ACE_CALLBACK_RETURN_CANCEL;
	}

	return nResult;
}

int CUnace::HandleRequestArchivedFile(pACECallbackArchivedFileStruc Request)
{
	int nResult = ACE_CALLBACK_RETURN_OK;

	switch (Request->Code) {
		case ACE_CALLBACK_REQUEST_OVERWRITE:
		case ACE_CALLBACK_REQUEST_OVERWRITESYSFILE:
			// Hmmm? Strange naming of the return values...
			nResult = unzipInfo.bOverwrite ? ACE_CALLBACK_RETURN_OK : ACE_CALLBACK_RETURN_NO;
		
			break;

		case ACE_CALLBACK_REQUEST_PASSWORD:
		{
			// The file is password protected
			int nRet = PromptPassword(&Request->GlobalData->DecryptPassword, Request->FileData->SourceFileName, Request->ArchiveData->ArchiveName, "The file is password protected");
			if (nRet == IDOK && strlen(Request->GlobalData->DecryptPassword) > 0) {
				m_bPwdSet = TRUE;
			}			
			else if (nRet == IDCANCEL) {
				return ACE_CALLBACK_RETURN_CANCEL;
			}
			break;
		}

		default:
		  return ACE_CALLBACK_RETURN_CANCEL;
	}

	return nResult;
}

int __stdcall CUnace::RequestProc(pACERequestCallbackProcStruc Request)
{
	switch (Request->StructureType)	{
		case ACE_CALLBACK_TYPE_ARCHIVE: {
			return HandleRequestArchive(&Request->Archive);
		}

		case ACE_CALLBACK_TYPE_ARCHIVEDFILE: {
			return HandleRequestArchivedFile(&Request->ArchivedFile);
		}

		case ACE_CALLBACK_TYPE_GLOBAL:
		case ACE_CALLBACK_TYPE_REALFILE:
		default:
			return ACE_CALLBACK_RETURN_CANCEL;
	}
}

int __stdcall CUnace::StateProc(pACEStateCallbackProcStruc State)
{
	switch (State->StructureType) {
		case ACE_CALLBACK_TYPE_ARCHIVE:	{
			if (State->Archive.Code == ACE_CALLBACK_STATE_STARTARCHIVE) {
				return HandleStateStartArchive(&State->Archive);
			}

			break;
		}

		case ACE_CALLBACK_TYPE_ARCHIVEDFILE: {
			switch (State->ArchivedFile.Code) {
				case ACE_CALLBACK_STATE_STARTFILE: {
					return HandleStateStartFile(&State->ArchivedFile);
				}

				case ACE_CALLBACK_STATE_ENDNOCRCCHECK: {

				}
			}

			break;
		}

		case ACE_CALLBACK_TYPE_PROGRESS: {
			if (State->Progress.Code == ACE_CALLBACK_STATE_PROGRESS) {
/*				TRACE("    processed: %I64d of %I64d bytes (%I64d of %I64d bytes)\n",
					   State->Progress.ProgressData->FileProcessedSize,
					   State->Progress.ProgressData->FileSize,
					   State->Progress.ProgressData->TotalProcessedSize,
					   State->Progress.ProgressData->TotalSize);*/
			}

			break;
		}

		case ACE_CALLBACK_TYPE_CRCCHECK: {
			if (State->CRCCheck.Code == ACE_CALLBACK_STATE_ENDCRCCHECK) {
				if(!State->CRCCheck.CRCOk) {
					ReportError(m_bPwdSet ? EX_BADPWD : EX_CRC, GetFileName(State->ArchivedFile.FileData->SourceFileName));
				}
			}

			break;
		}
	}

	return CancelStatus();
}

int __stdcall CUnace::InfoProc(pACEInfoCallbackProcStruc Info)
{
#ifdef _DEBUG
	LPSTR     InfoStr;

	switch (Info->Global.Code) {
		case ACE_CALLBACK_INFO_FILELISTCREATE:
		{
			InfoStr = "creating file list";

			break;
		}

		case ACE_CALLBACK_INFO_FILELISTCREATEEND:
		{
			InfoStr = "finished creating file list";

			break;
		}

		case ACE_CALLBACK_INFO_FILELISTADD:
		{
			InfoStr = "adding file to file list";

			break;
		}

		default:
		{
			InfoStr = "";

			break;
		}
	}

//	TRACE("Info: %s\n", InfoStr);
#endif
	return CancelStatus();
}

BOOL CUnace::DLLInit()
{
	tACEInitDllStruc DllData = {0};

	DllData.GlobalData.Obj = m_pUnzipDlg;
	DllData.GlobalData.MaxArchiveTestBytes = 0x1ffFF; // search for archive
													// header in first 128k
													// of file
	DllData.GlobalData.MaxFileBufSize      = 0x2ffFF; // read/write buffer size
													// is 256k

	DllData.GlobalData.Comment.BufSize     = sizeof(m_sCommentBuf);
	DllData.GlobalData.Comment.Buf         = m_sCommentBuf; // set comment bufffer
													   // to receive comments
													   // of archive and/or
													   // set comments

	DllData.GlobalData.TempDir             = "C:\\TEMP"; // set temp dir

	// set callback function pointers
	DllData.GlobalData.InfoCallbackProc    = InfoProc;
	DllData.GlobalData.ErrorCallbackProc   = ErrorProc;
	DllData.GlobalData.RequestCallbackProc = RequestProc;
	DllData.GlobalData.StateCallbackProc   = StateProc;

	return ACEInitDllProc(&DllData) == ACE_CALLBACK_RETURN_OK;
}


errorCode CUnace::GetErrorCode(int nError)
{
	errorCode error;

	switch(nError) {
		case ACE_ERROR_NOERROR:
			error = EX_OK;
			break;
		case ACE_ERROR_MEM:
			error = EX_MEM;
			break;	
		case ACE_ERROR_FILES:
			error = EX_NO_FILES;
			break;	
		case ACE_ERROR_FOUND:
			error = EX_NO_ARCHIVES;
			break;	
		case ACE_ERROR_FULL:
			error = EX_DISK;
			break;	
		case ACE_ERROR_OPEN:
			error = EX_OPEN;
			break;
		case ACE_ERROR_READ:
			error = EX_READ;
			break;	
		case ACE_ERROR_WRITE:
			error = EX_WRITE;
			break;	
		case ACE_ERROR_CLINE:
			error = EX_UNKNOWN;
			break;	
		case ACE_ERROR_CRC:
			error = EX_CRC;
			break;	
		case ACE_ERROR_OTHER:
			error = EX_UNKNOWN;
			break;	
		case ACE_ERROR_EXISTS:
			error = EX_EXISTS;
			break;
		case ACE_ERROR_USER:
			error =  EX_CANCELLED;
			break;
		default:
			error = EX_UNKNOWN;
	}

	return error;
}

int CUnace::CancelStatus()
{
	if (WaitForSingleObject(hStop, 0) == WAIT_OBJECT_0) {
		return ACE_CALLBACK_RETURN_CANCEL;
	}
	
	return ACE_CALLBACK_RETURN_OK;
}