// ArchiveExtractCallback.cpp
#include "StdAfx.h"
#undef sprintf
#undef printf
#include "../../../Common/ComTry.h"
#include "../../../Common/StringConvert.h"
#include "../../../Common/Wildcard.h"
#include "../../../Windows/FileDir.h"
#include "../../../Windows/FileFind.h"
#include "../../../Windows/FileName.h"
#include "../../../Windows/PropVariant.h"
#include "../../../Windows/PropVariantConv.h"
#if defined(_WIN32) && !defined(UNDER_CE) && !defined(_SFX)
#define _USE_SECURITY_CODE
#include "../../../Windows/SecurityUtils.h"
#endif
#include "../../Common/FilePathAutoRename.h"
#include "../Common/ExtractingFilePath.h"
#include "../Common/PropIDUtils.h"
#include "ArchiveExtractCallback.h"
using namespace NWindows;
using namespace NFile;
using namespace NDir;
static const char *kCantAutoRename = "Can not create file with auto name";
static const char *kCantRenameFile = "Can not rename existing file";
static const char *kCantDeleteOutputFile = "Can not delete output file";
static const char *kCantDeleteOutputDir = "Can not delete output folder";
#ifndef _SFX
STDMETHODIMP COutStreamWithHash::Write(const void *data, UInt32 size, UInt32 *processedSize)
{
HRESULT result = S_OK;
if (_stream)
result = _stream->Write(data, size, &size);
if (_calculate)
_hash->Update(data, size);
_size += size;
if (processedSize)
*processedSize = size;
return result;
}
#endif
#ifdef _USE_SECURITY_CODE
bool InitLocalPrivileges()
{
NSecurity::CAccessToken token;
if (!token.OpenProcessToken(GetCurrentProcess(),
TOKEN_QUERY | TOKEN_ADJUST_PRIVILEGES))
return false;
TOKEN_PRIVILEGES tp;
tp.PrivilegeCount = 1;
tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
if (!::LookupPrivilegeValue(NULL, SE_SECURITY_NAME, &tp.Privileges[0].Luid))
return false;
if (!token.AdjustPrivileges(&tp))
return false;
return (GetLastError() == ERROR_SUCCESS);
}
#endif
#ifdef SUPPORT_LINKS
int CHardLinkNode::Compare(const CHardLinkNode &a) const
{
if (StreamId < a.StreamId) return -1;
if (StreamId > a.StreamId) return 1;
return MyCompare(INode, a.INode);
}
HRESULT Archive_Get_HardLinkNode(IInArchive *archive, UInt32 index, CHardLinkNode &h, bool &defined)
{
h.INode = 0;
h.StreamId = (UInt64)(Int64)-1;
defined = false;
{
NCOM::CPropVariant prop;
RINOK(archive->GetProperty(index, kpidINode, &prop));
if (!ConvertPropVariantToUInt64(prop, h.INode))
return S_OK;
}
{
NCOM::CPropVariant prop;
RINOK(archive->GetProperty(index, kpidStreamId, &prop));
ConvertPropVariantToUInt64(prop, h.StreamId);
}
defined = true;
return S_OK;
}
HRESULT CArchiveExtractCallback::PrepareHardLinks(const CRecordVector<UInt32> *realIndices)
{
_hardLinks.Clear();
if (!_arc->Ask_INode)
return S_OK;
IInArchive *archive = _arc->Archive;
CRecordVector<CHardLinkNode> &hardIDs = _hardLinks.IDs;
{
UInt32 numItems;
if (realIndices)
numItems = realIndices->Size();
else
{
RINOK(archive->GetNumberOfItems(&numItems));
}
for (UInt32 i = 0; i < numItems; i++)
{
CHardLinkNode h;
bool defined;
RINOK(Archive_Get_HardLinkNode(archive, realIndices ? (*realIndices)[i] : i, h, defined));
if (defined)
hardIDs.Add(h);
}
}
hardIDs.Sort2();
{
// wee keep only items that have 2 or more items
unsigned k = 0;
unsigned numSame = 1;
for (unsigned i = 1; i < hardIDs.Size(); i++)
{
if (hardIDs[i].Compare(hardIDs[i - 1]) != 0)
numSame = 1;
else if (++numSame == 2)
{
if (i - 1 != k)
hardIDs[k] = hardIDs[i - 1];
k++;
}
}
hardIDs.DeleteFrom(k);
}
_hardLinks.PrepareLinks();
return S_OK;
}
#endif
CArchiveExtractCallback::CArchiveExtractCallback():
WriteCTime(true),
WriteATime(true),
WriteMTime(true),
_multiArchives(false)
{
LocalProgressSpec = new CLocalProgress();
_localProgress = LocalProgressSpec;
#ifdef _USE_SECURITY_CODE
_saclEnabled = InitLocalPrivileges();
#endif
}
void CArchiveExtractCallback::Init(
const CExtractNtOptions &ntOptions,
const NWildcard::CCensorNode *wildcardCensor,
const CArc *arc,
IFolderArchiveExtractCallback *extractCallback2,
bool stdOutMode, bool testMode,
const FString &directoryPath,
const UStringVector &removePathParts,
UInt64 packSize)
{
_extractedFolderPaths.Clear();
_extractedFolderIndices.Clear();
#ifdef SUPPORT_LINKS
_hardLinks.Clear();
#endif
_ntOptions = ntOptions;
_wildcardCensor = wildcardCensor;
_stdOutMode = stdOutMode;
_testMode = testMode;
_unpTotal = 1;
_packTotal = packSize;
_extractCallback2 = extractCallback2;
_compressProgress.Release();
_extractCallback2.QueryInterface(IID_ICompressProgressInfo, &_compressProgress);
#ifndef _SFX
_extractCallback2.QueryInterface(IID_IFolderExtractToStreamCallback, &ExtractToStreamCallback);
if (ExtractToStreamCallback)
{
Int32 useStreams = 0;
if (ExtractToStreamCallback->UseExtractToStream(&useStreams) != S_OK)
useStreams = 0;
if (useStreams == 0)
ExtractToStreamCallback.Release();
}
#endif
LocalProgressSpec->Init(extractCallback2, true);
LocalProgressSpec->SendProgress = false;
_removePathParts = removePathParts;
_baseParentFolder = (UInt32)(Int32)-1;
_use_baseParentFolder_mode = false;
_arc = arc;
_directoryPath = directoryPath;
NName::NormalizeDirPathPrefix(_directoryPath);
NDir::MyGetFullPathName(directoryPath, _directoryPathFull);
}
STDMETHODIMP CArchiveExtractCallback::SetTotal(UInt64 size)
{
COM_TRY_BEGIN
_unpTotal = size;
if (!_multiArchives && _extractCallback2)
return _extractCallback2->SetTotal(size);
return S_OK;
COM_TRY_END
}
static void NormalizeVals(UInt64 &v1, UInt64 &v2)
{
const UInt64 kMax = (UInt64)1 << 31;
while (v1 > kMax)
{
v1 >>= 1;
v2 >>= 1;
}
}
static UInt64 MyMultDiv64(UInt64 unpCur, UInt64 unpTotal, UInt64 packTotal)
{
NormalizeVals(packTotal, unpTotal);
NormalizeVals(unpCur, unpTotal);
if (unpTotal == 0)
unpTotal = 1;
return unpCur * packTotal / unpTotal;
}
STDMETHODIMP CArchiveExtractCallback::SetCompleted(const UInt64 *completeValue)
{
COM_TRY_BEGIN
if (!_extractCallback2)
return S_OK;
if (_multiArchives)
{
if (completeValue != NULL)
{
UInt64 packCur = LocalProgressSpec->InSize + MyMultDiv64(*completeValue, _unpTotal, _packTotal);
return _extractCallback2->SetCompleted(&packCur);
}
}
return _extractCallback2->SetCompleted(completeValue);
COM_TRY_END
}
STDMETHODIMP CArchiveExtractCallback::SetRatioInfo(const UInt64 *inSize, const UInt64 *outSize)
{
COM_TRY_BEGIN
return _localProgress->SetRatioInfo(inSize, outSize);
COM_TRY_END
}
#define IS_LETTER_CHAR(c) ((c) >= 'a' && (c) <= 'z' || (c) >= 'A' && (c) <= 'Z')
static inline bool IsDriveName(const UString &s)
{
return s.Len() == 2 && s[1] == ':' && IS_LETTER_CHAR(s[0]);
}
void CArchiveExtractCallback::CreateComplexDirectory(const UStringVector &dirPathParts, FString &fullPath)
{
bool isAbsPath = false;
if (!dirPathParts.IsEmpty())
{
const UString &s = dirPathParts[0];
if (s.IsEmpty())
isAbsPath = true;
#ifdef _WIN32
else
{
if (dirPathParts.Size() > 1 && IsDriveName(s))
isAbsPath = true;
}
#endif
}
if (_pathMode == NExtract::NPathMode::kAbsPaths && isAbsPath)
fullPath.Empty();
else
fullPath = _directoryPath;
FOR_VECTOR (i, dirPathParts)
{
if (i > 0)
fullPath += FCHAR_PATH_SEPARATOR;
const UString &s = dirPathParts[i];
fullPath += us2fs(s);
#ifdef _WIN32
if (_pathMode == NExtract::NPathMode::kAbsPaths)
if (i == 0 && IsDriveName(s))
continue;
#endif
CreateDir(fullPath);
}
}
HRESULT CArchiveExtractCallback::GetTime(int index, PROPID propID, FILETIME &filetime, bool &filetimeIsDefined)
{
filetimeIsDefined = false;
NCOM::CPropVariant prop;
RINOK(_arc->Archive->GetProperty(index, propID, &prop));
if (prop.vt == VT_FILETIME)
{
filetime = prop.filetime;
filetimeIsDefined = (filetime.dwHighDateTime != 0 || filetime.dwLowDateTime != 0);
}
else if (prop.vt != VT_EMPTY)
return E_FAIL;
return S_OK;
}
HRESULT CArchiveExtractCallback::GetUnpackSize()
{
return _arc->GetItemSize(_index, _curSize, _curSizeDefined);
}
HRESULT CArchiveExtractCallback::SendMessageError(const char *message, const FString &path)
{
return _extractCallback2->MessageError(
UString(L"ERROR: ") +
GetUnicodeString(message) + L": " + fs2us(path));
}
HRESULT CArchiveExtractCallback::SendMessageError2(const char *message, const FString &path1, const FString &path2)
{
return _extractCallback2->MessageError(
UString(L"ERROR: ") +
GetUnicodeString(message) + UString(L": ") + fs2us(path1) + UString(L" : ") + fs2us(path2));
}
#ifndef _SFX
STDMETHODIMP CGetProp::GetProp(PROPID propID, PROPVARIANT *value)
{
if (propID == kpidName)
{
COM_TRY_BEGIN
NCOM::CPropVariant prop = Name.Ptr();
prop.Detach(value);
return S_OK;
COM_TRY_END
}
return Arc->Archive->GetProperty(IndexInArc, propID, value);
}
#endif
#ifdef SUPPORT_LINKS
static UString GetDirPrefixOf(const UString &src)
{
UString s = src;
if (!s.IsEmpty())
{
if (s.Back() == WCHAR_PATH_SEPARATOR)
s.DeleteBack();
int pos = s.ReverseFind(WCHAR_PATH_SEPARATOR);
s.DeleteFrom(pos + 1);
}
return s;
}
static bool IsSafePath(const UString &path)
{
UStringVector parts;
SplitPathToParts(path, parts);
int level = 0;
FOR_VECTOR(i, parts)
{
const UString &s = parts[i];
if (s.IsEmpty())
continue;
if (s == L".")
continue;
if (s == L"..")
{
if (level <= 0)
return false;
level--;
}
else
level++;
}
return level > 0;
}
#endif
STDMETHODIMP CArchiveExtractCallback::GetStream(UInt32 index, ISequentialOutStream **outStream, Int32 askExtractMode)
{
COM_TRY_BEGIN
*outStream = 0;
#ifndef _SFX
if (_hashStream)
_hashStreamSpec->ReleaseStream();
_hashStreamWasUsed = false;
#endif
_outFileStream.Release();
_encrypted = false;
_isSplit = false;
_isAltStream = false;
_curSize = 0;
_curSizeDefined = false;
_index = index;
UString fullPath;
IInArchive *archive = _arc->Archive;
RINOK(_arc->GetItemPath(index, fullPath));
RINOK(Archive_IsItem_Folder(archive, index, _fi.IsDir));
_filePath = fullPath;
{
NCOM::CPropVariant prop;
RINOK(archive->GetProperty(index, kpidPosition, &prop));
if (prop.vt != VT_EMPTY)
{
if (prop.vt != VT_UI8)
return E_FAIL;
_position = prop.uhVal.QuadPart;
_isSplit = true;
}
}
#ifdef SUPPORT_LINKS
bool isHardLink = false;
bool isJunction = false;
bool isRelative = false;
UString linkPath;
// RINOK(Archive_GetItemBoolProp(archive, index, kpidIsHardLink, isHardLink));
// if (isHardLink)
{
NCOM::CPropVariant prop;
RINOK(archive->GetProperty(index, kpidHardLink, &prop));
if (prop.vt == VT_BSTR)
{
isHardLink = true;
linkPath = prop.bstrVal;
isRelative = false; // TAR: hard links are from root folder of archive
}
else if (prop.vt == VT_EMPTY)
{
// linkPath.Empty();
}
else
return E_FAIL;
}
{
NCOM::CPropVariant prop;
RINOK(archive->GetProperty(index, kpidSymLink, &prop));
if (prop.vt == VT_BSTR)
{
isHardLink = false;
linkPath = prop.bstrVal;
isRelative = true; // TAR: symbolic links are relative
}
else if (prop.vt == VT_EMPTY)
{
// linkPath.Empty();
}
else
return E_FAIL;
}
bool isOkReparse = false;
if (linkPath.IsEmpty() && _arc->GetRawProps)
{
const void *data;
UInt32 dataSize;
UInt32 propType;
_arc->GetRawProps->GetRawProp(_index, kpidNtReparse, &data, &dataSize, &propType);
if (dataSize != 0)
{
if (propType != NPropDataType::kRaw)
return E_FAIL;
UString s;
CReparseAttr reparse;
isOkReparse = reparse.Parse((const Byte *)data, dataSize);
if (isOkReparse)
{
isHardLink = false;
linkPath = reparse.GetPath();
isJunction = reparse.IsMountPoint();
isRelative = reparse.IsRelative();
#ifndef _WIN32
linkPath.Replace(WCHAR_PATH_SEPARATOR, '/', );
#endif
}
}
}
if (!linkPath.IsEmpty())
{
#ifdef _WIN32
linkPath.Replace('/', WCHAR_PATH_SEPARATOR);
#endif
for (;;)
// while (NName::IsAbsolutePath(linkPath))
{
unsigned n = NName::GetRootPrefixSize(linkPath);
if (n == 0)
break;
isRelative = false;
linkPath.DeleteFrontal(n);
}
}
if (!linkPath.IsEmpty() && !isRelative && _removePathParts.Size() != 0)
{
UStringVector pathParts;
SplitPathToParts(linkPath, pathParts);
bool badPrefix = false;
FOR_VECTOR (i, _removePathParts)
{
if (CompareFileNames(_removePathParts[i], pathParts[i]) != 0)
{
badPrefix = true;
break;
}
}
if (!badPrefix)
pathParts.DeleteFrontal(_removePathParts.Size());
linkPath = MakePathNameFromParts(pathParts);
}
#endif
RINOK(Archive_GetItemBoolProp(archive, index, kpidEncrypted, _encrypted));
RINOK(GetUnpackSize());
RINOK(Archive_IsItem_AltStream(archive, index, _isAltStream));
if (!_ntOptions.AltStreams.Val && _isAltStream)
return S_OK;
if (_wildcardCensor)
{
if (!_wildcardCensor->CheckPath(_isAltStream, fullPath, !_fi.IsDir))
return S_OK;
}
UStringVector pathParts;
if (_use_baseParentFolder_mode)
{
int baseParent = _baseParentFolder;
if (_pathMode == NExtract::NPathMode::kFullPaths ||
_pathMode == NExtract::NPathMode::kAbsPaths)
baseParent = -1;
RINOK(_arc->GetItemPathToParent(index, baseParent, pathParts));
if (_pathMode == NExtract::NPathMode::kNoPaths && !pathParts.IsEmpty())
pathParts.DeleteFrontal(pathParts.Size() - 1);
}
else
{
SplitPathToParts(fullPath, pathParts);
if (pathParts.IsEmpty())
return E_FAIL;
unsigned numRemovePathParts = 0;
switch (_pathMode)
{
case NExtract::NPathMode::kCurPaths:
{
bool badPrefix = false;
if (pathParts.Size() <= _removePathParts.Size())
badPrefix = true;
else
{
FOR_VECTOR (i, _removePathParts)
{
if (!_removePathParts[i].IsEqualToNoCase(pathParts[i]))
{
badPrefix = true;
break;
}
}
}
if (badPrefix)
{
if (askExtractMode == NArchive::NExtract::NAskMode::kExtract && !_testMode)
return E_FAIL;
}
else
numRemovePathParts = _removePathParts.Size();
break;
}
case NExtract::NPathMode::kNoPaths:
{
numRemovePathParts = pathParts.Size() - 1;
break;
}
/*
case NExtract::NPathMode::kFullPaths:
case NExtract::NPathMode::kAbsPaths:
break;
*/
}
pathParts.DeleteFrontal(numRemovePathParts);
}
#ifndef _SFX
if (ExtractToStreamCallback)
{
if (!GetProp)
{
GetProp_Spec = new CGetProp;
GetProp = GetProp_Spec;
}
GetProp_Spec->Arc = _arc;
GetProp_Spec->IndexInArc = index;
GetProp_Spec->Name = MakePathNameFromParts(pathParts);
return ExtractToStreamCallback->GetStream7(GetProp_Spec->Name, _fi.IsDir, outStream, askExtractMode, GetProp);
}
#endif
CMyComPtr<ISequentialOutStream> outStreamLoc;
if (askExtractMode == NArchive::NExtract::NAskMode::kExtract && !_testMode)
{
if (_stdOutMode)
{
outStreamLoc = new CStdOutFileStream;
}
else
{
{
NCOM::CPropVariant prop;
RINOK(archive->GetProperty(index, kpidAttrib, &prop));
if (prop.vt == VT_UI4)
{
_fi.Attrib = prop.ulVal;
_fi.AttribDefined = true;
}
else if (prop.vt == VT_EMPTY)
_fi.AttribDefined = false;
else
return E_FAIL;
}
RINOK(GetTime(index, kpidCTime, _fi.CTime, _fi.CTimeDefined));
RINOK(GetTime(index, kpidATime, _fi.ATime, _fi.ATimeDefined));
RINOK(GetTime(index, kpidMTime, _fi.MTime, _fi.MTimeDefined));
bool isAnti = false;
RINOK(_arc->IsItemAnti(index, isAnti));
bool replace = _isAltStream ?
_ntOptions.ReplaceColonForAltStream :
!_ntOptions.WriteToAltStreamIfColon;
if (_pathMode != NExtract::NPathMode::kAbsPaths)
MakeCorrectPath(_directoryPath.IsEmpty(), pathParts, replace);
Correct_IfEmptyLastPart(pathParts);
UString processedPath = MakePathNameFromParts(pathParts);
if (!isAnti)
{
if (!_fi.IsDir)
{
if (!pathParts.IsEmpty())
pathParts.DeleteBack();
}
if (!pathParts.IsEmpty())
{
FString fullPathNew;
CreateComplexDirectory(pathParts, fullPathNew);
if (_fi.IsDir)
{
_extractedFolderPaths.Add(fullPathNew);
_extractedFolderIndices.Add(index);
SetDirTime(fullPathNew,
(WriteCTime && _fi.CTimeDefined) ? &_fi.CTime : NULL,
(WriteATime && _fi.ATimeDefined) ? &_fi.ATime : NULL,
(WriteMTime && _fi.MTimeDefined) ? &_fi.MTime : (_arc->MTimeDefined ? &_arc->MTime : NULL));
}
}
}
FString fullProcessedPath = us2fs(processedPath);
if (_pathMode != NExtract::NPathMode::kAbsPaths ||
!NName::IsAbsolutePath(processedPath))
fullProcessedPath = _directoryPath + fullProcessedPath;
if (_fi.IsDir)
{
_diskFilePath = fullProcessedPath;
if (isAnti)
RemoveDir(_diskFilePath);
#ifdef SUPPORT_LINKS
if (linkPath.IsEmpty())
#endif
return S_OK;
}
else if (!_isSplit)
{
NFind::CFileInfo fileInfo;
if (fileInfo.Find(fullProcessedPath))
{
switch (_overwriteMode)
{
case NExtract::NOverwriteMode::kSkip:
return S_OK;
case NExtract::NOverwriteMode::kAsk:
{
int slashPos = fullProcessedPath.ReverseFind(FTEXT('/'));
#ifdef _WIN32
int slash1Pos = fullProcessedPath.ReverseFind(FTEXT('\\'));
slashPos = MyMax(slashPos, slash1Pos);
#endif
FString realFullProcessedPath = fullProcessedPath.Left(slashPos + 1) + fileInfo.Name;
Int32 overwiteResult;
RINOK(_extractCallback2->AskOverwrite(
fs2us(realFullProcessedPath), &fileInfo.MTime, &fileInfo.Size, fullPath,
_fi.MTimeDefined ? &_fi.MTime : NULL,
_curSizeDefined ? &_curSize : NULL,
&overwiteResult))
switch (overwiteResult)
{
case NOverwriteAnswer::kCancel: return E_ABORT;
case NOverwriteAnswer::kNo: return S_OK;
case NOverwriteAnswer::kNoToAll: _overwriteMode = NExtract::NOverwriteMode::kSkip; return S_OK;
case NOverwriteAnswer::kYes: break;
case NOverwriteAnswer::kYesToAll: _overwriteMode = NExtract::NOverwriteMode::kOverwrite; break;
case NOverwriteAnswer::kAutoRename: _overwriteMode = NExtract::NOverwriteMode::kRename; break;
default:
return E_FAIL;
}
}
}
if (_overwriteMode == NExtract::NOverwriteMode::kRename)
{
if (!AutoRenamePath(fullProcessedPath))
{
RINOK(SendMessageError(kCantAutoRename, fullProcessedPath));
return E_FAIL;
}
}
else if (_overwriteMode == NExtract::NOverwriteMode::kRenameExisting)
{
FString existPath = fullProcessedPath;
if (!AutoRenamePath(existPath))
{
RINOK(SendMessageError(kCantAutoRename, fullProcessedPath));
return E_FAIL;
}
// MyMoveFile can raname folders. So it's OK to use it folders too
if (!MyMoveFile(fullProcessedPath, existPath))
{
RINOK(SendMessageError(kCantRenameFile, fullProcessedPath));
return E_FAIL;
}
}
else
{
if (fileInfo.IsDir())
{
// do we need to delete all files in folder?
if (!RemoveDir(fullProcessedPath))
{
RINOK(SendMessageError(kCantDeleteOutputDir, fullProcessedPath));
return S_OK;
}
}
else if (!DeleteFileAlways(fullProcessedPath))
{
RINOK(SendMessageError(kCantDeleteOutputFile, fullProcessedPath));
return S_OK;
// return E_FAIL;
}
}
}
}
_diskFilePath = fullProcessedPath;
if (!isAnti)
{
#ifdef SUPPORT_LINKS
if (!linkPath.IsEmpty())
{
#ifndef UNDER_CE
UString relatPath;
if (isRelative)
relatPath = GetDirPrefixOf(_filePath);
relatPath += linkPath;
if (!IsSafePath(relatPath))
{
RINOK(SendMessageError("Dangerous link path was ignored", us2fs(relatPath)));
}
else
{
FString existPath;
if (isHardLink || !isRelative)
{
if (!NName::GetFullPath(_directoryPathFull, us2fs(relatPath), existPath))
{
RINOK(SendMessageError("Incorrect path", us2fs(relatPath)));
}
}
else
{
existPath = us2fs(linkPath);
}
if (!existPath.IsEmpty())
{
if (isHardLink)
{
if (!MyCreateHardLink(fullProcessedPath, existPath))
{
RINOK(SendMessageError2("Can not create hard link", fullProcessedPath, existPath));
// return S_OK;
}
}
else if (_ntOptions.SymLinks.Val)
{
// bool isSymLink = true; // = false for junction
if (_fi.IsDir && !isRelative)
{
// if it's before Vista we use Junction Point
// isJunction = true;
// convertToAbs = true;
}
CByteBuffer data;
if (FillLinkData(data, fs2us(existPath), !isJunction))
{
CReparseAttr attr;
if (!attr.Parse(data, data.Size()))
{
return E_FAIL; // "Internal conversion error";
}
if (!NFile::NIO::SetReparseData(fullProcessedPath, _fi.IsDir, data, (DWORD)data.Size()))
{
RINOK(SendMessageError("Can not set reparse data", fullProcessedPath));
}
}
}
}
}
#endif
}
else
#endif // SUPPORT_LINKS
{
bool needWriteFile = true;
#ifdef SUPPORT_LINKS
if (!_hardLinks.IDs.IsEmpty())
{
CHardLinkNode h;
bool defined;
RINOK(Archive_Get_HardLinkNode(archive, index, h, defined));
if (defined)
{
{
int linkIndex = _hardLinks.IDs.FindInSorted2(h);
if (linkIndex >= 0)
{
FString &hl = _hardLinks.Links[linkIndex];
if (hl.IsEmpty())
hl = fullProcessedPath;
else
{
if (!MyCreateHardLink(fullProcessedPath, hl))
{
RINOK(SendMessageError2("Can not create hard link", fullProcessedPath, hl));
return S_OK;
}
needWriteFile = false;
}
}
}
}
}
#endif
if (needWriteFile)
{
_outFileStreamSpec = new COutFileStream;
CMyComPtr<ISequentialOutStream> outStreamLoc(_outFileStreamSpec);
if (!_outFileStreamSpec->Open(fullProcessedPath, _isSplit ? OPEN_ALWAYS: CREATE_ALWAYS))
{
// if (::GetLastError() != ERROR_FILE_EXISTS || !isSplit)
{
RINOK(SendMessageError("Can not open output file ", fullProcessedPath));
return S_OK;
}
}
if (_isSplit)
{
RINOK(_outFileStreamSpec->Seek(_position, STREAM_SEEK_SET, NULL));
}
_outFileStream = outStreamLoc;
}
}
}
outStreamLoc = _outFileStream;
}
}
#ifndef _SFX
if (_hashStream)
{
if (askExtractMode == NArchive::NExtract::NAskMode::kExtract ||
askExtractMode == NArchive::NExtract::NAskMode::kTest)
{
_hashStreamSpec->SetStream(outStreamLoc);
outStreamLoc = _hashStream;
_hashStreamSpec->Init(true);
_hashStreamWasUsed = true;
}
}
#endif
if (outStreamLoc)
*outStream = outStreamLoc.Detach();
return S_OK;
COM_TRY_END
}
STDMETHODIMP CArchiveExtractCallback::PrepareOperation(Int32 askExtractMode)
{
COM_TRY_BEGIN
#ifndef _SFX
if (ExtractToStreamCallback)
return ExtractToStreamCallback->PrepareOperation7(askExtractMode);
#endif
_extractMode = false;
switch (askExtractMode)
{
case NArchive::NExtract::NAskMode::kExtract:
if (_testMode)
askExtractMode = NArchive::NExtract::NAskMode::kTest;
else
_extractMode = true;
break;
};
return _extractCallback2->PrepareOperation(_filePath, _fi.IsDir,
askExtractMode, _isSplit ? &_position: 0);
COM_TRY_END
}
STDMETHODIMP CArchiveExtractCallback::SetOperationResult(Int32 operationResult)
{
COM_TRY_BEGIN
#ifndef _SFX
if (ExtractToStreamCallback)
return ExtractToStreamCallback->SetOperationResult7(operationResult, _encrypted);
#endif
#ifndef _SFX
if (_hashStreamWasUsed)
{
_hashStreamSpec->_hash->Final(_fi.IsDir, _isAltStream, _filePath);
_curSize = _hashStreamSpec->GetSize();
_curSizeDefined = true;
_hashStreamSpec->ReleaseStream();
_hashStreamWasUsed = false;
}
#endif
if (_outFileStream)
{
_outFileStreamSpec->SetTime(
(WriteCTime && _fi.CTimeDefined) ? &_fi.CTime : NULL,
(WriteATime && _fi.ATimeDefined) ? &_fi.ATime : NULL,
(WriteMTime && _fi.MTimeDefined) ? &_fi.MTime : (_arc->MTimeDefined ? &_arc->MTime : NULL));
_curSize = _outFileStreamSpec->ProcessedSize;
_curSizeDefined = true;
RINOK(_outFileStreamSpec->Close());
_outFileStream.Release();
}
#ifdef _USE_SECURITY_CODE
if (_ntOptions.NtSecurity.Val && _arc->GetRawProps)
{
const void *data;
UInt32 dataSize;
UInt32 propType;
_arc->GetRawProps->GetRawProp(_index, kpidNtSecure, &data, &dataSize, &propType);
if (dataSize != 0)
{
if (propType != NPropDataType::kRaw)
return E_FAIL;
if (CheckNtSecure((const Byte *)data, dataSize))
{
SECURITY_INFORMATION securInfo = DACL_SECURITY_INFORMATION | GROUP_SECURITY_INFORMATION | OWNER_SECURITY_INFORMATION;
if (_saclEnabled)
securInfo |= SACL_SECURITY_INFORMATION;
::SetFileSecurityW(fs2us(_diskFilePath), securInfo, (PSECURITY_DESCRIPTOR)(void *)data);
}
}
}
#endif
if (!_curSizeDefined)
GetUnpackSize();
if (_curSizeDefined)
{
if (_isAltStream)
AltStreams_UnpackSize += _curSize;
else
UnpackSize += _curSize;
}
if (_fi.IsDir)
NumFolders++;
else if (_isAltStream)
NumAltStreams++;
else
NumFiles++;
if (_extractMode && _fi.AttribDefined)
SetFileAttrib(_diskFilePath, _fi.Attrib);
RINOK(_extractCallback2->SetOperationResult(operationResult, _encrypted));
return S_OK;
COM_TRY_END
}
/*
STDMETHODIMP CArchiveExtractCallback::GetInStream(
const wchar_t *name, ISequentialInStream **inStream)
{
COM_TRY_BEGIN
CInFileStream *inFile = new CInFileStream;
CMyComPtr<ISequentialInStream> inStreamTemp = inFile;
if (!inFile->Open(_srcDirectoryPrefix + name))
return ::GetLastError();
*inStream = inStreamTemp.Detach();
return S_OK;
COM_TRY_END
}
*/
STDMETHODIMP CArchiveExtractCallback::CryptoGetTextPassword(BSTR *password)
{
COM_TRY_BEGIN
if (!_cryptoGetTextPassword)
{
RINOK(_extractCallback2.QueryInterface(IID_ICryptoGetTextPassword,
&_cryptoGetTextPassword));
}
return _cryptoGetTextPassword->CryptoGetTextPassword(password);
COM_TRY_END
}
struct CExtrRefSortPair
{
int Len;
int Index;
int Compare(const CExtrRefSortPair &a) const;
};
#define RINOZ(x) { int __tt = (x); if (__tt != 0) return __tt; }
int CExtrRefSortPair::Compare(const CExtrRefSortPair &a) const
{
RINOZ(-MyCompare(Len, a.Len));
return MyCompare(Index, a.Index);
}
static int GetNumSlashes(const FChar *s)
{
for (int numSlashes = 0;;)
{
FChar c = *s++;
if (c == 0)
return numSlashes;
if (
#ifdef _WIN32
c == FTEXT('\\') ||
#endif
c == FTEXT('/'))
numSlashes++;
}
}
HRESULT CArchiveExtractCallback::SetDirsTimes()
{
CRecordVector<CExtrRefSortPair> pairs;
pairs.ClearAndSetSize(_extractedFolderPaths.Size());
unsigned i;
for (i = 0; i < _extractedFolderPaths.Size(); i++)
{
CExtrRefSortPair &pair = pairs[i];
pair.Index = i;
pair.Len = GetNumSlashes(_extractedFolderPaths[i]);
}
pairs.Sort2();
for (i = 0; i < pairs.Size(); i++)
{
int pairIndex = pairs[i].Index;
int index = _extractedFolderIndices[pairIndex];
FILETIME CTime;
FILETIME ATime;
FILETIME MTime;
bool CTimeDefined;
bool ATimeDefined;
bool MTimeDefined;
RINOK(GetTime(index, kpidCTime, CTime, CTimeDefined));
RINOK(GetTime(index, kpidATime, ATime, ATimeDefined));
RINOK(GetTime(index, kpidMTime, MTime, MTimeDefined));
// printf("\n%S", _extractedFolderPaths[pairIndex]);
SetDirTime(_extractedFolderPaths[pairIndex],
(WriteCTime && CTimeDefined) ? &CTime : NULL,
(WriteATime && ATimeDefined) ? &ATime : NULL,
(WriteMTime && MTimeDefined) ? &MTime : (_arc->MTimeDefined ? &_arc->MTime : NULL));
}
return S_OK;
}