mozilla
/
gecko-dev
зеркало из https://github.com/mozilla/gecko-dev.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность
gecko-dev/modules/lib7z/7zLib.cpp

798 строки
21 KiB
C++
Исходник Ответственный История

/* -*- Mode: C++; c-basic-offset: 2; tab-width: 8; indent-tabs-mode: nil; -*- */
/*****************************************************************************
*
* This 7z Library is based the 7z Client and 7z Standalone Extracting Plugin
* code from the LZMA SDK.
* It is in the public domain (see http://www.7-zip.org/sdk.html).
*
* Any copyright in these files held by contributors to the Mozilla Project is
* also dedicated to the Public Domain.
* http://creativecommons.org/licenses/publicdomain/
*
* Contributor(s):
* Alex Pakhotin <alexp@mozilla.com>
*
*****************************************************************************/
#include "Common/MyWindows.h"
#include "Common/NewHandler.h"
#include "Common/IntToString.h"
#include "Common/MyInitGuid.h"
#include "Common/StringConvert.h"
#include "Windows/DLL.h"
#include "Windows/FileDir.h"
#include "Windows/FileFind.h"
#include "Windows/FileName.h"
#include "Windows/NtCheck.h"
#include "Windows/PropVariant.h"
#include "Windows/PropVariantConversions.h"
#include "7zip/Common/FileStreams.h"
#include "7zip/ICoder.h"
#include "7zip/Archive/IArchive.h"
#include "7zip/IPassword.h"
#include "7zip/MyVersion.h"
// Used for global structures initialization
#include "../C/7zCrc.h"
#include "7zip/Common/RegisterArc.h"
#include "7zip/Common/RegisterCodec.h"
#include "7zip/Archive/7z/7zHandler.h"
#include "7zip/Compress/Bcj2Coder.h"
#include "7zip/Compress/BcjCoder.h"
#include "7zip/Compress/CopyCoder.h"
#include "7zip/Compress/Lzma2Decoder.h"
#include "7zip/Compress/LzmaDecoder.h"
#include "7zLib.h"
using namespace NWindows;
STDAPI CreateArchiver(const GUID *classID, const GUID *iid, void **outObject);
DEFINE_GUID(CLSID_CArchiveHandler,
0x23170F69, 0x40C1, 0x278A, 0x10, 0x00, 0x00, 0x01, 0x10, 0x00, 0x00, 0x00);
DEFINE_GUID(CLSID_CFormat7z,
0x23170F69, 0x40C1, 0x278A, 0x10, 0x00, 0x00, 0x01, 0x10, 0x07, 0x00, 0x00);
// Global static structures copied here from *Register.cpp files
// Static global variable defined in a module didn't work when used in a library
// 7z
static IInArchive *CreateArc() { return new NArchive::N7z::CHandler; }
static CArcInfo g_ArcInfo =
{ L"7z", L"7z", 0, 7, {'7', 'z', 0xBC, 0xAF, 0x27, 0x1C}, 6, false, CreateArc, NULL };
// BCJ2
static void *CreateCodecBCJ2() { return (void *)(ICompressCoder2 *)(new NCompress::NBcj2::CDecoder()); }
static CCodecInfo g_CodecInfoBCJ2 =
{ CreateCodecBCJ2, NULL, 0x0303011B, L"BCJ2", 4, false };
// BCJ
static void *CreateCodecBCJ() { return (void *)(ICompressFilter *)(new CBCJ_x86_Decoder()); }
static CCodecInfo g_CodecInfoBCJ =
{ CreateCodecBCJ, NULL, 0x03030103, L"BCJ", 1, true };
// Copy
static void *CreateCodecCopy() { return (void *)(ICompressCoder *)(new NCompress::CCopyCoder); }
static CCodecInfo g_CodecInfoCopy =
{ CreateCodecCopy, CreateCodecCopy, 0x00, L"Copy", 1, false };
// LZMA2
static void *CreateCodecLZMA2() { return (void *)(ICompressCoder *)(new NCompress::NLzma2::CDecoder); }
static CCodecInfo g_CodecInfoLZMA2 =
{ CreateCodecLZMA2, NULL, 0x21, L"LZMA2", 1, false };
// LZMA
static void *CreateCodecLZMA() { return (void *)(ICompressCoder *)(new NCompress::NLzma::CDecoder); }
static CCodecInfo g_CodecInfoLZMA =
{ CreateCodecLZMA, NULL, 0x030101, L"LZMA", 1, false };
// Initialize all global structures
static void Initialize7z()
{
static bool bInitialized = false;
if (bInitialized)
return;
CrcGenerateTable();
RegisterArc(&g_ArcInfo);
RegisterCodec(&g_CodecInfoBCJ2);
RegisterCodec(&g_CodecInfoBCJ);
RegisterCodec(&g_CodecInfoCopy);
RegisterCodec(&g_CodecInfoLZMA2);
RegisterCodec(&g_CodecInfoLZMA);
bInitialized = true;
}
#ifdef _CONSOLE
#include "stdio.h"
void PrintString(const UString &s)
{
printf("%s", (LPCSTR)GetOemString(s));
}
void PrintString(const AString &s)
{
printf("%s", (LPCSTR)s);
}
void PrintNewLine()
{
PrintString("\n");
}
void PrintStringLn(const AString &s)
{
PrintString(s);
PrintNewLine();
}
void PrintError(const AString &s)
{
PrintNewLine();
PrintString(s);
PrintNewLine();
}
#else
#define PrintString(s)
#define PrintString(s)
#define PrintNewLine()
#define PrintStringLn(s)
static UString g_sError;
void PrintError(const AString &s)
{
g_sError += GetUnicodeString(s) + L"\n";
}
const wchar_t* GetExtractorError()
{
return (const wchar_t*)g_sError;
}
#endif
static HRESULT IsArchiveItemProp(IInArchive *archive, UInt32 index, PROPID propID, bool &result)
{
NCOM::CPropVariant prop;
RINOK(archive->GetProperty(index, propID, &prop));
if (prop.vt == VT_BOOL)
result = VARIANT_BOOLToBool(prop.boolVal);
else if (prop.vt == VT_EMPTY)
result = false;
else
return E_FAIL;
return S_OK;
}
static HRESULT IsArchiveItemFolder(IInArchive *archive, UInt32 index, bool &result)
{
return IsArchiveItemProp(archive, index, kpidIsDir, result);
}
static const wchar_t *kEmptyFileAlias = L"[Content]";
//////////////////////////////////////////////////////////////
// Archive Open callback class
class CArchiveOpenCallback:
public IArchiveOpenCallback,
public ICryptoGetTextPassword,
public CMyUnknownImp
{
public:
MY_UNKNOWN_IMP1(ICryptoGetTextPassword)
STDMETHOD(SetTotal)(const UInt64 *files, const UInt64 *bytes);
STDMETHOD(SetCompleted)(const UInt64 *files, const UInt64 *bytes);
STDMETHOD(CryptoGetTextPassword)(BSTR *password);
bool PasswordIsDefined;
UString Password;
CArchiveOpenCallback() : PasswordIsDefined(false) {}
};
STDMETHODIMP CArchiveOpenCallback::SetTotal(const UInt64 * /* files */, const UInt64 * /* bytes */)
{
return S_OK;
}
STDMETHODIMP CArchiveOpenCallback::SetCompleted(const UInt64 * /* files */, const UInt64 * /* bytes */)
{
return S_OK;
}
STDMETHODIMP CArchiveOpenCallback::CryptoGetTextPassword(BSTR *password)
{
if (!PasswordIsDefined)
{
// You can ask real password here from user
// Password = GetPassword(OutStream);
// PasswordIsDefined = true;
PrintError("Password is not defined");
return E_ABORT;
}
return StringToBstr(Password, password);
}
//////////////////////////////////////////////////////////////
// Archive Extracting callback class
static const wchar_t *kCantDeleteOutputFile = L"ERROR: Can not delete output file ";
static const char *kTestingString = "Testing ";
static const char *kExtractingString = "Extracting ";
static const char *kSkippingString = "Skipping ";
static const char *kUnsupportedMethod = "Unsupported Method";
static const char *kCRCFailed = "CRC Failed";
static const char *kDataError = "Data Error";
static const char *kUnknownError = "Unknown Error";
class CArchiveExtractCallback:
public IArchiveExtractCallback,
public ICryptoGetTextPassword,
public CMyUnknownImp
{
public:
MY_UNKNOWN_IMP1(ICryptoGetTextPassword)
// IProgress
STDMETHOD(SetTotal)(UInt64 size);
STDMETHOD(SetCompleted)(const UInt64 *completeValue);
// IArchiveExtractCallback
STDMETHOD(GetStream)(UInt32 index, ISequentialOutStream **outStream, Int32 askExtractMode);
STDMETHOD(PrepareOperation)(Int32 askExtractMode);
STDMETHOD(SetOperationResult)(Int32 resultEOperationResult);
// ICryptoGetTextPassword
STDMETHOD(CryptoGetTextPassword)(BSTR *aPassword);
private:
CMyComPtr<IInArchive> _archiveHandler;
UString _directoryPath; // Output directory
UString _filePath; // name inside archive
UString _diskFilePath; // full path to file on disk
bool _extractMode;
struct CProcessedFileInfo
{
FILETIME MTime;
UInt32 Attrib;
bool isDir;
bool AttribDefined;
bool MTimeDefined;
} _processedFileInfo;
COutFileStream *_outFileStreamSpec;
CMyComPtr<ISequentialOutStream> _outFileStream;
SzExtractProgressCallback *_progressCallback;
UInt32 _numItemsTotal;
UInt32 _numItemsExtracted;
public:
void Init(IInArchive *archiveHandler, const UString &directoryPath, SzExtractProgressCallback *progressCallback);
UInt64 NumErrors;
bool PasswordIsDefined;
UString Password;
CArchiveExtractCallback() : PasswordIsDefined(false) {}
};
void CArchiveExtractCallback::Init(IInArchive *archiveHandler, const UString &directoryPath, SzExtractProgressCallback *progressCallback)
{
NumErrors = 0;
_archiveHandler = archiveHandler;
_directoryPath = directoryPath;
NFile::NName::NormalizeDirPathPrefix(_directoryPath);
_progressCallback = progressCallback;
_numItemsTotal = 0;
_numItemsExtracted = 0;
archiveHandler->GetNumberOfItems(&_numItemsTotal);
}
// SetTotal and SetCompleted callback methods show progress
// based on the input buffer, which does not really correspond
// to the actual extraction progress.
// Current implementation uses number of files as the progress indicator,
// which gives better result with an archive containing a lot of files.
STDMETHODIMP CArchiveExtractCallback::SetTotal(UInt64 /* size */)
{
/*
char s[30];
ConvertUInt64ToString(size, s);
PrintString(AString("\n--- Total: "));
PrintStringLn(s);
*/
return S_OK;
}
STDMETHODIMP CArchiveExtractCallback::SetCompleted(const UInt64 * /* completeValue */)
{
/*
char s[30];
ConvertUInt64ToString(*completeValue, s);
PrintString(AString("\n--- Completed: "));
PrintStringLn(s);
*/
return S_OK;
}
STDMETHODIMP CArchiveExtractCallback::GetStream(UInt32 index,
ISequentialOutStream **outStream, Int32 askExtractMode)
{
*outStream = 0;
_outFileStream.Release();
{
// Get Name
NCOM::CPropVariant prop;
RINOK(_archiveHandler->GetProperty(index, kpidPath, &prop));
UString fullPath;
if (prop.vt == VT_EMPTY)
fullPath = kEmptyFileAlias;
else
{
if (prop.vt != VT_BSTR)
return E_FAIL;
fullPath = prop.bstrVal;
}
_filePath = fullPath;
}
if (askExtractMode != NArchive::NExtract::NAskMode::kExtract)
return S_OK;
{
// Get Attrib
NCOM::CPropVariant prop;
RINOK(_archiveHandler->GetProperty(index, kpidAttrib, &prop));
if (prop.vt == VT_EMPTY)
{
_processedFileInfo.Attrib = 0;
_processedFileInfo.AttribDefined = false;
}
else
{
if (prop.vt != VT_UI4)
return E_FAIL;
_processedFileInfo.Attrib = prop.ulVal;
_processedFileInfo.AttribDefined = true;
}
}
RINOK(IsArchiveItemFolder(_archiveHandler, index, _processedFileInfo.isDir));
{
// Get Modified Time
NCOM::CPropVariant prop;
RINOK(_archiveHandler->GetProperty(index, kpidMTime, &prop));
_processedFileInfo.MTimeDefined = false;
switch(prop.vt)
{
case VT_EMPTY:
// _processedFileInfo.MTime = _utcMTimeDefault;
break;
case VT_FILETIME:
_processedFileInfo.MTime = prop.filetime;
_processedFileInfo.MTimeDefined = true;
break;
default:
return E_FAIL;
}
}
/*
{
// Get Size
NCOM::CPropVariant prop;
RINOK(_archiveHandler->GetProperty(index, kpidSize, &prop));
bool newFileSizeDefined = (prop.vt != VT_EMPTY);
UInt64 newFileSize;
if (newFileSizeDefined)
newFileSize = ConvertPropVariantToUInt64(prop);
}
*/
{
// Create folders for file
int slashPos = _filePath.ReverseFind(WCHAR_PATH_SEPARATOR);
if (slashPos >= 0)
NFile::NDirectory::CreateComplexDirectory(_directoryPath + _filePath.Left(slashPos));
}
UString fullProcessedPath = _directoryPath + _filePath;
_diskFilePath = fullProcessedPath;
if (_processedFileInfo.isDir)
{
NFile::NDirectory::CreateComplexDirectory(fullProcessedPath);
}
else
{
NFile::NFind::CFileInfoW fi;
if (fi.Find(fullProcessedPath))
{
if (!NFile::NDirectory::DeleteFileAlways(fullProcessedPath))
{
PrintString(UString(kCantDeleteOutputFile) + fullProcessedPath);
return E_ABORT;
}
}
_outFileStreamSpec = new COutFileStream;
CMyComPtr<ISequentialOutStream> outStreamLoc(_outFileStreamSpec);
if (!_outFileStreamSpec->Open(fullProcessedPath, CREATE_ALWAYS))
{
PrintString((UString)L"can not open output file " + fullProcessedPath);
return E_ABORT;
}
_outFileStream = outStreamLoc;
*outStream = outStreamLoc.Detach();
}
return S_OK;
}
STDMETHODIMP CArchiveExtractCallback::PrepareOperation(Int32 askExtractMode)
{
_extractMode = false;
switch (askExtractMode)
{
case NArchive::NExtract::NAskMode::kExtract: _extractMode = true; break;
};
switch (askExtractMode)
{
case NArchive::NExtract::NAskMode::kExtract: PrintString(kExtractingString); break;
case NArchive::NExtract::NAskMode::kTest: PrintString(kTestingString); break;
case NArchive::NExtract::NAskMode::kSkip: PrintString(kSkippingString); break;
};
PrintString(_filePath);
_numItemsExtracted++;
if (_progressCallback)
{
_progressCallback(_numItemsExtracted * 100 / _numItemsTotal);
}
return S_OK;
}
STDMETHODIMP CArchiveExtractCallback::SetOperationResult(Int32 operationResult)
{
switch(operationResult)
{
case NArchive::NExtract::NOperationResult::kOK:
break;
default:
{
NumErrors++;
PrintString(" ");
switch(operationResult)
{
case NArchive::NExtract::NOperationResult::kUnSupportedMethod:
PrintString(kUnsupportedMethod);
break;
case NArchive::NExtract::NOperationResult::kCRCError:
PrintString(kCRCFailed);
break;
case NArchive::NExtract::NOperationResult::kDataError:
PrintString(kDataError);
break;
default:
PrintString(kUnknownError);
}
}
}
if (_outFileStream != NULL)
{
if (_processedFileInfo.MTimeDefined)
_outFileStreamSpec->SetMTime(&_processedFileInfo.MTime);
RINOK(_outFileStreamSpec->Close());
}
_outFileStream.Release();
if (_extractMode && _processedFileInfo.AttribDefined)
NFile::NDirectory::MySetFileAttributes(_diskFilePath, _processedFileInfo.Attrib);
PrintNewLine();
return S_OK;
}
STDMETHODIMP CArchiveExtractCallback::CryptoGetTextPassword(BSTR *password)
{
if (!PasswordIsDefined)
{
// You can ask real password here from user
// Password = GetPassword(OutStream);
// PasswordIsDefined = true;
PrintError("Password is not defined");
return E_ABORT;
}
return StringToBstr(Password, password);
}
static WRes MyCreateDir(const WCHAR *name)
{
return CreateDirectoryW(name, NULL) ? 0 : GetLastError();
}
static WRes CreateOutputDir(const WCHAR *outputDir)
{
WRes res = SZ_OK;
WCHAR name[MAX_PATH];
size_t j;
if (outputDir == NULL || outputDir[0] == 0)
return SZ_ERROR_PARAM;
wcsncpy(name, outputDir, MAX_PATH-1);
name[MAX_PATH-1] = 0;
for (j = 1; name[j] != 0 && res == 0; j++)
{
if (name[j] == CHAR_PATH_SEPARATOR)
{
name[j] = 0;
res = MyCreateDir(name);
name[j] = CHAR_PATH_SEPARATOR;
}
}
if (res == 0 && name[wcslen(name) - 1] != CHAR_PATH_SEPARATOR)
{
res = MyCreateDir(name);
}
return res;
}
//////////////////////////////////////////////////////////////////////////
// Main extract functions
/**
* Extract 7z-archive
*
* @param archiveFileName Name of the archive
* @param fileToExtract Name of the file to extract (if NULL - extract all files)
* @param outputDir Output directory for extracted files
* @param progressCallback Function to be called on each file - can show the progress
*/
int SzExtract(const WCHAR *archiveName,
const WCHAR *fileToExtract, const WCHAR *outputDir,
SzExtractProgressCallback *progressCallback)
{
return SzExtractSfx(archiveName, 0, fileToExtract, outputDir, progressCallback);
}
/**
* Extract 7z-SFX-archive
*
* @param archiveFileName Name of the archive
* @param sfxStubSize Size of the stub at the beginning of the file before the actual archive data (could be 0)
* @param fileToExtract Name of the file to extract (if NULL - extract all files)
* @param outputDir Output directory for extracted files
* @param progressCallback Function to be called on each file to show the progress
*/
int SzExtractSfx(const WCHAR *archiveName, DWORD sfxStubSize,
const WCHAR *fileToExtract, const WCHAR *outputDir,
SzExtractProgressCallback *progressCallback)
{
Initialize7z();
CreateOutputDir(outputDir);
#ifdef _DEBUG_OUTPUT
PrintString("Loading archive ");
PrintString(archiveName);
PrintNewLine();
#endif
// Extracting
{
CMyComPtr<IInArchive> archive;
if (CreateArchiver(&CLSID_CFormat7z, &IID_IInArchive, (void **)&archive) != S_OK)
{
PrintError("Can not get class object");
return SZ_ERROR_FAIL;
}
#ifdef _DEBUG_OUTPUT
PrintStringLn("Created archiver");
#endif
CInFileStream *fileSpec = new CInFileStream;
CMyComPtr<IInStream> file = fileSpec;
if (!fileSpec->Open(archiveName))
{
PrintError("Can not open archive file");
return SZ_ERROR_NO_ARCHIVE;
}
if (sfxStubSize > 0)
file->Seek(sfxStubSize, STREAM_SEEK_SET, NULL);
#ifdef _DEBUG_OUTPUT
PrintStringLn("Opened file");
#endif
{
CArchiveOpenCallback *openCallbackSpec = new CArchiveOpenCallback;
CMyComPtr<IArchiveOpenCallback> openCallback(openCallbackSpec);
openCallbackSpec->PasswordIsDefined = false;
// openCallbackSpec->PasswordIsDefined = true;
// openCallbackSpec->Password = L"1";
if (archive->Open(file, 0, openCallback) != S_OK)
{
PrintError("Can not open archive");
return SZ_ERROR_NO_ARCHIVE;
}
}
#ifdef _DEBUG_OUTPUT
PrintStringLn("Extracting...");
#endif
CArchiveExtractCallback *extractCallbackSpec = new CArchiveExtractCallback;
CMyComPtr<IArchiveExtractCallback> extractCallback(extractCallbackSpec);
extractCallbackSpec->Init(archive, outputDir, progressCallback);
extractCallbackSpec->PasswordIsDefined = false;
// extractCallbackSpec->PasswordIsDefined = true;
// extractCallbackSpec->Password = L"1";
HRESULT result = S_OK;
UInt32 numItems = 0;
archive->GetNumberOfItems(&numItems);
if (numItems == 0)
{
PrintError("No files found in the archive");
return SZ_ERROR_DATA;
}
if (fileToExtract)
{
// Extract one file
for (UInt32 i = 0; i < numItems; i++)
{
// Get name of file
NWindows::NCOM::CPropVariant prop;
archive->GetProperty(i, kpidPath, &prop);
UString s = ConvertPropVariantToString(prop);
if (wcscmp(fileToExtract, s) == 0)
{
PrintString(s);
PrintString("\n");
// Extract the current file
result = archive->Extract(&i, 1, false, extractCallback);
break;
}
}
}
else
{
// Extract all
result = archive->Extract(NULL, (UInt32)(Int32)(-1), false, extractCallback);
}
if (result != S_OK)
{
PrintError("Extract Error");
return SZ_ERROR_DATA;
}
}
return SZ_OK;
}
/**
* Get information about 7z-SFX-archive
*
* @param archiveFileName Name of the archive
* @param sfxStubSize Size of the stub at the beginning of the file before the actual archive data (could be 0)
*
* Output parameters:
* @param pUncompressedSize Pointer to 64 bit integer for the total uncompressed size
* @param pNumberOfFiles (optional) Pointer to a number of files in the archive
* @param pNumberOfDirs (optional) Pointer to a number of directories in the archive
*/
int SzGetSfxArchiveInfo(const WCHAR *archiveName, const DWORD sfxStubSize,
ULONGLONG *pUncompressedSize, DWORD *pNumberOfFiles, DWORD *pNumberOfDirs)
{
if (!archiveName || !pUncompressedSize)
return SZ_ERROR_PARAM;
*pUncompressedSize = 0;
Initialize7z();
CMyComPtr<IInArchive> archive;
if (CreateArchiver(&CLSID_CFormat7z, &IID_IInArchive, (void **)&archive) != S_OK)
{
PrintError("Can not get class object");
return SZ_ERROR_FAIL;
}
CInFileStream *fileSpec = new CInFileStream;
CMyComPtr<IInStream> file = fileSpec;
if (!fileSpec->Open(archiveName))
{
PrintError("Can not open archive file");
return SZ_ERROR_NO_ARCHIVE;
}
if (sfxStubSize > 0)
file->Seek(sfxStubSize, STREAM_SEEK_SET, NULL);
CArchiveOpenCallback *openCallbackSpec = new CArchiveOpenCallback;
CMyComPtr<IArchiveOpenCallback> openCallback(openCallbackSpec);
openCallbackSpec->PasswordIsDefined = false;
if (archive->Open(file, 0, openCallback) != S_OK)
{
PrintError("Can not open archive");
return SZ_ERROR_NO_ARCHIVE;
}
UInt32 numItems = 0;
archive->GetNumberOfItems(&numItems);
if (numItems == 0)
{
PrintError("No files found in the archive");
return SZ_ERROR_DATA;
}
if (pNumberOfFiles)
*pNumberOfFiles = 0;
if (pNumberOfDirs)
*pNumberOfDirs = 0;
// Iterate through all items
for (UInt32 i = 0; i < numItems; i++)
{
bool isDir = false;
RINOK(IsArchiveItemFolder(archive, i, isDir));
if (isDir)
{
if (pNumberOfDirs)
(*pNumberOfDirs)++;
continue;
}
UInt64 unpackSize = 0;
NWindows::NCOM::CPropVariant prop;
if (archive->GetProperty(i, kpidSize, &prop) != S_OK)
{
PrintError("Cannot get size property value");
return SZ_ERROR_DATA;
}
if (prop.vt != VT_EMPTY)
unpackSize = ConvertPropVariantToUInt64(prop);
(*pUncompressedSize) += unpackSize;
if (pNumberOfFiles)
(*pNumberOfFiles)++;
}
return SZ_OK;
}
Ссылка в новой задаче Показать git blame Копировать постоянную ссылку