perl/p7zip-rar
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
master
p7zip-rar/CPP/7zip/Archive/VmdkHandler.cpp

1519 lines
34 KiB
C++
Raw Permalink Normal View History

Imported Upstream version 16.02
2017-10-11 12:40:22 +02:00
// VmdkHandler.cpp
#include "StdAfx.h"
// #include <stdio.h>
#include "../../../C/CpuArch.h"
#include "../../Common/ComTry.h"
#include "../../Common/IntToString.h"
#include "../../Common/StringConvert.h"
#include "../../Common/StringToInt.h"
#include "../../Common/UTFConvert.h"
#include "../../Windows/PropVariant.h"
#include "../Common/RegisterArc.h"
#include "../Common/StreamObjects.h"
#include "../Common/StreamUtils.h"
#include "../Compress/ZlibDecoder.h"
#include "HandlerCont.h"
using namespace NWindows;
namespace NArchive {
namespace NVmdk {
#define Get16(p) GetUi16(p)
#define Get32(p) GetUi32(p)
#define Get64(p) GetUi64(p)
#define LE_16(offs, dest) dest = Get16(p + (offs));
#define LE_32(offs, dest) dest = Get32(p + (offs));
#define LE_64(offs, dest) dest = Get64(p + (offs));
#define SIGNATURE { 'K', 'D', 'M', 'V' }
static const Byte k_Signature[] = SIGNATURE;
static const UInt32 k_Flags_NL = (UInt32)1 << 0;
static const UInt32 k_Flags_RGD = (UInt32)1 << 1;
static const UInt32 k_Flags_ZeroGrain = (UInt32)1 << 2;
static const UInt32 k_Flags_Compressed = (UInt32)1 << 16;
static const UInt32 k_Flags_Marker = (UInt32)1 << 17;
static const unsigned k_NumMidBits = 9; // num bits for index in Grain Table
struct CHeader
{
UInt32 flags;
UInt32 version;
UInt64 capacity;
UInt64 grainSize;
UInt64 descriptorOffset;
UInt64 descriptorSize;
UInt32 numGTEsPerGT;
UInt16 algo;
// Byte uncleanShutdown;
// UInt64 rgdOffset;
UInt64 gdOffset;
UInt64 overHead;
bool Is_NL() const { return (flags & k_Flags_NL) != 0; };
bool Is_ZeroGrain() const { return (flags & k_Flags_ZeroGrain) != 0; };
bool Is_Compressed() const { return (flags & k_Flags_Compressed) != 0; };
bool Is_Marker() const { return (flags & k_Flags_Marker) != 0; };
bool Parse(const Byte *p);
bool IsSameImageFor(const CHeader &h) const
{
return flags == h.flags
&& version == h.version
&& capacity == h.capacity
&& grainSize == h.grainSize
&& algo == h.algo;
}
};
bool CHeader::Parse(const Byte *p)
{
if (memcmp(p, k_Signature, sizeof(k_Signature)) != 0)
return false;
LE_32 (0x04, version);
LE_32 (0x08, flags);
LE_64 (0x0C, capacity);
LE_64 (0x14, grainSize);
LE_64 (0x1C, descriptorOffset);
LE_64 (0x24, descriptorSize);
LE_32 (0x2C, numGTEsPerGT);
// LE_64 (0x30, rgdOffset);
LE_64 (0x38, gdOffset);
LE_64 (0x40, overHead);
// uncleanShutdown = buf[0x48];
LE_16(0x4D, algo);
if (Is_NL() && Get32(p + 0x49) != 0x0A0D200A) // do we need Is_NL() check here?
return false;
return (numGTEsPerGT == (1 << k_NumMidBits)) && (version <= 3);
}
enum
{
k_Marker_END_OF_STREAM = 0,
k_Marker_GRAIN_TABLE = 1,
k_Marker_GRAIN_DIR = 2,
k_Marker_FOOTER = 3
};
struct CMarker
{
UInt64 NumSectors;
UInt32 SpecSize; // = 0 for metadata sectors
UInt32 Type;
void Parse(const Byte *p)
{
LE_64 (0, NumSectors);
LE_32 (8, SpecSize);
LE_32 (12, Type);
}
};
static bool Str_to_ValName(const AString &s, AString &name, AString &val)
{
name.Empty();
val.Empty();
int qu = s.Find('"');
int eq = s.Find('=');
if (eq < 0 || (qu >= 0 && eq > qu))
return false;
name = s.Left(eq);
name.Trim();
val = s.Ptr(eq + 1);
val.Trim();
return true;
}
static inline bool IsSpaceChar(char c)
{
return (c == ' ' || c == '\t');
}
static const char *SkipSpaces(const char *s)
{
for (;; s++)
{
char c = *s;
if (c == 0 || !IsSpaceChar(c))
return s;
}
}
#define SKIP_SPACES(s) s = SkipSpaces(s);
static const char *GetNextWord(const char *s, AString &dest)
{
dest.Empty();
SKIP_SPACES(s);
const char *start = s;
for (;; s++)
{
char c = *s;
if (c == 0 || IsSpaceChar(c))
{
dest.SetFrom(start, (unsigned)(s - start));
return s;
}
}
}
static const char *GetNextNumber(const char *s, UInt64 &val)
{
SKIP_SPACES(s);
if (*s == 0)
return s;
const char *end;
val = ConvertStringToUInt64(s, &end);
char c = *end;
if (c != 0 && !IsSpaceChar(c))
return NULL;
return end;
}
struct CExtentInfo
{
AString Access; // RW, RDONLY, or NOACCESS
UInt64 NumSectors; // 512 bytes sectors
AString Type; // FLAT, SPARSE, ZERO, VMFS, VMFSSPARSE, VMFSRDM, VMFSRAW
AString FileName;
UInt64 StartSector; // used for FLAT
// for VMWare Player 9:
// PartitionUUID
// DeviceIdentifier
bool IsType_ZERO() const { return Type == "ZERO"; }
// bool IsType_FLAT() const { return Type == "FLAT"; }
bool IsType_Flat() const { return Type == "FLAT" || Type == "VMFS" || Type == "VMFSRAW"; }
bool Parse(const char *s);
};
bool CExtentInfo::Parse(const char *s)
{
NumSectors = 0;
StartSector = 0;
Access.Empty();
Type.Empty();
FileName.Empty();
s = GetNextWord(s, Access);
s = GetNextNumber(s, NumSectors);
if (!s)
return false;
s = GetNextWord(s, Type);
if (Type.IsEmpty())
return false;
SKIP_SPACES(s);
if (IsType_ZERO())
return (*s == 0);
if (*s != '\"')
return false;
s++;
{
const char *s2 = strchr(s, '\"');
if (!s2)
return false;
FileName.SetFrom(s, (unsigned)(s2 - s));
s = s2 + 1;
}
SKIP_SPACES(s);
if (*s == 0)
return true;
s = GetNextNumber(s, StartSector);
if (!s)
return false;
return true;
// SKIP_SPACES(s);
// return (*s == 0);
}
struct CDescriptor
{
AString CID;
AString parentCID;
AString createType;
// AString encoding; // UTF-8, windows-1252 - default is UTF-8
CObjectVector<CExtentInfo> Extents;
static void GetUnicodeName(const AString &s, UString &res)
{
if (!ConvertUTF8ToUnicode(s, res))
MultiByteToUnicodeString2(res, s);
}
void Clear()
{
CID.Empty();
parentCID.Empty();
createType.Empty();
Extents.Clear();
}
bool IsThere_Parent() const
{
return !parentCID.IsEmpty() && !parentCID.IsEqualTo_Ascii_NoCase("ffffffff");
}
bool Parse(const Byte *p, size_t size);
};
bool CDescriptor::Parse(const Byte *p, size_t size)
{
Clear();
AString s;
AString name;
AString val;
for (size_t i = 0;; i++)
{
const char c = p[i];
if (i == size || c == 0 || c == 0xA || c == 0xD)
{
if (!s.IsEmpty() && s[0] != '#')
{
if (Str_to_ValName(s, name, val))
{
if (name.IsEqualTo_Ascii_NoCase("CID"))
CID = val;
else if (name.IsEqualTo_Ascii_NoCase("parentCID"))
parentCID = val;
else if (name.IsEqualTo_Ascii_NoCase("createType"))
createType = val;
}
else
{
CExtentInfo ei;
if (!ei.Parse(s))
return false;
Extents.Add(ei);
}
}
s.Empty();
if (c == 0 || i >= size)
break;
}
else
s += (char)c;
}
return true;
}
struct CExtent
{
bool IsOK;
bool IsArc;
bool NeedDeflate;
bool Unsupported;
bool IsZero;
bool IsFlat;
bool DescriptorOK;
bool HeadersError;
unsigned ClusterBits;
UInt32 ZeroSector;
CObjectVector<CByteBuffer> Tables;
CMyComPtr<IInStream> Stream;
UInt64 PosInArc;
UInt64 PhySize;
UInt64 VirtSize; // from vmdk header of volume
UInt64 StartOffset; // virtual offset of this extent
UInt64 NumBytes; // from main descriptor, if multi-vol
UInt64 FlatOffset; // in Stream
CByteBuffer DescriptorBuf;
CDescriptor Descriptor;
CHeader h;
UInt64 GetEndOffset() const { return StartOffset + NumBytes; }
bool IsVmdk() const { return !IsZero && !IsFlat; };
// if (IsOK && IsVmdk()), then VMDK header of this extent was read
CExtent():
IsOK(false),
IsArc(false),
NeedDeflate(false),
Unsupported(false),
IsZero(false),
IsFlat(false),
DescriptorOK(false),
HeadersError(false),
ClusterBits(0),
ZeroSector(0),
PosInArc(0),
PhySize(0),
VirtSize(0),
StartOffset(0),
NumBytes(0),
FlatOffset(0)
{}
HRESULT ReadForHeader(IInStream *stream, UInt64 sector, void *data, size_t numSectors);
HRESULT Open3(IInStream *stream, IArchiveOpenCallback *openCallback,
unsigned numVols, unsigned volIndex, UInt64 &complexity);
HRESULT Seek(UInt64 offset)
{
PosInArc = offset;
return Stream->Seek(offset, STREAM_SEEK_SET, NULL);
}
HRESULT InitAndSeek()
{
if (Stream)
return Seek(0);
return S_OK;
}
HRESULT Read(void *data, size_t *size)
{
HRESULT res = ReadStream(Stream, data, size);
PosInArc += *size;
return res;
}
};
class CHandler: public CHandlerImg
{
bool _isArc;
bool _unsupported;
bool _unsupportedSome;
bool _headerError;
bool _missingVol;
bool _isMultiVol;
bool _needDeflate;
UInt64 _cacheCluster;
unsigned _cacheExtent;
CByteBuffer _cache;
CByteBuffer _cacheCompressed;
unsigned _clusterBitsMax;
UInt64 _phySize;
CObjectVector<CExtent> _extents;
CBufInStream *_bufInStreamSpec;
CMyComPtr<ISequentialInStream> _bufInStream;
CBufPtrSeqOutStream *_bufOutStreamSpec;
CMyComPtr<ISequentialOutStream> _bufOutStream;
NCompress::NZlib::CDecoder *_zlibDecoderSpec;
CMyComPtr<ICompressCoder> _zlibDecoder;
CByteBuffer _descriptorBuf;
CDescriptor _descriptor;
UString _missingVolName;
void InitAndSeekMain()
{
_virtPos = 0;
}
virtual HRESULT Open2(IInStream *stream, IArchiveOpenCallback *openCallback);
virtual void CloseAtError();
public:
INTERFACE_IInArchive_Img(;)
STDMETHOD(GetStream)(UInt32 index, ISequentialInStream **stream);
STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
};
STDMETHODIMP CHandler::Read(void *data, UInt32 size, UInt32 *processedSize)
{
if (processedSize)
*processedSize = 0;
if (_virtPos >= _size)
return S_OK;
{
UInt64 rem = _size - _virtPos;
if (size > rem)
size = (UInt32)rem;
if (size == 0)
return S_OK;
}
unsigned extentIndex;
{
unsigned left = 0, right = _extents.Size();
for (;;)
{
unsigned mid = (left + right) / 2;
if (mid == left)
break;
if (_virtPos < _extents[mid].StartOffset)
right = mid;
else
left = mid;
}
extentIndex = left;
}
CExtent &extent = _extents[extentIndex];
{
const UInt64 vir = _virtPos - extent.StartOffset;
if (vir >= extent.NumBytes)
{
return E_FAIL;
/*
if (vir > extent.NumBytes)
_stream_dataError = true;
memset(data, 0, size);
_virtPos += size;
if (processedSize)
*processedSize = size;
return S_OK;
*/
}
{
const UInt64 rem = extent.NumBytes - vir;
if (size > rem)
size = (UInt32)rem;
}
if (vir >= extent.VirtSize)
{
// if vmdk's VirtSize is smaller than VirtSize from main multi-volume descriptor
_stream_dataError = true;
return S_FALSE;
/*
memset(data, 0, size);
_virtPos += size;
if (processedSize)
*processedSize = size;
return S_OK;
*/
}
{
const UInt64 rem = extent.VirtSize - vir;
if (size > rem)
size = (UInt32)rem;
}
if (extent.IsZero || !extent.IsOK || !extent.Stream || extent.Unsupported)
{
if (extent.Unsupported)
{
_stream_unsupportedMethod = true;
return S_FALSE;
}
if (!extent.IsOK || !extent.Stream)
{
_stream_unavailData = true;
return S_FALSE;
}
memset(data, 0, size);
_virtPos += size;
if (processedSize)
*processedSize = size;
return S_OK;
}
if (extent.IsFlat)
{
UInt64 offset = extent.FlatOffset + vir;
if (offset != extent.PosInArc)
{
RINOK(extent.Seek(offset));
}
UInt32 size2 = 0;
HRESULT res = extent.Stream->Read(data, size, &size2);
if (res == S_OK && size2 == 0)
{
_stream_unavailData = true;
/*
memset(data, 0, size);
_virtPos += size;
if (processedSize)
*processedSize = size;
return S_OK;
*/
}
// _stream_PackSize += size2;
extent.PosInArc += size2;
_virtPos += size2;
if (processedSize)
*processedSize = size2;
return res;
}
}
for (;;)
{
const UInt64 vir = _virtPos - extent.StartOffset;
const unsigned clusterBits = extent.ClusterBits;
const UInt64 cluster = vir >> clusterBits;
const size_t clusterSize = (size_t)1 << clusterBits;
const size_t lowBits = (size_t)vir & (clusterSize - 1);
{
size_t rem = clusterSize - lowBits;
if (size > rem)
size = (UInt32)rem;
}
if (extentIndex == _cacheExtent && cluster == _cacheCluster)
{
memcpy(data, _cache + lowBits, size);
_virtPos += size;
if (processedSize)
*processedSize = size;
return S_OK;
}
const UInt64 high = cluster >> k_NumMidBits;
if (high < extent.Tables.Size())
{
const CByteBuffer &table = extent.Tables[(unsigned)high];
if (table.Size() != 0)
{
const size_t midBits = (size_t)cluster & ((1 << k_NumMidBits) - 1);
const Byte *p = (const Byte *)table + (midBits << 2);
const UInt32 v = Get32(p);
if (v != 0 && v != extent.ZeroSector)
{
UInt64 offset = (UInt64)v << 9;
if (extent.NeedDeflate)
{
if (offset != extent.PosInArc)
{
// printf("\n%12x %12x\n", (unsigned)offset, (unsigned)(offset - extent.PosInArc));
RINOK(extent.Seek(offset));
}
const size_t kStartSize = 1 << 9;
{
size_t curSize = kStartSize;
RINOK(extent.Read(_cacheCompressed, &curSize));
// _stream_PackSize += curSize;
if (curSize != kStartSize)
return S_FALSE;
}
if (Get64(_cacheCompressed) != (cluster << (clusterBits - 9)))
return S_FALSE;
UInt32 dataSize = Get32(_cacheCompressed + 8);
if (dataSize > ((UInt32)1 << 31))
return S_FALSE;
size_t dataSize2 = (size_t)dataSize + 12;
if (dataSize2 > kStartSize)
{
dataSize2 = (dataSize2 + 511) & ~(size_t)511;
if (dataSize2 > _cacheCompressed.Size())
return S_FALSE;
size_t curSize = dataSize2 - kStartSize;
const size_t curSize2 = curSize;
RINOK(extent.Read(_cacheCompressed + kStartSize, &curSize));
// _stream_PackSize += curSize;
if (curSize != curSize2)
return S_FALSE;
}
_bufInStreamSpec->Init(_cacheCompressed + 12, dataSize);
_cacheCluster = (UInt64)(Int64)-1;
_cacheExtent = (unsigned)(int)-1;
if (_cache.Size() < clusterSize)
return E_FAIL;
_bufOutStreamSpec->Init(_cache, clusterSize);
// Do we need to use smaller block than clusterSize for last cluster?
UInt64 blockSize64 = clusterSize;
HRESULT res = _zlibDecoderSpec->Code(_bufInStream, _bufOutStream, NULL, &blockSize64, NULL);
/*
if (_bufOutStreamSpec->GetPos() != clusterSize)
{
_stream_dataError = true;
memset(_cache + _bufOutStreamSpec->GetPos(), 0, clusterSize - _bufOutStreamSpec->GetPos());
}
*/
if (_bufOutStreamSpec->GetPos() != clusterSize
|| _zlibDecoderSpec->GetInputProcessedSize() != dataSize)
{
_stream_dataError = true;
if (res == S_OK)
res = S_FALSE;
}
RINOK(res);
_cacheCluster = cluster;
_cacheExtent = extentIndex;
continue;
/*
memcpy(data, _cache + lowBits, size);
_virtPos += size;
if (processedSize)
*processedSize = size;
return S_OK;
*/
}
{
offset += lowBits;
if (offset != extent.PosInArc)
{
// printf("\n%12x %12x\n", (unsigned)offset, (unsigned)(offset - extent.PosInArc));
RINOK(extent.Seek(offset));
}
UInt32 size2 = 0;
HRESULT res = extent.Stream->Read(data, size, &size2);
if (res == S_OK && size2 == 0)
{
_stream_unavailData = true;
/*
memset(data, 0, size);
_virtPos += size;
if (processedSize)
*processedSize = size;
return S_OK;
*/
}
extent.PosInArc += size2;
// _stream_PackSize += size2;
_virtPos += size2;
if (processedSize)
*processedSize = size2;
return res;
}
}
}
}
memset(data, 0, size);
_virtPos += size;
if (processedSize)
*processedSize = size;
return S_OK;
}
}
static const Byte kProps[] =
{
kpidSize,
kpidPackSize
};
static const Byte kArcProps[] =
{
kpidNumVolumes,
kpidMethod,
kpidClusterSize,
kpidHeadersSize,
kpidId,
kpidName,
kpidComment
};
IMP_IInArchive_Props
IMP_IInArchive_ArcProps
STDMETHODIMP CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value)
{
COM_TRY_BEGIN
NCOM::CPropVariant prop;
const CExtent *e = NULL;
const CDescriptor *desc = NULL;
if (_isMultiVol)
desc = &_descriptor;
else if (_extents.Size() == 1)
{
e = &_extents[0];
desc = &e->Descriptor;
}
switch (propID)
{
case kpidMainSubfile: prop = (UInt32)0; break;
case kpidPhySize: if (_phySize != 0) prop = _phySize; break;
case kpidClusterSize: prop = (UInt32)((UInt32)1 << _clusterBitsMax); break;
case kpidHeadersSize: if (e) prop = (e->h.overHead << 9); break;
case kpidMethod:
{
AString s;
if (desc && !desc->createType.IsEmpty())
s = desc->createType;
bool zlib = false;
bool marker = false;
int algo = -1;
FOR_VECTOR (i, _extents)
{
const CExtent &extent = _extents[i];
if (!extent.IsOK || !extent.IsVmdk())
continue;
const CHeader &h = extent.h;
if (h.algo != 0)
{
if (h.algo == 1)
zlib = true;
else if (algo != (int)h.algo)
{
s.Add_Space_if_NotEmpty();
char temp[16];
ConvertUInt32ToString(h.algo, temp);
s += temp;
algo = h.algo;
}
}
if (h.Is_Marker())
marker = true;
}
if (zlib)
{
s.Add_Space_if_NotEmpty();
s += "zlib";
}
if (marker)
{
s.Add_Space_if_NotEmpty();
s += "Marker";
}
if (!s.IsEmpty())
prop = s;
break;
}
case kpidComment:
{
if (e && e->DescriptorBuf.Size() != 0)
{
AString s;
s.SetFrom_CalcLen((const char *)(const Byte *)e->DescriptorBuf, (unsigned)e->DescriptorBuf.Size());
if (!s.IsEmpty() && s.Len() <= (1 << 16))
prop = s;
}
break;
}
case kpidId:
if (desc && !desc->CID.IsEmpty())
{
prop = desc->CID;
break;
}
case kpidName:
{
if (!_isMultiVol && desc && desc->Extents.Size() == 1)
{
const CExtentInfo &ei = desc->Extents[0];
if (!ei.FileName.IsEmpty())
{
UString u;
CDescriptor::GetUnicodeName(ei.FileName, u);
if (!u.IsEmpty())
prop = u;
}
}
break;
}
case kpidNumVolumes: if (_isMultiVol) prop = (UInt32)_extents.Size(); break;
case kpidError:
{
if (_missingVol || !_missingVolName.IsEmpty())
{
UString s;
s.SetFromAscii("Missing volume : ");
if (!_missingVolName.IsEmpty())
s += _missingVolName;
prop = s;
}
break;
}
case kpidErrorFlags:
{
UInt32 v = 0;
if (!_isArc) v |= kpv_ErrorFlags_IsNotArc;;
if (_unsupported) v |= kpv_ErrorFlags_UnsupportedMethod;
if (_unsupportedSome) v |= kpv_ErrorFlags_UnsupportedMethod;
if (_headerError) v |= kpv_ErrorFlags_HeadersError;
// if (_missingVol) v |= kpv_ErrorFlags_UnexpectedEnd;
if (v != 0)
prop = v;
break;
}
}
prop.Detach(value);
return S_OK;
COM_TRY_END
}
STDMETHODIMP CHandler::GetProperty(UInt32 /* index */, PROPID propID, PROPVARIANT *value)
{
COM_TRY_BEGIN
NCOM::CPropVariant prop;
switch (propID)
{
case kpidSize: prop = _size; break;
case kpidPackSize:
{
UInt64 packSize = 0;
FOR_VECTOR (i, _extents)
{
const CExtent &e = _extents[i];
if (!e.IsOK)
continue;
if (e.IsVmdk() && !_isMultiVol)
{
UInt64 ov = (e.h.overHead << 9);
if (e.PhySize >= ov)
packSize += e.PhySize - ov;
}
else
packSize += e.PhySize;
}
prop = packSize;
break;
}
case kpidExtension: prop = (_imgExt ? _imgExt : "img"); break;
}
prop.Detach(value);
return S_OK;
COM_TRY_END
}
static int inline GetLog(UInt64 num)
{
for (int i = 0; i < 64; i++)
if (((UInt64)1 << i) == num)
return i;
return -1;
}
HRESULT CExtent::ReadForHeader(IInStream *stream, UInt64 sector, void *data, size_t numSectors)
{
sector <<= 9;
RINOK(stream->Seek(sector, STREAM_SEEK_SET, NULL));
size_t size = numSectors << 9;
RINOK(ReadStream_FALSE(stream, data, size));
UInt64 end = sector + size;
if (PhySize < end)
PhySize = end;
return S_OK;
}
void CHandler::CloseAtError()
{
_extents.Clear();
CHandlerImg::CloseAtError();
}
HRESULT CHandler::Open2(IInStream *stream, IArchiveOpenCallback *openCallback)
{
const unsigned kSectoreSize = 512;
Byte buf[kSectoreSize];
size_t headerSize = kSectoreSize;
RINOK(ReadStream(stream, buf, &headerSize));
if (headerSize < sizeof(k_Signature))
return S_FALSE;
CMyComPtr<IArchiveOpenVolumeCallback> volumeCallback;
if (memcmp(buf, k_Signature, sizeof(k_Signature)) != 0)
{
const char *kSignature_Descriptor = "# Disk DescriptorFile";
const size_t k_SigDesc_Size = strlen(kSignature_Descriptor);
if (headerSize < k_SigDesc_Size)
return S_FALSE;
if (memcmp(buf, kSignature_Descriptor, k_SigDesc_Size) != 0)
return S_FALSE;
UInt64 endPos;
RINOK(stream->Seek(0, STREAM_SEEK_END, &endPos));
if (endPos > (1 << 20))
return S_FALSE;
const size_t numBytes = (size_t)endPos;
_descriptorBuf.Alloc(numBytes);
RINOK(stream->Seek(0, STREAM_SEEK_SET, NULL));
RINOK(ReadStream_FALSE(stream, _descriptorBuf, numBytes));
if (!_descriptor.Parse(_descriptorBuf, _descriptorBuf.Size()))
return S_FALSE;
_isMultiVol = true;
_isArc = true;
_phySize = numBytes;
if (_descriptor.IsThere_Parent())
_unsupported = true;
if (openCallback)
{
openCallback->QueryInterface(IID_IArchiveOpenVolumeCallback, (void **)&volumeCallback);
}
if (!volumeCallback)
{
_unsupported = true;
return E_NOTIMPL;
}
/*
UInt64 totalVirtSize = 0;
FOR_VECTOR (i, _descriptor.Extents)
{
const CExtentInfo &ei = _descriptor.Extents[i];
if (ei.NumSectors >= ((UInt64)1 << (63 - 9)))
return S_FALSE;
totalVirtSize += ei.NumSectors;
if (totalVirtSize >= ((UInt64)1 << (63 - 9)))
return S_FALSE;
}
totalVirtSize <<= 9;
*/
if (_descriptor.Extents.Size() > 1)
{
const UInt64 numFiles = _descriptor.Extents.Size();
RINOK(openCallback->SetTotal(&numFiles, NULL));
}
}
UInt64 complexity = 0;
for (;;)
{
CExtent *e = NULL;
CMyComPtr<IInStream> nextStream;
if (_isMultiVol)
{
const unsigned extentIndex = _extents.Size();
if (extentIndex >= _descriptor.Extents.Size())
break;
const CExtentInfo &ei = _descriptor.Extents[extentIndex];
e = &_extents.AddNew();
e->StartOffset = 0;
if (ei.NumSectors >= ((UInt64)1 << (62 - 9)) ||
ei.StartSector >= ((UInt64)1 << (62 - 9)))
return S_FALSE;
e->NumBytes = ei.NumSectors << 9;
e->IsZero = ei.IsType_ZERO();
if (extentIndex != 0)
e->StartOffset = _extents[extentIndex - 1].GetEndOffset();
if (e->GetEndOffset() < e->StartOffset)
return S_FALSE;
e->VirtSize = e->NumBytes;
if (e->IsZero)
{
e->IsOK = true;
continue;
}
e->IsFlat = ei.IsType_Flat();
e->FlatOffset = ei.StartSector << 9;
UString u;
CDescriptor::GetUnicodeName(ei.FileName, u);
if (u.IsEmpty())
{
_missingVol = true;
continue;
}
HRESULT result = volumeCallback->GetStream(u, &nextStream);
if (result != S_OK && result != S_FALSE)
return result;
if (!nextStream || result != S_OK)
{
if (_missingVolName.IsEmpty())
_missingVolName = u;
_missingVol = true;
continue;
}
if (e->IsFlat)
{
e->IsOK = true;
e->Stream = nextStream;
e->PhySize = e->NumBytes;
continue;
}
stream = nextStream;
headerSize = kSectoreSize;
RINOK(ReadStream(stream, buf, &headerSize));
if (headerSize != kSectoreSize)
continue;
if (memcmp(buf, k_Signature, sizeof(k_Signature)) != 0)
continue;
}
else
{
if (headerSize != kSectoreSize)
return S_FALSE;
e = &_extents.AddNew();
e->StartOffset = 0;
}
HRESULT res = S_FALSE;
if (e->h.Parse(buf))
res = e->Open3(stream, openCallback, _isMultiVol ? _descriptor.Extents.Size() : 1, _extents.Size() - 1, complexity);
if (!_isMultiVol)
{
_isArc = e->IsArc;
_phySize = e->PhySize;
_unsupported = e->Unsupported;
}
if (e->Unsupported)
_unsupportedSome = true;
if (e->HeadersError)
_headerError = true;
if (res != S_OK)
{
if (res != S_FALSE)
return res;
if (!_isMultiVol)
return res;
continue;
}
e->Stream = stream;
e->IsOK = true;
if (!_isMultiVol)
{
e->NumBytes = e->VirtSize;
break;
}
if (e->NumBytes != e->VirtSize)
_headerError = true;
}
if (!_extents.IsEmpty())
_size = _extents.Back().GetEndOffset();
_needDeflate = false;
_clusterBitsMax = 0;
unsigned numOKs = 0;
unsigned numUnsupported = 0;
FOR_VECTOR (i, _extents)
{
const CExtent &e = _extents[i];
if (e.Unsupported)
numUnsupported++;
if (!e.IsOK)
continue;
numOKs++;
if (e.IsVmdk())
{
if (e.NeedDeflate)
_needDeflate = true;
if (_clusterBitsMax < e.ClusterBits)
_clusterBitsMax = e.ClusterBits;
}
}
if (numUnsupported != 0 && numUnsupported == _extents.Size())
_unsupported = true;
return S_OK;
}
HRESULT CExtent::Open3(IInStream *stream, IArchiveOpenCallback *openCallback,
unsigned numVols, unsigned volIndex, UInt64 &complexity)
{
if (h.descriptorSize != 0)
{
if (h.descriptorOffset == 0 ||
h.descriptorSize > (1 << 10))
return S_FALSE;
DescriptorBuf.Alloc((size_t)h.descriptorSize << 9);
RINOK(ReadForHeader(stream, h.descriptorOffset, DescriptorBuf, (size_t)h.descriptorSize));
if (h.descriptorOffset == 1 && h.Is_Marker() && Get64(DescriptorBuf) == 0)
{
// We check data as end marker.
// and if probably it's footer's copy of header, we don't want to open it.
return S_FALSE;
}
DescriptorOK = Descriptor.Parse(DescriptorBuf, DescriptorBuf.Size());
if (!DescriptorOK)
HeadersError = true;
if (Descriptor.IsThere_Parent())
Unsupported = true;
}
if (h.gdOffset == (UInt64)(Int64)-1)
{
// Grain Dir is at end of file
UInt64 endPos;
RINOK(stream->Seek(0, STREAM_SEEK_END, &endPos));
if ((endPos & 511) != 0)
return S_FALSE;
const size_t kEndSize = 512 * 3;
Byte buf2[kEndSize];
if (endPos < kEndSize)
return S_FALSE;
RINOK(stream->Seek(endPos - kEndSize, STREAM_SEEK_SET, NULL));
RINOK(ReadStream_FALSE(stream, buf2, kEndSize));
CHeader h2;
if (!h2.Parse(buf2 + 512))
return S_FALSE;
if (!h.IsSameImageFor(h2))
return S_FALSE;
h = h2;
CMarker m;
m.Parse(buf2);
if (m.NumSectors != 1 || m.SpecSize != 0 || m.Type != k_Marker_FOOTER)
return S_FALSE;
m.Parse(buf2 + 512 * 2);
if (m.NumSectors != 0 || m.SpecSize != 0 || m.Type != k_Marker_END_OF_STREAM)
return S_FALSE;
PhySize = endPos;
}
int grainSize_Log = GetLog(h.grainSize);
if (grainSize_Log < 3 || grainSize_Log > 30 - 9) // grain size must be >= 4 KB
return S_FALSE;
if (h.capacity >= ((UInt64)1 << (63 - 9)))
return S_FALSE;
if (h.overHead >= ((UInt64)1 << (63 - 9)))
return S_FALSE;
IsArc = true;
ClusterBits = (9 + grainSize_Log);
VirtSize = h.capacity << 9;
NeedDeflate = (h.algo >= 1);
if (h.Is_Compressed() ? (h.algo > 1 || !h.Is_Marker()) : (h.algo != 0))
{
Unsupported = true;
PhySize = 0;
return S_FALSE;
}
{
UInt64 overHeadBytes = h.overHead << 9;
if (PhySize < overHeadBytes)
PhySize = overHeadBytes;
}
ZeroSector = 0;
if (h.Is_ZeroGrain())
ZeroSector = 1;
const UInt64 numSectorsPerGde = (UInt64)1 << (grainSize_Log + k_NumMidBits);
const UInt64 numGdeEntries = (h.capacity + numSectorsPerGde - 1) >> (grainSize_Log + k_NumMidBits);
CByteBuffer table;
if (numGdeEntries != 0)
{
if (h.gdOffset == 0)
return S_FALSE;
size_t numSectors = (size_t)((numGdeEntries + ((1 << (9 - 2)) - 1)) >> (9 - 2));
size_t t1SizeBytes = numSectors << 9;
if ((t1SizeBytes >> 2) < numGdeEntries)
return S_FALSE;
table.Alloc(t1SizeBytes);
if (h.Is_Marker())
{
Byte buf2[1 << 9];
if (ReadForHeader(stream, h.gdOffset - 1, buf2, 1) != S_OK)
return S_FALSE;
{
CMarker m;
m.Parse(buf2);
if (m.Type != k_Marker_GRAIN_DIR
|| m.NumSectors != numSectors
|| m.SpecSize != 0)
return S_FALSE;
}
}
RINOK(ReadForHeader(stream, h.gdOffset, table, numSectors));
}
const size_t clusterSize = (size_t)1 << ClusterBits;
const UInt64 complexityStart = complexity;
if (openCallback)
{
complexity += (UInt64)numGdeEntries << (k_NumMidBits + 2);
{
const UInt64 numVols2 = numVols;
RINOK(openCallback->SetTotal((numVols == 1) ? NULL : &numVols2, &complexity));
}
if (numVols != 1)
{
const UInt64 volIndex2 = volIndex;
RINOK(openCallback->SetCompleted(numVols == 1 ? NULL : &volIndex2, &complexityStart));
}
}
UInt64 lastSector = 0;
UInt64 lastVirtCluster = 0;
size_t numProcessed_Prev = 0;
for (size_t i = 0; i < numGdeEntries; i++)
{
const size_t k_NumSectors = (size_t)1 << (k_NumMidBits - 9 + 2);
const size_t k_NumMidItems = (size_t)1 << k_NumMidBits;
CByteBuffer &buf = Tables.AddNew();
{
const UInt32 v = Get32((const Byte *)table + (size_t)i * 4);
if (v == 0 || v == ZeroSector)
continue;
if (openCallback && (i - numProcessed_Prev) >= 1024)
{
const UInt64 comp = complexityStart + ((UInt64)i << (k_NumMidBits + 2));
const UInt64 volIndex2 = volIndex;
RINOK(openCallback->SetCompleted(numVols == 1 ? NULL : &volIndex2, &comp));
numProcessed_Prev = i;
}
if (h.Is_Marker())
{
Byte buf2[1 << 9];
if (ReadForHeader(stream, v - 1, buf2, 1) != S_OK)
return S_FALSE;
{
CMarker m;
m.Parse(buf2);
if (m.Type != k_Marker_GRAIN_TABLE
|| m.NumSectors != k_NumSectors
|| m.SpecSize != 0)
return S_FALSE;
}
}
buf.Alloc(k_NumMidItems * 4);
RINOK(ReadForHeader(stream, v, buf, k_NumSectors));
}
for (size_t k = 0; k < k_NumMidItems; k++)
{
const UInt32 v = Get32((const Byte *)buf + (size_t)k * 4);
if (v == 0 || v == ZeroSector)
continue;
if (v < h.overHead)
return S_FALSE;
if (lastSector < v)
{
lastSector = v;
if (NeedDeflate)
lastVirtCluster = ((UInt64)i << k_NumMidBits) + k;
}
}
}
if (!NeedDeflate)
{
UInt64 end = ((UInt64)lastSector << 9) + clusterSize;
if (PhySize < end)
PhySize = end;
}
else if (lastSector != 0)
{
Byte buf[1 << 9];
if (ReadForHeader(stream, lastSector, buf, 1) == S_OK)
{
UInt64 lba = Get64(buf);
if (lba == (lastVirtCluster << (ClusterBits - 9)))
{
UInt32 dataSize = Get32(buf + 8);
size_t dataSize2 = (size_t)dataSize + 12;
dataSize2 = (dataSize2 + 511) & ~(size_t)511;
UInt64 end = ((UInt64)lastSector << 9) + dataSize2;
if (PhySize < end)
PhySize = end;
}
}
}
return S_OK;
}
STDMETHODIMP CHandler::Close()
{
_phySize = 0;
_size = 0;
_cacheCluster = (UInt64)(Int64)-1;
_cacheExtent = (unsigned)(int)-1;
_clusterBitsMax = 0;
_isArc = false;
_unsupported = false;
_unsupportedSome = false;
_headerError = false;
_missingVol = false;
_isMultiVol = false;
_needDeflate = false;
_missingVolName.Empty();
_descriptorBuf.Free();
_descriptor.Clear();
_imgExt = NULL;
Stream.Release(); // Stream vriable is unused
_extents.Clear();
return S_OK;
}
STDMETHODIMP CHandler::GetStream(UInt32 /* index */, ISequentialInStream **stream)
{
COM_TRY_BEGIN
*stream = 0;
if (_unsupported)
return S_FALSE;
ClearStreamVars();
// _stream_UsePackSize = true;
if (_needDeflate)
{
if (!_bufInStream)
{
_bufInStreamSpec = new CBufInStream;
_bufInStream = _bufInStreamSpec;
}
if (!_bufOutStream)
{
_bufOutStreamSpec = new CBufPtrSeqOutStream();
_bufOutStream = _bufOutStreamSpec;
}
if (!_zlibDecoder)
{
_zlibDecoderSpec = new NCompress::NZlib::CDecoder;
_zlibDecoder = _zlibDecoderSpec;
}
const size_t clusterSize = (size_t)1 << _clusterBitsMax;
_cache.AllocAtLeast(clusterSize);
_cacheCompressed.AllocAtLeast(clusterSize * 2);
}
FOR_VECTOR (i, _extents)
{
RINOK(_extents[i].InitAndSeek());
}
CMyComPtr<ISequentialInStream> streamTemp = this;
InitAndSeekMain();
*stream = streamTemp.Detach();
return S_OK;
COM_TRY_END
}
REGISTER_ARC_I(
"VMDK", "vmdk", NULL, 0xC8,
k_Signature,
0,
0,
NULL)
}}
Reference in New Issue Copy Permalink