Simone
d074cc7c07
Plugin: ns7zip v2.0.0 Architectures: x86-ansi, x86-unicode, amd64-unicode License: LGPL-2.1-or-later
642 lines
14 KiB
C++
642 lines
14 KiB
C++
// ArchiveExtractCallback.h
|
|
|
|
#ifndef ZIP7_INC_ARCHIVE_EXTRACT_CALLBACK_H
|
|
#define ZIP7_INC_ARCHIVE_EXTRACT_CALLBACK_H
|
|
|
|
#include "../../../Common/MyCom.h"
|
|
#include "../../../Common/MyLinux.h"
|
|
#include "../../../Common/Wildcard.h"
|
|
|
|
#include "../../IPassword.h"
|
|
|
|
#include "../../Common/FileStreams.h"
|
|
#include "../../Common/ProgressUtils.h"
|
|
#include "../../Common/StreamObjects.h"
|
|
|
|
#include "../../Archive/IArchive.h"
|
|
|
|
#include "ExtractMode.h"
|
|
#include "IFileExtractCallback.h"
|
|
#include "OpenArchive.h"
|
|
|
|
#include "HashCalc.h"
|
|
|
|
#ifndef Z7_SFX
|
|
|
|
Z7_CLASS_IMP_NOQIB_1(
|
|
COutStreamWithHash
|
|
, ISequentialOutStream
|
|
)
|
|
bool _calculate;
|
|
CMyComPtr<ISequentialOutStream> _stream;
|
|
UInt64 _size;
|
|
public:
|
|
IHashCalc *_hash;
|
|
|
|
void SetStream(ISequentialOutStream *stream) { _stream = stream; }
|
|
void ReleaseStream() { _stream.Release(); }
|
|
void Init(bool calculate = true)
|
|
{
|
|
InitCRC();
|
|
_size = 0;
|
|
_calculate = calculate;
|
|
}
|
|
void EnableCalc(bool calculate) { _calculate = calculate; }
|
|
void InitCRC() { _hash->InitForNewFile(); }
|
|
UInt64 GetSize() const { return _size; }
|
|
};
|
|
|
|
#endif
|
|
|
|
struct CExtractNtOptions
|
|
{
|
|
CBoolPair NtSecurity;
|
|
CBoolPair SymLinks;
|
|
CBoolPair HardLinks;
|
|
CBoolPair AltStreams;
|
|
bool ReplaceColonForAltStream;
|
|
bool WriteToAltStreamIfColon;
|
|
|
|
bool ExtractOwner;
|
|
|
|
bool PreAllocateOutFile;
|
|
|
|
// used for hash arcs only, when we open external files
|
|
bool PreserveATime;
|
|
bool OpenShareForWrite;
|
|
|
|
unsigned SymLinks_DangerousLevel;
|
|
|
|
UInt64 MemLimit;
|
|
|
|
CExtractNtOptions():
|
|
ReplaceColonForAltStream(false),
|
|
WriteToAltStreamIfColon(false),
|
|
ExtractOwner(false),
|
|
PreserveATime(false),
|
|
OpenShareForWrite(false),
|
|
SymLinks_DangerousLevel(5),
|
|
MemLimit((UInt64)(Int64)-1)
|
|
{
|
|
SymLinks.Val = true;
|
|
HardLinks.Val = true;
|
|
AltStreams.Val = true;
|
|
|
|
PreAllocateOutFile =
|
|
#ifdef _WIN32
|
|
true;
|
|
#else
|
|
false;
|
|
#endif
|
|
}
|
|
};
|
|
|
|
|
|
#ifndef Z7_SFX
|
|
#ifndef UNDER_CE
|
|
#define SUPPORT_LINKS
|
|
#endif
|
|
#endif
|
|
|
|
|
|
#ifdef SUPPORT_LINKS
|
|
|
|
struct CHardLinkNode
|
|
{
|
|
UInt64 StreamId;
|
|
UInt64 INode;
|
|
|
|
int Compare(const CHardLinkNode &a) const;
|
|
};
|
|
|
|
class CHardLinks
|
|
{
|
|
public:
|
|
CRecordVector<CHardLinkNode> IDs;
|
|
CObjectVector<FString> Links;
|
|
|
|
void Clear()
|
|
{
|
|
IDs.Clear();
|
|
Links.Clear();
|
|
}
|
|
|
|
void PrepareLinks()
|
|
{
|
|
while (Links.Size() < IDs.Size())
|
|
Links.AddNew();
|
|
}
|
|
};
|
|
|
|
#endif
|
|
|
|
#ifdef SUPPORT_ALT_STREAMS
|
|
|
|
struct CIndexToPathPair
|
|
{
|
|
UInt32 Index;
|
|
FString Path;
|
|
|
|
CIndexToPathPair(UInt32 index): Index(index) {}
|
|
CIndexToPathPair(UInt32 index, const FString &path): Index(index), Path(path) {}
|
|
|
|
int Compare(const CIndexToPathPair &pair) const
|
|
{
|
|
return MyCompare(Index, pair.Index);
|
|
}
|
|
};
|
|
|
|
#endif
|
|
|
|
|
|
|
|
struct CFiTimesCAM
|
|
{
|
|
CFiTime CTime;
|
|
CFiTime ATime;
|
|
CFiTime MTime;
|
|
|
|
bool CTime_Defined;
|
|
bool ATime_Defined;
|
|
bool MTime_Defined;
|
|
|
|
bool IsSomeTimeDefined() const
|
|
{
|
|
return
|
|
CTime_Defined |
|
|
ATime_Defined |
|
|
MTime_Defined;
|
|
}
|
|
bool SetDirTime_to_FS(CFSTR path) const;
|
|
#ifdef SUPPORT_LINKS
|
|
bool SetLinkFileTime_to_FS(CFSTR path) const;
|
|
#endif
|
|
};
|
|
|
|
struct CDirPathTime: public CFiTimesCAM
|
|
{
|
|
FString Path;
|
|
|
|
bool SetDirTime_to_FS_2() const { return SetDirTime_to_FS(Path); }
|
|
};
|
|
|
|
|
|
#ifdef SUPPORT_LINKS
|
|
|
|
enum ELinkType
|
|
{
|
|
k_LinkType_HardLink,
|
|
k_LinkType_PureSymLink,
|
|
k_LinkType_Junction,
|
|
k_LinkType_WSL
|
|
// , k_LinkType_CopyLink;
|
|
};
|
|
|
|
|
|
struct CLinkInfo
|
|
{
|
|
ELinkType LinkType;
|
|
bool isRelative;
|
|
// if (isRelative == false), then (LinkPath) is relative to root folder of archive
|
|
// if (isRelative == true ), then (LinkPath) is relative to current item
|
|
bool isWindowsPath;
|
|
UString LinkPath;
|
|
|
|
bool Is_HardLink() const { return LinkType == k_LinkType_HardLink; }
|
|
bool Is_AnySymLink() const { return LinkType != k_LinkType_HardLink; }
|
|
|
|
bool Is_WSL() const { return LinkType == k_LinkType_WSL; }
|
|
|
|
CLinkInfo():
|
|
LinkType(k_LinkType_PureSymLink),
|
|
isRelative(false),
|
|
isWindowsPath(false)
|
|
{}
|
|
|
|
void Clear()
|
|
{
|
|
LinkType = k_LinkType_PureSymLink;
|
|
isRelative = false;
|
|
isWindowsPath = false;
|
|
LinkPath.Empty();
|
|
}
|
|
|
|
bool Parse_from_WindowsReparseData(const Byte *data, size_t dataSize);
|
|
bool Parse_from_LinuxData(const Byte *data, size_t dataSize);
|
|
void Normalize_to_RelativeSafe(UStringVector &removePathParts);
|
|
private:
|
|
void Remove_AbsPathPrefixes();
|
|
};
|
|
|
|
#endif // SUPPORT_LINKS
|
|
|
|
|
|
|
|
struct CProcessedFileInfo
|
|
{
|
|
CArcTime CTime;
|
|
CArcTime ATime;
|
|
CArcTime MTime;
|
|
UInt32 Attrib;
|
|
bool Attrib_Defined;
|
|
|
|
#ifndef _WIN32
|
|
|
|
struct COwnerInfo
|
|
{
|
|
bool Id_Defined;
|
|
UInt32 Id;
|
|
AString Name;
|
|
|
|
void Clear()
|
|
{
|
|
Id_Defined = false;
|
|
Id = 0;
|
|
Name.Empty();
|
|
}
|
|
};
|
|
|
|
COwnerInfo Owner;
|
|
COwnerInfo Group;
|
|
#endif
|
|
|
|
void Clear()
|
|
{
|
|
#ifndef _WIN32
|
|
Attrib_Defined = false;
|
|
Owner.Clear();
|
|
#endif
|
|
}
|
|
|
|
bool IsReparse() const
|
|
{
|
|
return (Attrib_Defined && (Attrib & FILE_ATTRIBUTE_REPARSE_POINT) != 0);
|
|
}
|
|
|
|
bool IsLinuxSymLink() const
|
|
{
|
|
return (Attrib_Defined && MY_LIN_S_ISLNK(Attrib >> 16));
|
|
}
|
|
|
|
void SetFromPosixAttrib(UInt32 a)
|
|
{
|
|
// here we set only part of combined attribute required by SetFileAttrib() call
|
|
#ifdef _WIN32
|
|
// Windows sets FILE_ATTRIBUTE_NORMAL, if we try to set 0 as attribute.
|
|
Attrib = MY_LIN_S_ISDIR(a) ?
|
|
FILE_ATTRIBUTE_DIRECTORY :
|
|
FILE_ATTRIBUTE_ARCHIVE;
|
|
if ((a & 0222) == 0) // (& S_IWUSR) in p7zip
|
|
Attrib |= FILE_ATTRIBUTE_READONLY;
|
|
// 22.00 : we need type bits for (MY_LIN_S_IFLNK) for IsLinuxSymLink()
|
|
a &= MY_LIN_S_IFMT;
|
|
if (a == MY_LIN_S_IFLNK)
|
|
Attrib |= (a << 16);
|
|
#else
|
|
Attrib = (a << 16) | FILE_ATTRIBUTE_UNIX_EXTENSION;
|
|
#endif
|
|
Attrib_Defined = true;
|
|
}
|
|
};
|
|
|
|
|
|
#ifdef SUPPORT_LINKS
|
|
|
|
struct CPostLink
|
|
{
|
|
UInt32 Index_in_Arc;
|
|
bool item_IsDir; // _item.IsDir
|
|
UString item_Path; // _item.Path;
|
|
UStringVector item_PathParts; // _item.PathParts;
|
|
CProcessedFileInfo item_FileInfo; // _fi
|
|
FString fullProcessedPath_from; // full file path in FS
|
|
CLinkInfo LinkInfo;
|
|
};
|
|
|
|
/*
|
|
struct CPostLinks
|
|
{
|
|
void Clear()
|
|
{
|
|
Links.Clear();
|
|
}
|
|
};
|
|
*/
|
|
|
|
#endif // SUPPORT_LINKS
|
|
|
|
|
|
|
|
class CArchiveExtractCallback Z7_final:
|
|
public IArchiveExtractCallback,
|
|
public IArchiveExtractCallbackMessage2,
|
|
public ICryptoGetTextPassword,
|
|
public ICompressProgressInfo,
|
|
#ifndef Z7_SFX
|
|
public IArchiveUpdateCallbackFile,
|
|
public IArchiveGetDiskProperty,
|
|
public IArchiveRequestMemoryUseCallback,
|
|
#endif
|
|
public CMyUnknownImp
|
|
{
|
|
/* IArchiveExtractCallback, */
|
|
Z7_COM_QI_BEGIN2(IArchiveExtractCallbackMessage2)
|
|
Z7_COM_QI_ENTRY(ICryptoGetTextPassword)
|
|
Z7_COM_QI_ENTRY(ICompressProgressInfo)
|
|
#ifndef Z7_SFX
|
|
Z7_COM_QI_ENTRY(IArchiveUpdateCallbackFile)
|
|
Z7_COM_QI_ENTRY(IArchiveGetDiskProperty)
|
|
Z7_COM_QI_ENTRY(IArchiveRequestMemoryUseCallback)
|
|
#endif
|
|
Z7_COM_QI_END
|
|
Z7_COM_ADDREF_RELEASE
|
|
|
|
Z7_IFACE_COM7_IMP(IProgress)
|
|
Z7_IFACE_COM7_IMP(IArchiveExtractCallback)
|
|
Z7_IFACE_COM7_IMP(IArchiveExtractCallbackMessage2)
|
|
Z7_IFACE_COM7_IMP(ICryptoGetTextPassword)
|
|
Z7_IFACE_COM7_IMP(ICompressProgressInfo)
|
|
#ifndef Z7_SFX
|
|
Z7_IFACE_COM7_IMP(IArchiveUpdateCallbackFile)
|
|
Z7_IFACE_COM7_IMP(IArchiveGetDiskProperty)
|
|
Z7_IFACE_COM7_IMP(IArchiveRequestMemoryUseCallback)
|
|
#endif
|
|
|
|
// bool Write_CTime;
|
|
// bool Write_ATime;
|
|
// bool Write_MTime;
|
|
bool _stdOutMode;
|
|
bool _testMode;
|
|
bool _removePartsForAltStreams;
|
|
public:
|
|
bool Is_elimPrefix_Mode;
|
|
private:
|
|
|
|
const CArc *_arc;
|
|
public:
|
|
CExtractNtOptions _ntOptions;
|
|
private:
|
|
bool _encrypted;
|
|
bool _isSplit;
|
|
bool _curSize_Defined;
|
|
bool _fileLength_WasSet;
|
|
|
|
bool _isRenamed;
|
|
bool _extractMode;
|
|
bool _is_SymLink_in_Data_Linux; // false = WIN32, true = LINUX.
|
|
// _is_SymLink_in_Data_Linux is detected from Windows/Linux part of attributes of file.
|
|
bool _needSetAttrib;
|
|
bool _isSymLinkCreated;
|
|
bool _itemFailure;
|
|
bool _some_pathParts_wereRemoved;
|
|
|
|
bool _multiArchives;
|
|
bool _keepAndReplaceEmptyDirPrefixes; // replace them to "_";
|
|
#if defined(_WIN32) && !defined(UNDER_CE) && !defined(Z7_SFX)
|
|
bool _saclEnabled;
|
|
#endif
|
|
|
|
NExtract::NPathMode::EEnum _pathMode;
|
|
NExtract::NOverwriteMode::EEnum _overwriteMode;
|
|
|
|
CMyComPtr<IFolderArchiveExtractCallback> _extractCallback2;
|
|
const NWildcard::CCensorNode *_wildcardCensor; // we need wildcard for single pass mode (stdin)
|
|
// CMyComPtr<ICompressProgressInfo> _compressProgress;
|
|
// CMyComPtr<IArchiveExtractCallbackMessage2> _callbackMessage;
|
|
CMyComPtr<IFolderArchiveExtractCallback2> _folderArchiveExtractCallback2;
|
|
CMyComPtr<ICryptoGetTextPassword> _cryptoGetTextPassword;
|
|
|
|
FString _dirPathPrefix;
|
|
public:
|
|
FString _dirPathPrefix_Full;
|
|
private:
|
|
|
|
#ifndef Z7_SFX
|
|
|
|
CMyComPtr<IFolderExtractToStreamCallback> ExtractToStreamCallback;
|
|
CMyComPtr<IArchiveRequestMemoryUseCallback> _requestMemoryUseCallback;
|
|
|
|
#endif
|
|
|
|
CReadArcItem _item;
|
|
FString _diskFilePath;
|
|
|
|
CProcessedFileInfo _fi;
|
|
|
|
UInt64 _position;
|
|
UInt64 _curSize;
|
|
UInt64 _fileLength_that_WasSet;
|
|
UInt32 _index;
|
|
|
|
// #ifdef SUPPORT_ALT_STREAMS
|
|
#if defined(_WIN32) && !defined(UNDER_CE)
|
|
DWORD _altStream_NeedRestore_AttribVal;
|
|
FString _altStream_NeedRestore_Attrib_for_parentFsPath;
|
|
#endif
|
|
// #endif
|
|
|
|
COutFileStream *_outFileStreamSpec;
|
|
CMyComPtr<ISequentialOutStream> _outFileStream;
|
|
|
|
CByteBuffer _outMemBuf;
|
|
CBufPtrSeqOutStream *_bufPtrSeqOutStream_Spec;
|
|
CMyComPtr<ISequentialOutStream> _bufPtrSeqOutStream;
|
|
|
|
#ifndef Z7_SFX
|
|
COutStreamWithHash *_hashStreamSpec;
|
|
CMyComPtr<ISequentialOutStream> _hashStream;
|
|
bool _hashStreamWasUsed;
|
|
|
|
bool _use_baseParentFolder_mode;
|
|
UInt32 _baseParentFolder;
|
|
#endif
|
|
|
|
UStringVector _removePathParts;
|
|
|
|
UInt64 _packTotal;
|
|
UInt64 _progressTotal;
|
|
// bool _progressTotal_Defined;
|
|
|
|
CObjectVector<CDirPathTime> _extractedFolders;
|
|
|
|
#ifndef _WIN32
|
|
// CObjectVector<NWindows::NFile::NDir::CDelayedSymLink> _delayedSymLinks;
|
|
#endif
|
|
|
|
void CreateComplexDirectory(
|
|
const UStringVector &dirPathParts, bool isFinal, FString &fullPath);
|
|
HRESULT GetTime(UInt32 index, PROPID propID, CArcTime &ft);
|
|
HRESULT GetUnpackSize();
|
|
|
|
FString Hash_GetFullFilePath();
|
|
|
|
void SetAttrib() const;
|
|
|
|
public:
|
|
HRESULT SendMessageError(const char *message, const FString &path) const;
|
|
HRESULT SendMessageError_with_Error(HRESULT errorCode, const char *message, const FString &path) const;
|
|
HRESULT SendMessageError_with_LastError(const char *message, const FString &path) const;
|
|
HRESULT SendMessageError2(HRESULT errorCode, const char *message, const FString &path1, const FString &path2) const;
|
|
HRESULT SendMessageError2_with_LastError(const char *message, const FString &path1, const FString &path2) const;
|
|
|
|
#if defined(_WIN32) && !defined(UNDER_CE) && !defined(Z7_SFX)
|
|
NExtract::NZoneIdMode::EEnum ZoneMode;
|
|
CByteBuffer ZoneBuf;
|
|
#endif
|
|
|
|
CMyComPtr2_Create<ICompressProgressInfo, CLocalProgress> LocalProgressSpec;
|
|
|
|
UInt64 NumFolders;
|
|
UInt64 NumFiles;
|
|
UInt64 NumAltStreams;
|
|
UInt64 UnpackSize;
|
|
UInt64 AltStreams_UnpackSize;
|
|
|
|
FString DirPathPrefix_for_HashFiles;
|
|
|
|
CArchiveExtractCallback();
|
|
|
|
void InitForMulti(bool multiArchives,
|
|
NExtract::NPathMode::EEnum pathMode,
|
|
NExtract::NOverwriteMode::EEnum overwriteMode,
|
|
NExtract::NZoneIdMode::EEnum zoneMode,
|
|
bool keepAndReplaceEmptyDirPrefixes)
|
|
{
|
|
_multiArchives = multiArchives;
|
|
_pathMode = pathMode;
|
|
_overwriteMode = overwriteMode;
|
|
#if defined(_WIN32) && !defined(UNDER_CE) && !defined(Z7_SFX)
|
|
ZoneMode = zoneMode;
|
|
#else
|
|
UNUSED_VAR(zoneMode)
|
|
#endif
|
|
_keepAndReplaceEmptyDirPrefixes = keepAndReplaceEmptyDirPrefixes;
|
|
NumFolders = NumFiles = NumAltStreams = UnpackSize = AltStreams_UnpackSize = 0;
|
|
}
|
|
|
|
#ifndef Z7_SFX
|
|
|
|
void SetHashMethods(IHashCalc *hash)
|
|
{
|
|
if (!hash)
|
|
return;
|
|
_hashStreamSpec = new COutStreamWithHash;
|
|
_hashStream = _hashStreamSpec;
|
|
_hashStreamSpec->_hash = hash;
|
|
}
|
|
|
|
#endif
|
|
|
|
void InitBeforeNewArchive();
|
|
|
|
void Init(
|
|
const CExtractNtOptions &ntOptions,
|
|
const NWildcard::CCensorNode *wildcardCensor,
|
|
const CArc *arc,
|
|
IFolderArchiveExtractCallback *extractCallback2,
|
|
bool stdOutMode, bool testMode,
|
|
const FString &directoryPath,
|
|
const UStringVector &removePathParts, bool removePartsForAltStreams,
|
|
UInt64 packSize);
|
|
|
|
|
|
#ifdef SUPPORT_LINKS
|
|
|
|
private:
|
|
CHardLinks _hardLinks;
|
|
CObjectVector<CPostLink> _postLinks;
|
|
CLinkInfo _link;
|
|
// const void *NtReparse_Data;
|
|
// UInt32 NtReparse_Size;
|
|
|
|
// FString _copyFile_Path;
|
|
// HRESULT MyCopyFile(ISequentialOutStream *outStream);
|
|
HRESULT ReadLink();
|
|
HRESULT SetLink(
|
|
const FString &fullProcessedPath_from,
|
|
const CLinkInfo &linkInfo,
|
|
bool &linkWasSet);
|
|
HRESULT SetPostLinks() const;
|
|
|
|
public:
|
|
HRESULT CreateHardLink2(const FString &newFilePath,
|
|
const FString &existFilePath, bool &link_was_Created) const;
|
|
HRESULT DeleteLinkFileAlways_or_RemoveEmptyDir(const FString &path, bool checkThatFileIsEmpty) const;
|
|
HRESULT PrepareHardLinks(const CRecordVector<UInt32> *realIndices); // NULL means all items
|
|
#endif
|
|
|
|
private:
|
|
|
|
#ifdef SUPPORT_ALT_STREAMS
|
|
CObjectVector<CIndexToPathPair> _renamedFiles;
|
|
#endif
|
|
|
|
// call it after Init()
|
|
|
|
public:
|
|
#ifndef Z7_SFX
|
|
void SetBaseParentFolderIndex(UInt32 indexInArc)
|
|
{
|
|
_baseParentFolder = indexInArc;
|
|
_use_baseParentFolder_mode = true;
|
|
}
|
|
#endif
|
|
|
|
HRESULT CloseArc();
|
|
|
|
private:
|
|
void ClearExtractedDirsInfo()
|
|
{
|
|
_extractedFolders.Clear();
|
|
#ifndef _WIN32
|
|
// _delayedSymLinks.Clear();
|
|
#endif
|
|
}
|
|
|
|
HRESULT Read_fi_Props();
|
|
void CorrectPathParts();
|
|
void CreateFolders();
|
|
|
|
HRESULT CheckExistFile(FString &fullProcessedPath, bool &needExit);
|
|
HRESULT GetExtractStream(CMyComPtr<ISequentialOutStream> &outStreamLoc, bool &needExit);
|
|
HRESULT GetItem(UInt32 index);
|
|
|
|
HRESULT CloseFile();
|
|
HRESULT CloseReparseAndFile();
|
|
HRESULT SetDirsTimes();
|
|
HRESULT SetSecurityInfo(UInt32 indexInArc, const FString &path) const;
|
|
};
|
|
|
|
|
|
struct CArchiveExtractCallback_Closer
|
|
{
|
|
CArchiveExtractCallback *_ref;
|
|
|
|
CArchiveExtractCallback_Closer(CArchiveExtractCallback *ref): _ref(ref) {}
|
|
|
|
HRESULT Close()
|
|
{
|
|
HRESULT res = S_OK;
|
|
if (_ref)
|
|
{
|
|
res = _ref->CloseArc();
|
|
_ref = NULL;
|
|
}
|
|
return res;
|
|
}
|
|
|
|
~CArchiveExtractCallback_Closer()
|
|
{
|
|
Close();
|
|
}
|
|
};
|
|
|
|
|
|
bool CensorNode_CheckPath(const NWildcard::CCensorNode &node, const CReadArcItem &item);
|
|
|
|
bool Is_ZoneId_StreamName(const wchar_t *s);
|
|
void ReadZoneFile_Of_BaseFile(CFSTR fileName, CByteBuffer &buf);
|
|
bool WriteZoneFile_To_BaseFile(CFSTR fileName, const CByteBuffer &buf);
|
|
|
|
#endif
|