void Process2()
{
NFind::CFileInfo fi;
if (!fi.Find(FileName))
{
ErrorMessage = kCantFindArchive;
Result = E_FAIL;
return;
}
CObjectVector<COpenType> incl;
CIntVector excl;
COpenOptions options;
options.codecs = Codecs;
options.types = &incl;
options.excludedFormats = !
options.filePath = fs2us(FileName);
Result = ArchiveLink.Open2(options, ExtractCallbackSpec);
if (Result != S_OK)
{
if (Result != S_OK)
ErrorMessage = kCantOpenArchive;
return;
}
FString dirPath = DestFolder;
NName::NormalizeDirPathPrefix(dirPath);
if (!CreateComplexDir(dirPath))
{
ErrorMessage = MyFormatNew(IDS_CANNOT_CREATE_FOLDER,
#ifdef LANG
0x02000603,
#endif
fs2us(dirPath));
Result = E_FAIL;
return;
}
ExtractCallbackSpec->Init(ArchiveLink.GetArchive(), dirPath, L"Default", fi.MTime, 0);
Result = ArchiveLink.GetArchive()->Extract(0, (UInt32)(Int32)-1 , BoolToInt(false), ExtractCallback);
}
void Process()
{
NFile::NFind::CFileInfoW fi;
if (!NFile::NFind::FindFile(FileName, fi))
{
ErrorMessage = kCantFindArchive;
Result = E_FAIL;
return;
}
Result = MyOpenArchive(Codecs, CIntVector(), FileName, ArchiveLink, ExtractCallbackSpec);
if (Result != S_OK)
{
if (Result != S_OK)
ErrorMessage = kCantOpenArchive;
return;
}
UString dirPath = DestFolder;
NFile::NName::NormalizeDirPathPrefix(dirPath);
if (!NFile::NDirectory::CreateComplexDirectory(dirPath))
{
ErrorMessage = MyFormatNew(IDS_CANNOT_CREATE_FOLDER,
#ifdef LANG
0x02000603,
#endif
dirPath);
Result = E_FAIL;
return;
}
ExtractCallbackSpec->Init(ArchiveLink.GetArchive(), dirPath, L"Default", fi.MTime, 0);
#ifndef _NO_PROGRESS
if (ShowProgress)
ExtractCallbackSpec->ProgressDialog.WaitCreating();
#endif
Result = ArchiveLink.GetArchive()->Extract(0, (UInt32)-1 , BoolToInt(false), ExtractCallback);
#ifndef _NO_PROGRESS
if (ShowProgress)
ExtractCallbackSpec->ProgressDialog.MyClose();
#endif
}
HRESULT DecompressArchives(
UStringVector &archivePaths, UStringVector &archivePathsFull,
const NWildcard::CCensorNode &wildcardCensor,
const CExtractOptions &optionsSpec,
IOpenCallbackUI *openCallback,
IExtractCallbackUI *extractCallback)
{
CExtractOptions options = optionsSpec;
for (int i = 0; i < archivePaths.Size(); i++)
{
const UString &archivePath = archivePaths[i];
NFile::NFind::CFileInfoW archiveFileInfo;
if (!NFile::NFind::FindFile(archivePath, archiveFileInfo))
throw "there is no such archive";
if (archiveFileInfo.IsDirectory())
throw "there is no such archive";
options.ArchiveFileInfo = archiveFileInfo;
RINOK(extractCallback->BeforeOpen(archivePath));
CArchiveLink archiveLink;
HRESULT result = MyOpenArchive(archivePath, archiveLink, openCallback);
RINOK(extractCallback->OpenResult(archivePath, result));
if (result != S_OK)
continue;
for (int v = 0; v < archiveLink.VolumePaths.Size(); v++)
{
int index = archivePathsFull.FindInSorted(archiveLink.VolumePaths[v]);
if (index >= 0 && index > i)
{
archivePaths.Delete(index);
archivePathsFull.Delete(index);
}
}
#ifndef _NO_CRYPTO
UString password;
RINOK(openCallback->GetPasswordIfAny(password));
if (!password.IsEmpty())
{
RINOK(extractCallback->SetPassword(password));
}
#endif
options.DefaultItemName = archiveLink.GetDefaultItemName();
RINOK(DecompressArchive(
archiveLink.GetArchive(), archiveLink.GetDefaultItemName(),
wildcardCensor, options, extractCallback));
}
return S_OK;
}
HRESULT ReOpenArchive(CCodecs *codecs, CArchiveLink &archiveLink, const UString &fileName)
{
if (archiveLink.GetNumLevels() > 1)
return E_NOTIMPL;
if (archiveLink.GetNumLevels() == 0)
return MyOpenArchive(codecs, fileName, archiveLink, 0);
CMyComPtr<IArchiveOpenCallback> openCallback;
SetCallback(fileName, NULL, openCallback);
HRESULT res = ReOpenArchive(archiveLink.GetArchive(), fileName, openCallback);
archiveLink.IsOpen = (res == S_OK);
return res;
}
HRESULT DecompressArchives(
CCodecs *codecs, const CIntVector &formatIndices,
UStringVector &archivePaths, UStringVector &archivePathsFull,
const NWildcard::CCensorNode &wildcardCensor,
const CExtractOptions &optionsSpec,
IOpenCallbackUI *openCallback,
IExtractCallbackUI *extractCallback,
UString &errorMessage,
CDecompressStat &stat)
{
stat.Clear();
CExtractOptions options = optionsSpec;
int i;
UInt64 totalPackSize = 0;
CRecordVector<UInt64> archiveSizes;
for (i = 0; i < archivePaths.Size(); i++)
{
const UString &archivePath = archivePaths[i];
NFile::NFind::CFileInfoW fi;
if (!NFile::NFind::FindFile(archivePath, fi))
throw "there is no such archive";
if (fi.IsDir())
throw "can't decompress folder";
archiveSizes.Add(fi.Size);
totalPackSize += fi.Size;
}
CArchiveExtractCallback *extractCallbackSpec = new CArchiveExtractCallback;
CMyComPtr<IArchiveExtractCallback> ec(extractCallbackSpec);
bool multi = (archivePaths.Size() > 1);
extractCallbackSpec->InitForMulti(multi, options.PathMode, options.OverwriteMode);
if (multi)
{
RINOK(extractCallback->SetTotal(totalPackSize));
}
for (i = 0; i < archivePaths.Size(); i++)
{
const UString &archivePath = archivePaths[i];
NFile::NFind::CFileInfoW fi;
if (!NFile::NFind::FindFile(archivePath, fi))
throw "there is no such archive";
if (fi.IsDir())
throw "there is no such archive";
options.ArchiveFileInfo = fi;
#ifndef _NO_CRYPTO
openCallback->Open_ClearPasswordWasAskedFlag();
#endif
RINOK(extractCallback->BeforeOpen(archivePath));
CArchiveLink archiveLink;
CIntVector formatIndices2 = formatIndices;
#ifndef _SFX
if (formatIndices.IsEmpty())
{
int pos = archivePath.ReverseFind(L'.');
if (pos >= 0)
{
UString s = archivePath.Mid(pos + 1);
int index = codecs->FindFormatForExtension(s);
if (index >= 0 && s == L"001")
{
s = archivePath.Left(pos);
pos = s.ReverseFind(L'.');
if (pos >= 0)
{
int index2 = codecs->FindFormatForExtension(s.Mid(pos + 1));
if (index2 >= 0 && s.CompareNoCase(L"rar") != 0)
{
formatIndices2.Add(index2);
formatIndices2.Add(index);
}
}
}
}
}
#endif
HRESULT result = MyOpenArchive(codecs, formatIndices2, archivePath, archiveLink, openCallback);
if (result == E_ABORT)
return result;
bool crypted = false;
#ifndef _NO_CRYPTO
crypted = openCallback->Open_WasPasswordAsked();
#endif
RINOK(extractCallback->OpenResult(archivePath, result, crypted));
if (result != S_OK)
continue;
for (int v = 0; v < archiveLink.VolumePaths.Size(); v++)
{
int index = archivePathsFull.FindInSorted(archiveLink.VolumePaths[v]);
if (index >= 0 && index > i)
{
archivePaths.Delete(index);
archivePathsFull.Delete(index);
totalPackSize -= archiveSizes[index];
archiveSizes.Delete(index);
}
}
if (archiveLink.VolumePaths.Size() != 0)
{
totalPackSize += archiveLink.VolumesSize;
RINOK(extractCallback->SetTotal(totalPackSize));
}
#ifndef _NO_CRYPTO
UString password;
RINOK(openCallback->Open_GetPasswordIfAny(password));
if (!password.IsEmpty())
{
RINOK(extractCallback->SetPassword(password));
}
#endif
options.DefaultItemName = archiveLink.GetDefaultItemName();
RINOK(DecompressArchive(
archiveLink.GetArchive(),
fi.Size + archiveLink.VolumesSize,
wildcardCensor, options, extractCallback, extractCallbackSpec, errorMessage));
extractCallbackSpec->LocalProgressSpec->InSize += fi.Size +
archiveLink.VolumesSize;
extractCallbackSpec->LocalProgressSpec->OutSize = extractCallbackSpec->UnpackSize;
if (!errorMessage.IsEmpty())
return E_FAIL;
}
stat.NumFolders = extractCallbackSpec->NumFolders;
stat.NumFiles = extractCallbackSpec->NumFiles;
stat.UnpackSize = extractCallbackSpec->UnpackSize;
stat.NumArchives = archivePaths.Size();
stat.PackSize = extractCallbackSpec->LocalProgressSpec->InSize;
return S_OK;
}
HRESULT ListArchives(
CCodecs *codecs,
UStringVector &archivePaths, UStringVector &archivePathsFull,
const NWildcard::CCensorNode &wildcardCensor,
bool enableHeaders, bool techMode, bool &passwordEnabled, UString &password, UInt64 &numErrors)
{
numErrors = 0;
CFieldPrinter fieldPrinter;
if (!techMode)
fieldPrinter.Init(kStandardFieldTable, sizeof(kStandardFieldTable) / sizeof(kStandardFieldTable[0]));
UInt64 numFiles2 = 0, numDirs2 = 0, totalPackSize2 = 0, totalUnPackSize2 = 0;
UInt64 *totalPackSizePointer2 = 0, *totalUnPackSizePointer2 = 0;
for (int i = 0; i < archivePaths.Size(); i++)
{
const UString &archiveName = archivePaths[i];
NFile::NFind::CFileInfoW archiveFileInfo;
if (!NFile::NFind::FindFile(archiveName, archiveFileInfo) || archiveFileInfo.IsDirectory())
{
g_StdOut << endl << "Error: " << archiveName << " is not archive" << endl;
numErrors++;
continue;
}
if (archiveFileInfo.IsDirectory())
{
g_StdOut << endl << "Error: " << archiveName << " is not file" << endl;
numErrors++;
continue;
}
CArchiveLink archiveLink;
COpenCallbackConsole openCallback;
openCallback.OutStream = &g_StdOut;
openCallback.PasswordIsDefined = passwordEnabled;
openCallback.Password = password;
HRESULT result = MyOpenArchive(codecs, archiveName, archiveLink, &openCallback);
if (result != S_OK)
{
g_StdOut << endl << "Error: " << archiveName << " is not supported archive" << endl;
numErrors++;
continue;
}
for (int v = 0; v < archiveLink.VolumePaths.Size(); v++)
{
int index = archivePathsFull.FindInSorted(archiveLink.VolumePaths[v]);
if (index >= 0 && index > i)
{
archivePaths.Delete(index);
archivePathsFull.Delete(index);
}
}
IInArchive *archive = archiveLink.GetArchive();
const UString defaultItemName = archiveLink.GetDefaultItemName();
if (enableHeaders)
{
g_StdOut << endl << kListing << archiveName << endl << endl;
UInt32 numProps;
if (archive->GetNumberOfArchiveProperties(&numProps) == S_OK)
{
for (UInt32 i = 0; i < numProps; i++)
{
CMyComBSTR name;
PROPID propID;
VARTYPE vt;
if (archive->GetArchivePropertyInfo(i, &name, &propID, &vt) != S_OK)
continue;
NCOM::CPropVariant prop;
if (archive->GetArchiveProperty(propID, &prop) != S_OK)
continue;
UString s = ConvertPropertyToString(prop, propID);
if (!s.IsEmpty())
g_StdOut << GetPropName(propID, name) << " = " << s << endl;
}
}
if (techMode)
g_StdOut << "----------\n";
if (numProps > 0)
g_StdOut << endl;
}
if (enableHeaders && !techMode)
{
fieldPrinter.PrintTitle();
g_StdOut << endl;
fieldPrinter.PrintTitleLines();
g_StdOut << endl;
}
if (techMode)
{
RINOK(fieldPrinter.Init(archive));
}
UInt64 numFiles = 0, numDirs = 0, totalPackSize = 0, totalUnPackSize = 0;
UInt64 *totalPackSizePointer = 0, *totalUnPackSizePointer = 0;
UInt32 numItems;
RINOK(archive->GetNumberOfItems(&numItems));
for(UInt32 i = 0; i < numItems; i++)
{
if (NConsoleClose::TestBreakSignal())
return E_ABORT;
UString filePath;
RINOK(GetArchiveItemPath(archive, i, defaultItemName, filePath));
bool isFolder;
RINOK(IsArchiveItemFolder(archive, i, isFolder));
if (!wildcardCensor.CheckPath(filePath, !isFolder))
continue;
fieldPrinter.PrintItemInfo(archive, defaultItemName, archiveFileInfo, i, techMode);
UInt64 packSize, unpackSize;
if (!GetUInt64Value(archive, i, kpidSize, unpackSize))
unpackSize = 0;
else
totalUnPackSizePointer = &totalUnPackSize;
if (!GetUInt64Value(archive, i, kpidPackedSize, packSize))
packSize = 0;
else
totalPackSizePointer = &totalPackSize;
g_StdOut << endl;
if (isFolder)
numDirs++;
else
numFiles++;
totalPackSize += packSize;
totalUnPackSize += unpackSize;
}
if (enableHeaders && !techMode)
{
fieldPrinter.PrintTitleLines();
g_StdOut << endl;
fieldPrinter.PrintSummaryInfo(numFiles, numDirs, totalUnPackSizePointer, totalPackSizePointer);
g_StdOut << endl;
}
if (totalPackSizePointer != 0)
{
totalPackSizePointer2 = &totalPackSize2;
totalPackSize2 += totalPackSize;
}
if (totalUnPackSizePointer != 0)
{
totalUnPackSizePointer2 = &totalUnPackSize2;
totalUnPackSize2 += totalUnPackSize;
}
numFiles2 += numFiles;
numDirs2 += numDirs;
}
if (enableHeaders && !techMode && archivePaths.Size() > 1)
{
g_StdOut << endl;
fieldPrinter.PrintTitleLines();
g_StdOut << endl;
fieldPrinter.PrintSummaryInfo(numFiles2, numDirs2, totalUnPackSizePointer2, totalPackSizePointer2);
g_StdOut << endl;
g_StdOut << "Archives: " << archivePaths.Size() << endl;
}
return S_OK;
}
// Create a new 7z archive for each folder contained in the archive to be
// exploded.
HRESULT ExplodeArchives(CCodecs *codecs, const CIntVector &formatIndices,
bool stdInMode,
UStringVector &arcPaths, UStringVector &arcPathsFull,
UString& outputPath, UInt64 maxDepth, UInt64 &numErrors)
{
int numArcs = arcPaths.Size();
for (int i = 0; i < numArcs; i++)
{
UString archivePath = arcPaths[i];
/*UString outputPath = arcPaths[i];
outputPath.Replace(L'\\', L'/'); // linux and windows consistent
const UString archiveName = StripFile(outputPath);
outputPath.Empty();*/
archivePath.Replace(L'\\', L'/'); // linux, windows and archive consistent
outputPath.Replace(L'\\', L'/');
FixPathFormat(outputPath);
const UString archiveName = GetFileFromPath(archivePath);
g_StdOut << "Outputting into : " << outputPath << endl;
UInt64 arcPackSize = 0;
if (!stdInMode)
{
NFile::NFind::CFileInfoW fi;
if (!fi.Find(archivePath) || fi.IsDir())
{
SHOW_ERROR("is not a file.");
continue;
}
arcPackSize = fi.Size;
}
g_StdOut << endl << "Exploding : " << archivePath << endl << endl;
CArchiveLink archiveLink;
COpenCallbackConsole openCallback;
openCallback.OutStream = &g_StdOut;
#ifndef _NO_CRYPTO
openCallback.PasswordIsDefined = false;
#endif
HRESULT result = archiveLink.Open2(codecs, formatIndices, stdInMode, NULL, archivePath, &openCallback);
if (result != S_OK)
{
if (result == E_ABORT)
return result;
g_StdOut << endl << "Error: " << archivePath << ": ";
if (result == S_FALSE)
g_StdOut << "Can not open file as archive";
else if (result == E_OUTOFMEMORY)
g_StdOut << "Can't allocate required memory";
else
g_StdOut << NError::MyFormatMessage(result);
g_StdOut << endl;
numErrors++;
continue;
}
// remove other files names if multi-volume
if (!stdInMode) {
for (int v = 0; v < archiveLink.VolumePaths.Size(); v++)
{
int index = arcPathsFull.FindInSorted(archiveLink.VolumePaths[v]);
if (index >= 0 && index > i)
{
arcPaths.Delete(index);
arcPathsFull.Delete(index);
numArcs = arcPaths.Size();
}
}
}
// don't support multi volume because i have to reopen the stream
if (archiveLink.VolumePaths.Size() != 1) {
SHOW_ERROR("Exploding multi-volume archives isn't supported.");
continue;
}
bool szArchive = true;
for (int x = 0; x < archiveLink.Arcs.Size(); x++)
{
const UString szName = L"7z";
const CArc &arc = archiveLink.Arcs[x];
if (codecs->Formats[arc.FormatIndex].Name != szName) {
szArchive = false;
break;
}
}
if (!szArchive) {
SHOW_ERROR("Only 7z archives can be exploded.");
continue;
}
// Only 7z is supported, and it's been checked
using namespace NArchive::N7z;
IInArchive* inArc = archiveLink.GetArchive();
CHandler* szHandler = (CHandler*)inArc;
// not a fan of having to reopen the file..
CInFileStream* _inStream = new CInFileStream;
CMyComPtr<CInFileStream> inStream(_inStream);
if (!inStream->Open(archivePath)) {
SHOW_ERROR("Cannot be opened for reading.");
continue;
}
// Explode the archive into each folder
CObjectVector<szExplodeData> exploded;
szHandler->Explode(exploded, maxDepth);
if (exploded.Size() == 0) {
SHOW_ERROR("Empty archive!");
continue;
}
// should make a struct that gets passed to Explode..
// something like
/*
* struct a {
* CArchiveDatabase newDatabase;
* CRecordVector<UInt64> folderSizes, folderPositions
* };
* CObjectVector<a> exploded;
* szHandler->Explode(exploded);
*/
// Save each folder as a new 7z archive
for (int x = 0; x < exploded.Size(); x++) {
UString relativeFilePath; // relative to archive
UString fileName;
CArchiveDatabase& newDatabase = exploded[x].newDatabase;
szExplodeData& explodeData = exploded[x];
// each exploded archive will only have a single folder.
// no longer true. need to make sure the selected file
// is the highest in the dir tree. could make 7zhandler
// give us this info i guess.
if (newDatabase.Files.Size() > 0) {
relativeFilePath = newDatabase.Files[0].Name;
if (!newDatabase.Files[0].IsDir) {
fileName = GetFileFromPath(relativeFilePath);
StripFile(relativeFilePath);
}
}
//g_StdOut << "Relative path " << relativeFilePath << endl;
//g_StdOut << "Archive " << archivePath << endl;
UString folderOutPath = outputPath + relativeFilePath;
if (relativeFilePath.Length() != 0) {
bool b = NWindows::NFile::NDirectory::CreateComplexDirectory(folderOutPath);
if (!b) g_StdOut << "Couldn't create directory " << folderOutPath << endl;
//relativeFilePath.Insert(folderOutPath.Length(), L'/');
}
std::wstringstream sstream;
sstream << folderOutPath.GetBuffer();
if (newDatabase.Files.Size() == 1) // can use file names
sstream << fileName.GetBuffer();
else // use folder as name
sstream << archiveName.GetBuffer() << L"_folder_" << x;
sstream << ".7z";
g_StdOut << "Saving as '" << sstream.str().c_str() << "'" << endl;
COutFileStream* _outstream = new COutFileStream;
CMyComPtr<COutFileStream> outstream(_outstream);
outstream->Create(sstream.str().c_str(), true);
COutArchive out;
out.Create(outstream, false);
out.SkipPrefixArchiveHeader();
for (int folderIndex = 0; folderIndex < newDatabase.Folders.Size();
folderIndex++)
{
UInt64 folderLen = explodeData.folderSizes[folderIndex];
UInt64 folderStartPackPos = explodeData.folderPositions[folderIndex];
// write actual data
RINOK(WriteRange(inStream, out.SeqStream,
folderStartPackPos, folderLen, NULL));
}
CCompressionMethodMode method, headerMethod;
szHandler->SetCompressionMethod(method, headerMethod);
CHeaderOptions headerOptions;
headerOptions.CompressMainHeader = true;
out.WriteDatabase(newDatabase, &headerMethod, headerOptions);
out.Close();
/*#ifdef ENV_UNIX
// Create a symlink for each file in the folder.
// This makes it seem as though each file is individually accessible.
for (int fileIndex = 0; fileIndex < newDatabase.Files.Size(); fileIndex++) {
AString oldfile, newfile;
UString woldfile = sstream.str().c_str();
UString wnewfile = outputPath + relativeFilePath + newDatabase.Files[fileIndex].Name + L".7z";
ConvertUnicodeToUTF8(woldfile, oldfile);
ConvertUnicodeToUTF8(wnewfile, newfile);
const char* link_to = oldfile.GetBuffer();
const char* link_name = newfile.GetBuffer();
unlink(link_name);// should ask user
//g_StdOut << "Creating symlink to '" << link_to << "' called '" << link_name << "'" << endl;
int status = symlink(link_to, link_name);
if (status == -1) {
AString error = "Couldn't create symlink for '";
error += newfile;
error += "'";
SHOW_ERROR(error);
g_StdOut << "Error: " << errno << endl;
}
}
#endif*/
}
archiveLink.Close(); // not needed but oh well
}
return S_OK;
}