seven-zip 1.4.2 → 1.7.0.rc1

data/ext/p7zip/CPP/7zip/Archive/VhdHandler.cpp

@@ -4,45 +4,47 @@
 
 #include "../../../C/CpuArch.h"
 
-#include "Common/Buffer.h"
-#include "Common/ComTry.h"
-#include "Common/IntToString.h"
-#include "Common/MyString.h"
+#include "../../Common/ComTry.h"
+#include "../../Common/IntToString.h"
 
-#include "Windows/PropVariant.h"
+#include "../../Windows/PropVariant.h"
 
 #include "../Common/LimitedStreams.h"
-#include "../Common/ProgressUtils.h"
 #include "../Common/RegisterArc.h"
 #include "../Common/StreamUtils.h"
 
-#include "../Compress/CopyCoder.h"
+#include "HandlerCont.h"
 
 #define Get16(p) GetBe16(p)
 #define Get32(p) GetBe32(p)
 #define Get64(p) GetBe64(p)
 
-#define G32(p, dest) dest = Get32(p);
-#define G64(p, dest) dest = Get64(p);
+#define G32(_offs_, dest) dest = Get32(p + (_offs_));
+#define G64(_offs_, dest) dest = Get64(p + (_offs_));
 
 using namespace NWindows;
 
 namespace NArchive {
 namespace NVhd {
 
+#define SIGNATURE { 'c', 'o', 'n', 'e', 'c', 't', 'i', 'x', 0, 0 }
+  
+static const unsigned kSignatureSize = 10;
+static const Byte kSignature[kSignatureSize] = SIGNATURE;
+
 static const UInt32 kUnusedBlock = 0xFFFFFFFF;
 
 static const UInt32 kDiskType_Fixed = 2;
 static const UInt32 kDiskType_Dynamic = 3;
 static const UInt32 kDiskType_Diff = 4;
 
-static const char *kDiskTypes[] =
+static const char * const kDiskTypes[] =
 {
-  "0",
-  "1",
-  "Fixed",
-  "Dynamic",
-  "Differencing"
+    "0"
+  , "1"
+  , "Fixed"
+  , "Dynamic"
+  , "Differencing"
 };
 
 struct CFooter
@@ -73,7 +75,7 @@ struct CFooter
 
 AString CFooter::GetTypeString() const
 {
-  if (Type < sizeof(kDiskTypes) / sizeof(kDiskTypes[0]))
+  if (Type < ARRAY_SIZE(kDiskTypes))
     return kDiskTypes[Type];
   char s[16];
   ConvertUInt32ToString(Type, s);
@@ -96,27 +98,35 @@ static bool CheckBlock(const Byte *p, unsigned size, unsigned checkSumOffset, un
   return true;
 }
 
+static const unsigned kSectorSize_Log = 9;
+static const unsigned kSectorSize = 1 << kSectorSize_Log;
+static const unsigned kHeaderSize = 512;
+
 bool CFooter::Parse(const Byte *p)
 {
-  if (memcmp(p, "conectix", 8) != 0)
+  if (memcmp(p, kSignature, kSignatureSize) != 0)
+    return false;
+  // G32(0x08, Features);
+  // G32(0x0C, FormatVersion);
+  G64(0x10, DataOffset);
+  G32(0x18, CTime);
+  G32(0x1C, CreatorApp);
+  G32(0x20, CreatorVersion);
+  G32(0x24, CreatorHostOS);
+  // G64(0x28, OriginalSize);
+  G64(0x30, CurrentSize);
+  G32(0x38, DiskGeometry);
+  G32(0x3C, Type);
+  if (Type < kDiskType_Fixed ||
+      Type > kDiskType_Diff)
     return false;
-  // G32(p + 0x08, Features);
-  // G32(p + 0x0C, FormatVersion);
-  G64(p + 0x10, DataOffset);
-  G32(p + 0x18, CTime);
-  G32(p + 0x1C, CreatorApp);
-  G32(p + 0x20, CreatorVersion);
-  G32(p + 0x24, CreatorHostOS);
-  // G64(p + 0x28, OriginalSize);
-  G64(p + 0x30, CurrentSize);
-  G32(p + 0x38, DiskGeometry);
-  G32(p + 0x3C, Type);
   memcpy(Id, p + 0x44, 16);
   SavedState = p[0x54];
-  return CheckBlock(p, 512, 0x40, 0x55);
+  // if (DataOffset > ((UInt64)1 << 62)) return false;
+  // if (CurrentSize > ((UInt64)1 << 62)) return false;
+  return CheckBlock(p, kHeaderSize, 0x40, 0x55);
 }
 
-/*
 struct CParentLocatorEntry
 {
   UInt32 Code;
@@ -124,17 +134,15 @@ struct CParentLocatorEntry
   UInt32 DataLen;
   UInt64 DataOffset;
 
-  bool Parse(const Byte *p);
+  bool Parse(const Byte *p)
+  {
+    G32(0x00, Code);
+    G32(0x04, DataSpace);
+    G32(0x08, DataLen);
+    G64(0x10, DataOffset);
+    return Get32(p + 0x0C) == 0; // Reserved
+  }
 };
-bool CParentLocatorEntry::Parse(const Byte *p)
-{
-  G32(p + 0x00, Code);
-  G32(p + 0x04, DataSpace);
-  G32(p + 0x08, DataLen);
-  G32(p + 0x10, DataOffset);
-  return (Get32(p + 0x0C) == 0); // Resrved
-}
-*/
 
 struct CDynHeader
 {
@@ -142,68 +150,77 @@ struct CDynHeader
   UInt64 TableOffset;
   // UInt32 HeaderVersion;
   UInt32 NumBlocks;
-  int BlockSizeLog;
+  unsigned BlockSizeLog;
   UInt32 ParentTime;
   Byte ParentId[16];
+  bool RelativeNameWasUsed;
   UString ParentName;
-  // CParentLocatorEntry ParentLocators[8];
+  UString RelativeParentNameFromLocator;
+  CParentLocatorEntry ParentLocators[8];
 
   bool Parse(const Byte *p);
   UInt32 NumBitMapSectors() const
   {
-    UInt32 numSectorsInBlock = (1 << (BlockSizeLog - 9));
-    return (numSectorsInBlock + 512 * 8 - 1) / (512 * 8);
+    UInt32 numSectorsInBlock = (1 << (BlockSizeLog - kSectorSize_Log));
+    return (numSectorsInBlock + kSectorSize * 8 - 1) / (kSectorSize * 8);
+  }
+  void Clear()
+  {
+    RelativeNameWasUsed = false;
+    ParentName.Empty();
+    RelativeParentNameFromLocator.Empty();
   }
 };
 
-static int GetLog(UInt32 num)
-{
-  for (int i = 0; i < 31; i++)
-    if (((UInt32)1 << i) == num)
-      return i;
-  return -1;
-}
-
 bool CDynHeader::Parse(const Byte *p)
 {
   if (memcmp(p, "cxsparse", 8) != 0)
     return false;
-  // G64(p + 0x08, DataOffset);
-  G64(p + 0x10, TableOffset);
-  // G32(p + 0x18, HeaderVersion);
-  G32(p + 0x1C, NumBlocks);
-  BlockSizeLog = GetLog(Get32(p + 0x20));
-  if (BlockSizeLog < 9 || BlockSizeLog > 30)
-    return false;
-  G32(p + 0x38, ParentTime);
+  // G64(0x08, DataOffset);
+  G64(0x10, TableOffset);
+  // G32(0x18, HeaderVersion);
+  G32(0x1C, NumBlocks);
+  {
+    UInt32 blockSize = Get32(p + 0x20);
+    unsigned i;
+    for (i = kSectorSize_Log;; i++)
+    {
+      if (i > 31)
+        return false;
+      if (((UInt32)1 << i) == blockSize)
+        break;
+    }
+    BlockSizeLog = i;
+  }
+  G32(0x38, ParentTime);
   if (Get32(p + 0x3C) != 0) // reserved
     return false;
   memcpy(ParentId, p + 0x28, 16);
   {
-    const int kNameLength = 256;
-    wchar_t *s = ParentName.GetBuffer(kNameLength);
-    for (unsigned i = 0; i < kNameLength; i++)
-      s[i] = Get16(p + 0x40 + i * 2);
-    s[kNameLength] = 0;
-    ParentName.ReleaseBuffer();
+    const unsigned kNameLen = 256;
+    wchar_t *s = ParentName.GetBuf(kNameLen);
+    unsigned i;
+    for (i = 0; i < kNameLen; i++)
+    {
+      wchar_t c = Get16(p + 0x40 + i * 2);
+      if (c == 0)
+        break;
+      s[i] = c;
+    }
+    s[i] = 0;
+    ParentName.ReleaseBuf_SetLen(i);
   }
-  /*
-  for (int i = 0; i < 8; i++)
+  for (unsigned i = 0; i < 8; i++)
     if (!ParentLocators[i].Parse(p + 0x240 + i * 24))
       return false;
-  */
   return CheckBlock(p, 1024, 0x24, 0x240 + 8 * 24);
 }
 
-class CHandler:
-  public IInStream,
-  public IInArchive,
-  public IInArchiveGetStream,
-  public CMyUnknownImp
+class CHandler: public CHandlerImg
 {
-  UInt64 _virtPos;
-  UInt64 _phyPos;
-  UInt64 _phyLimit;
+  UInt64 _posInArcLimit;
+  UInt64 _startOffset;
+  UInt64 _phySize;
 
   CFooter Footer;
   CDynHeader Dyn;
@@ -211,10 +228,25 @@ class CHandler:
   CByteBuffer BitMap;
   UInt32 BitMapTag;
   UInt32 NumUsedBlocks;
-  CMyComPtr<IInStream> Stream;
+  // CMyComPtr<IInStream> Stream;
   CMyComPtr<IInStream> ParentStream;
   CHandler *Parent;
+  UString _errorMessage;
+  // bool _unexpectedEnd;
 
+  void AddErrorMessage(const wchar_t *s)
+  {
+    if (!_errorMessage.IsEmpty())
+      _errorMessage.Add_LF();
+    _errorMessage += s;
+  }
+  void UpdatePhySize(UInt64 value)
+  {
+    if (_phySize < value)
+      _phySize = value;
+  }
+
+  void Reset_PosInArc() { _posInArc = (UInt64)0 - 1; }
   HRESULT Seek(UInt64 offset);
   HRESULT InitAndSeek();
   HRESULT ReadPhy(UInt64 offset, void *data, UInt32 size);
@@ -223,45 +255,67 @@ class CHandler:
   UInt64 GetPackSize() const
     { return Footer.ThereIsDynamic() ? ((UInt64)NumUsedBlocks << Dyn.BlockSizeLog) : Footer.CurrentSize; }
 
-  UString GetParentName() const
+  UString GetParentSequence() const
   {
     const CHandler *p = this;
     UString res;
     while (p && p->NeedParent())
     {
       if (!res.IsEmpty())
-        res += L" -> ";
-      res += p->Dyn.ParentName;
+        res.AddAscii(" -> ");
+      UString mainName;
+      UString anotherName;
+      if (Dyn.RelativeNameWasUsed)
+      {
+        mainName = p->Dyn.RelativeParentNameFromLocator;
+        anotherName = p->Dyn.ParentName;
+      }
+      else
+      {
+        mainName = p->Dyn.ParentName;
+        anotherName = p->Dyn.RelativeParentNameFromLocator;
+      }
+      res += mainName;
+      if (mainName != anotherName && !anotherName.IsEmpty())
+      {
+        res.Add_Space();
+        res += L'(';
+        res += anotherName;
+        res += L')';
+      }
       p = p->Parent;
     }
     return res;
   }
 
-  bool IsOK() const
+  bool AreParentsOK() const
   {
     const CHandler *p = this;
     while (p->NeedParent())
     {
       p = p->Parent;
-      if (p == 0)
+      if (!p)
         return false;
     }
     return true;
   }
 
   HRESULT Open3();
-  HRESULT Open2(IInStream *stream, CHandler *child, IArchiveOpenCallback *openArchiveCallback, int level);
+  HRESULT Open2(IInStream *stream, CHandler *child, IArchiveOpenCallback *openArchiveCallback, unsigned level);
+  HRESULT Open2(IInStream *stream, IArchiveOpenCallback *openArchiveCallback)
+  {
+    return Open2(stream, NULL, openArchiveCallback, 0);
+  }
+  void CloseAtError();
 
 public:
-  MY_UNKNOWN_IMP3(IInArchive, IInArchiveGetStream, IInStream)
+  INTERFACE_IInArchive_Img(;)
 
-  INTERFACE_IInArchive(;)
   STDMETHOD(GetStream)(UInt32 index, ISequentialInStream **stream);
   STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
-  STDMETHOD(Seek)(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition);
 };
 
-HRESULT CHandler::Seek(UInt64 offset) { return Stream->Seek(offset, STREAM_SEEK_SET, NULL); }
+HRESULT CHandler::Seek(UInt64 offset) { return Stream->Seek(_startOffset + offset, STREAM_SEEK_SET, NULL); }
 
 HRESULT CHandler::InitAndSeek()
 {
@@ -269,50 +323,132 @@ HRESULT CHandler::InitAndSeek()
   {
     RINOK(Parent->InitAndSeek());
   }
-  _virtPos = _phyPos = 0;
+  _virtPos = _posInArc = 0;
   BitMapTag = kUnusedBlock;
-  BitMap.SetCapacity(Dyn.NumBitMapSectors() << 9);
+  BitMap.Alloc(Dyn.NumBitMapSectors() << kSectorSize_Log);
   return Seek(0);
 }
 
 HRESULT CHandler::ReadPhy(UInt64 offset, void *data, UInt32 size)
 {
-  if (offset + size > _phyLimit)
+  if (offset + size > _posInArcLimit)
     return S_FALSE;
-  if (offset != _phyPos)
+  if (offset != _posInArc)
   {
-    _phyPos = offset;
+    _posInArc = offset;
     RINOK(Seek(offset));
   }
   HRESULT res = ReadStream_FALSE(Stream, data, size);
-  _phyPos += size;
+  if (res == S_OK)
+    _posInArc += size;
+  else
+    Reset_PosInArc();
   return res;
 }
 
 HRESULT CHandler::Open3()
 {
-  RINOK(Stream->Seek(0, STREAM_SEEK_END, &_phyPos));
-  if (_phyPos < 512)
+  // Fixed archive uses only footer
+
+  UInt64 startPos;
+  RINOK(Stream->Seek(0, STREAM_SEEK_CUR, &startPos));
+  _startOffset = startPos;
+  Byte header[kHeaderSize];
+  RINOK(ReadStream_FALSE(Stream, header, kHeaderSize));
+  bool headerIsOK = Footer.Parse(header);
+  _size = Footer.CurrentSize;
+
+  if (headerIsOK && !Footer.ThereIsDynamic())
+  {
+    // fixed archive
+    if (startPos < Footer.CurrentSize)
+      return S_FALSE;
+    _posInArcLimit = Footer.CurrentSize;
+    _phySize = Footer.CurrentSize + kHeaderSize;
+    _startOffset = startPos - Footer.CurrentSize;
+    _posInArc = _phySize;
+    return S_OK;
+  }
+
+  UInt64 fileSize;
+  RINOK(Stream->Seek(0, STREAM_SEEK_END, &fileSize));
+  if (fileSize < kHeaderSize)
     return S_FALSE;
+
   const UInt32 kDynSize = 1024;
   Byte buf[kDynSize];
 
-  _phyLimit = _phyPos;
-  RINOK(ReadPhy(_phyLimit - 512, buf, 512));
-  if (!Footer.Parse(buf))
-    return S_FALSE;
-  _phyLimit -= 512;
+  RINOK(Stream->Seek(fileSize - kHeaderSize, STREAM_SEEK_SET, NULL));
+  RINOK(ReadStream_FALSE(Stream, buf, kHeaderSize));
 
-  if (!Footer.ThereIsDynamic())
+  if (!headerIsOK)
+  {
+    if (!Footer.Parse(buf))
+      return S_FALSE;
+    _size = Footer.CurrentSize;
+    if (Footer.ThereIsDynamic())
+      return S_FALSE; // we can't open Dynamic Archive backward.
+    _posInArcLimit = Footer.CurrentSize;
+    _phySize = Footer.CurrentSize + kHeaderSize;
+    _startOffset = fileSize - kHeaderSize - Footer.CurrentSize;
+    _posInArc = _phySize;
     return S_OK;
+  }
 
-  RINOK(ReadPhy(0, buf + 512, 512));
-  if (memcmp(buf, buf + 512, 512) != 0)
-    return S_FALSE;
+  _phySize = kHeaderSize;
+  _posInArc = fileSize - startPos;
+  _posInArcLimit = _posInArc - kHeaderSize;
+
+  bool headerAndFooterAreEqual = false;
+  if (memcmp(header, buf, kHeaderSize) == 0)
+  {
+    headerAndFooterAreEqual = true;
+    _phySize = fileSize - _startOffset;
+  }
 
   RINOK(ReadPhy(Footer.DataOffset, buf, kDynSize));
   if (!Dyn.Parse(buf))
     return S_FALSE;
+
+  UpdatePhySize(Footer.DataOffset + kDynSize);
+
+  for (int i = 0; i < 8; i++)
+  {
+    const CParentLocatorEntry &locator = Dyn.ParentLocators[i];
+    const UInt32 kNameBufSizeMax = 1024;
+    if (locator.DataLen < kNameBufSizeMax &&
+        locator.DataOffset < _posInArcLimit &&
+        locator.DataOffset + locator.DataLen <= _posInArcLimit)
+    {
+      if (locator.Code == 0x57327275 && (locator.DataLen & 1) == 0)
+      {
+        // "W2ru" locator
+        // Path is encoded as little-endian UTF-16
+        Byte nameBuf[kNameBufSizeMax];
+        UString tempString;
+        unsigned len = (locator.DataLen >> 1);
+        {
+          wchar_t *s = tempString.GetBuf(len);
+          RINOK(ReadPhy(locator.DataOffset, nameBuf, locator.DataLen));
+          unsigned j;
+          for (j = 0; j < len; j++)
+          {
+            wchar_t c = GetUi16(nameBuf + j * 2);
+            if (c == 0)
+              break;
+            s[j] = c;
+          }
+          s[j] = 0;
+          tempString.ReleaseBuf_SetLen(j);
+        }
+        if (tempString[0] == L'.' && tempString[1] == L'\\')
+          tempString.DeleteFrontal(2);
+        Dyn.RelativeParentNameFromLocator = tempString;
+      }
+    }
+    if (locator.DataLen != 0)
+      UpdatePhySize(locator.DataOffset + locator.DataLen);
+  }
   
   if (Dyn.NumBlocks >= (UInt32)1 << 31)
     return S_FALSE;
@@ -324,32 +460,83 @@ HRESULT CHandler::Open3()
   else if (((Footer.CurrentSize - 1) >> Dyn.BlockSizeLog) + 1 != Dyn.NumBlocks)
     return S_FALSE;
 
-  Bat.Reserve(Dyn.NumBlocks);
+  Bat.ClearAndReserve(Dyn.NumBlocks);
+
+  UInt32 bitmapSize = Dyn.NumBitMapSectors() << kSectorSize_Log;
+
   while ((UInt32)Bat.Size() < Dyn.NumBlocks)
   {
-    RINOK(ReadPhy(Dyn.TableOffset + (UInt64)Bat.Size() * 4, buf, 512));
-    for (UInt32 j = 0; j < 512; j += 4)
+    RINOK(ReadPhy(Dyn.TableOffset + (UInt64)Bat.Size() * 4, buf, kSectorSize));
+    UpdatePhySize(Dyn.TableOffset + kSectorSize);
+    for (UInt32 j = 0; j < kSectorSize; j += 4)
     {
       UInt32 v = Get32(buf + j);
       if (v != kUnusedBlock)
+      {
+        UInt32 blockSize = (UInt32)1 << Dyn.BlockSizeLog;
+        UpdatePhySize(((UInt64)v << kSectorSize_Log) + bitmapSize + blockSize);
         NumUsedBlocks++;
-      Bat.Add(v);
+      }
+      Bat.AddInReserved(v);
       if ((UInt32)Bat.Size() >= Dyn.NumBlocks)
         break;
     }
   }
+
+  if (headerAndFooterAreEqual)
+    return S_OK;
+
+  if (_startOffset + _phySize + kHeaderSize > fileSize)
+  {
+    // _unexpectedEnd = true;
+    _posInArcLimit = _phySize;
+    _phySize += kHeaderSize;
+    return S_OK;
+  }
+
+  RINOK(ReadPhy(_phySize, buf, kHeaderSize));
+  if (memcmp(header, buf, kHeaderSize) == 0)
+  {
+    _posInArcLimit = _phySize;
+    _phySize += kHeaderSize;
+    return S_OK;
+  }
+
+  if (_phySize == 0x800)
+  {
+    /* WHY does empty archive contain additional empty sector?
+       We skip that sector and check footer again. */
+    unsigned i;
+    for (i = 0; i < kSectorSize && buf[i] == 0; i++);
+    if (i == kSectorSize)
+    {
+      RINOK(ReadPhy(_phySize + kSectorSize, buf, kHeaderSize));
+      if (memcmp(header, buf, kHeaderSize) == 0)
+      {
+        _phySize += kSectorSize;
+        _posInArcLimit = _phySize;
+        _phySize += kHeaderSize;
+        return S_OK;
+      }
+    }
+  }
+  _posInArcLimit = _phySize;
+  _phySize += kHeaderSize;
+  AddErrorMessage(L"Can't find footer");
   return S_OK;
 }
 
 STDMETHODIMP CHandler::Read(void *data, UInt32 size, UInt32 *processedSize)
 {
-  if (processedSize != NULL)
+  if (processedSize)
     *processedSize = 0;
   if (_virtPos >= Footer.CurrentSize)
-    return (Footer.CurrentSize == _virtPos) ? S_OK: E_FAIL;
-  UInt64 rem = Footer.CurrentSize - _virtPos;
-  if (size > rem)
-    size = (UInt32)rem;
+    return S_OK;
+  {
+    const UInt64 rem = Footer.CurrentSize - _virtPos;
+    if (size > rem)
+      size = (UInt32)rem;
+  }
   if (size == 0)
     return S_OK;
   UInt32 blockIndex = (UInt32)(_virtPos >> Dyn.BlockSizeLog);
@@ -371,17 +558,17 @@ STDMETHODIMP CHandler::Read(void *data, UInt32 size, UInt32 *processedSize)
   }
   else
   {
-    UInt64 newPos = (UInt64)blockSectIndex << 9;
+    UInt64 newPos = (UInt64)blockSectIndex << kSectorSize_Log;
     if (BitMapTag != blockIndex)
     {
-      RINOK(ReadPhy(newPos, BitMap, (UInt32)BitMap.GetCapacity()));
+      RINOK(ReadPhy(newPos, BitMap, (UInt32)BitMap.Size()));
       BitMapTag = blockIndex;
     }
-    RINOK(ReadPhy(newPos + BitMap.GetCapacity() + offsetInBlock, data, size));
+    RINOK(ReadPhy(newPos + BitMap.Size() + offsetInBlock, data, size));
     for (UInt32 cur = 0; cur < size;)
     {
-      UInt32 rem = MyMin(0x200 - (offsetInBlock & 0x1FF), size - cur);
-      UInt32 bmi = offsetInBlock >> 9;
+      const UInt32 rem = MyMin(0x200 - (offsetInBlock & 0x1FF), size - cur);
+      UInt32 bmi = offsetInBlock >> kSectorSize_Log;
       if (((BitMap[bmi >> 3] >> (7 - (bmi & 7))) & 1) == 0)
       {
         if (ParentStream)
@@ -401,25 +588,12 @@ STDMETHODIMP CHandler::Read(void *data, UInt32 size, UInt32 *processedSize)
       cur += rem;
     }
   }
-  if (processedSize != NULL)
+  if (processedSize)
     *processedSize = size;
   _virtPos += size;
   return res;
 }
 
-STDMETHODIMP CHandler::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition)
-{
-  switch(seekOrigin)
-  {
-    case STREAM_SEEK_SET: _virtPos = offset; break;
-    case STREAM_SEEK_CUR: _virtPos += offset; break;
-    case STREAM_SEEK_END: _virtPos = Footer.CurrentSize + offset; break;
-    default: return STG_E_INVALIDFUNCTION;
-  }
-  if (newPosition)
-    *newPosition = _virtPos;
-  return S_OK;
-}
 
 enum
 {
@@ -427,29 +601,30 @@ enum
   kpidSavedState
 };
 
-STATPROPSTG kArcProps[] =
+static const CStatProp kArcProps[] =
 {
   { NULL, kpidSize, VT_UI8},
+  { NULL, kpidOffset, VT_UI8},
   { NULL, kpidCTime, VT_FILETIME},
   { NULL, kpidClusterSize, VT_UI8},
   { NULL, kpidMethod, VT_BSTR},
-  { L"Parent", kpidParent, VT_BSTR},
+  { "Parent", kpidParent, VT_BSTR},
   { NULL, kpidCreatorApp, VT_BSTR},
   { NULL, kpidHostOS, VT_BSTR},
-  { L"Saved State", kpidSavedState, VT_BOOL},
+  { "Saved State", kpidSavedState, VT_BOOL},
   { NULL, kpidId, VT_BSTR}
  };
 
-STATPROPSTG kProps[] =
+static const Byte kProps[] =
 {
-  { NULL, kpidSize, VT_UI8},
-  { NULL, kpidPackSize, VT_UI8},
-  { NULL, kpidCTime, VT_FILETIME}
+  kpidSize,
+  kpidPackSize,
+  kpidCTime
   
   /*
-  { NULL, kpidNumCyls, VT_UI4},
-  { NULL, kpidNumHeads, VT_UI4},
-  { NULL, kpidSectorsPerTrack, VT_UI4}
+  { kpidNumCyls, VT_UI4},
+  { kpidNumHeads, VT_UI4},
+  { kpidSectorsPerTrack, VT_UI4}
   */
 };
 
@@ -470,11 +645,11 @@ static void VhdTimeToFileTime(UInt32 vhdTime, NCOM::CPropVariant &prop)
   prop = utc;
 }
 
-static void StringToAString(char *dest, UInt32 s)
+static void StringToAString(char *dest, UInt32 val)
 {
   for (int i = 24; i >= 0; i -= 8)
   {
-    Byte b = (Byte)((s >> i) & 0xFF);
+    Byte b = (Byte)((val >> i) & 0xFF);
     if (b < 0x20 || b > 0x7F)
       break;
     *dest++ = b;
@@ -496,11 +671,12 @@ STDMETHODIMP CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value)
 {
   COM_TRY_BEGIN
   NCOM::CPropVariant prop;
-  switch(propID)
+  switch (propID)
   {
     case kpidMainSubfile: prop = (UInt32)0; break;
     case kpidCTime: VhdTimeToFileTime(Footer.CTime, prop); break;
     case kpidClusterSize: if (Footer.ThereIsDynamic()) prop = (UInt32)1 << Dyn.BlockSizeLog; break;
+    case kpidShortComment:
     case kpidMethod:
     {
       AString s = Footer.GetTypeString();
@@ -508,9 +684,9 @@ STDMETHODIMP CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value)
       {
         s += " -> ";
         const CHandler *p = this;
-        while (p != 0 && p->NeedParent())
+        while (p && p->NeedParent())
           p = p->Parent;
-        if (p == 0)
+        if (!p)
           s += '?';
         else
           s += p->Footer.GetTypeString();
@@ -525,7 +701,7 @@ STDMETHODIMP CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value)
       AString res = s;
       res.Trim();
       ConvertUInt32ToString(Footer.CreatorVersion >> 16, s);
-      res += ' ';
+      res.Add_Space();
       res += s;
       res += '.';
       ConvertUInt32ToString(Footer.CreatorVersion & 0xFFFF, s);
@@ -535,7 +711,7 @@ STDMETHODIMP CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value)
     }
     case kpidHostOS:
     {
-      if (Footer.CreatorHostOS == 0x5769326b)
+      if (Footer.CreatorHostOS == 0x5769326B)
         prop = "Windows";
       else
       {
@@ -555,151 +731,166 @@ STDMETHODIMP CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value)
       break;
     }
     case kpidSavedState: prop = Footer.SavedState ? true : false; break;
-    case kpidParent: if (NeedParent()) prop = GetParentName(); break;
+    case kpidParent: if (NeedParent()) prop = GetParentSequence(); break;
+    case kpidOffset: prop = _startOffset; break;
+    case kpidPhySize: prop = _phySize; break;
+    /*
+    case kpidErrorFlags:
+    {
+      UInt32 flags = 0;
+      if (_unexpectedEnd)
+        flags |= kpv_ErrorFlags_UnexpectedEndOfArc;
+      if (flags != 0)
+        prop = flags;
+      break;
+    }
+    */
+    case kpidError: if (!_errorMessage.IsEmpty()) prop = _errorMessage; break;
   }
   prop.Detach(value);
   return S_OK;
   COM_TRY_END
 }
 
-HRESULT CHandler::Open2(IInStream *stream, CHandler *child, IArchiveOpenCallback *openArchiveCallback, int level)
+
+HRESULT CHandler::Open2(IInStream *stream, CHandler *child, IArchiveOpenCallback *openArchiveCallback, unsigned level)
 {
   Close();
   Stream = stream;
-  if (level > 32)
+  if (level > (1 << 12)) // Maybe we need to increase that limit
     return S_FALSE;
+  
   RINOK(Open3());
+  
   if (child && memcmp(child->Dyn.ParentId, Footer.Id, 16) != 0)
     return S_FALSE;
   if (Footer.Type != kDiskType_Diff)
     return S_OK;
-  CMyComPtr<IArchiveOpenVolumeCallback> openVolumeCallback;
-  if (openArchiveCallback->QueryInterface(IID_IArchiveOpenVolumeCallback, (void **)&openVolumeCallback) != S_OK)
-    return S_FALSE;
-  CMyComPtr<IInStream> nextStream;
-  HRESULT res = openVolumeCallback->GetStream(Dyn.ParentName, &nextStream);
-  if (res == S_FALSE)
-    return S_OK;
-  RINOK(res);
 
-  Parent = new CHandler;
-  ParentStream = Parent;
-  return Parent->Open2(nextStream, this, openArchiveCallback, level + 1);
-}
+  bool useRelative;
+  UString name;
+  
+  if (!Dyn.RelativeParentNameFromLocator.IsEmpty())
+  {
+    useRelative = true;
+    name = Dyn.RelativeParentNameFromLocator;
+  }
+  else
+  {
+    useRelative = false;
+    name = Dyn.ParentName;
+  }
+  
+  Dyn.RelativeNameWasUsed = useRelative;
 
-STDMETHODIMP CHandler::Open(IInStream *stream,
-    const UInt64 * /* maxCheckStartPosition */,
-    IArchiveOpenCallback * openArchiveCallback)
-{
-  COM_TRY_BEGIN
+  CMyComPtr<IArchiveOpenVolumeCallback> openVolumeCallback;
+  openArchiveCallback->QueryInterface(IID_IArchiveOpenVolumeCallback, (void **)&openVolumeCallback);
+
+  if (openVolumeCallback)
   {
-    HRESULT res;
-    try
+    CMyComPtr<IInStream> nextStream;
+    HRESULT res = openVolumeCallback->GetStream(name, &nextStream);
+    
+    if (res == S_FALSE)
     {
-      res = Open2(stream, NULL, openArchiveCallback, 0);
-      if (res == S_OK)
-        return S_OK;
+      if (useRelative && Dyn.ParentName != Dyn.RelativeParentNameFromLocator)
+      {
+        res = openVolumeCallback->GetStream(Dyn.ParentName, &nextStream);
+        if (res == S_OK)
+          Dyn.RelativeNameWasUsed = false;
+      }
     }
-    catch(...)
+
+    if (res != S_OK && res != S_FALSE)
+      return res;
+    
+    if (res == S_FALSE || !nextStream)
     {
-      Close();
-      throw;
+      UString s;
+      s.SetFromAscii("Missing volume : ");
+      s += name;
+      AddErrorMessage(s);
+      return S_OK;
+    }
+    
+    Parent = new CHandler;
+    ParentStream = Parent;
+    
+    res = Parent->Open2(nextStream, this, openArchiveCallback, level + 1);
+
+    if (res != S_OK)
+    {
+      Parent = NULL;
+      ParentStream.Release();
+      if (res == E_ABORT)
+        return res;
+      if (res != S_FALSE)
+      {
+        // we must show that error code
+      }
     }
-    Close();
-    return res;
   }
-  COM_TRY_END
+  {
+    const CHandler *p = this;
+    while (p->NeedParent())
+    {
+      p = p->Parent;
+      if (!p)
+      {
+        AddErrorMessage(L"Can't open parent VHD file:");
+        AddErrorMessage(Dyn.ParentName);
+        break;
+      }
+    }
+  }
+  return S_OK;
 }
 
-STDMETHODIMP CHandler::Close()
+
+void CHandler::CloseAtError()
 {
+  _phySize = 0;
   Bat.Clear();
   NumUsedBlocks = 0;
-  Parent = 0;
+  Parent = NULL;
   Stream.Release();
   ParentStream.Release();
-  return S_OK;
+  Dyn.Clear();
+  _errorMessage.Empty();
+  // _unexpectedEnd = false;
+  _imgExt = NULL;
 }
 
-STDMETHODIMP CHandler::GetNumberOfItems(UInt32 *numItems)
+STDMETHODIMP CHandler::Close()
 {
-  *numItems = 1;
+  CloseAtError();
   return S_OK;
 }
 
 STDMETHODIMP CHandler::GetProperty(UInt32 /* index */, PROPID propID, PROPVARIANT *value)
 {
   COM_TRY_BEGIN
-  NWindows::NCOM::CPropVariant prop;
+  NCOM::CPropVariant prop;
 
-  switch(propID)
+  switch (propID)
   {
     case kpidSize: prop = Footer.CurrentSize; break;
     case kpidPackSize: prop = GetPackSize(); break;
     case kpidCTime: VhdTimeToFileTime(Footer.CTime, prop); break;
+    case kpidExtension: prop = (_imgExt ? _imgExt : "img"); break;
+
     /*
     case kpidNumCyls: prop = Footer.NumCyls(); break;
     case kpidNumHeads: prop = Footer.NumHeads(); break;
     case kpidSectorsPerTrack: prop = Footer.NumSectorsPerTrack(); break;
     */
   }
+
   prop.Detach(value);
   return S_OK;
   COM_TRY_END
 }
 
-STDMETHODIMP CHandler::Extract(const UInt32 *indices, UInt32 numItems,
-    Int32 testMode, IArchiveExtractCallback *extractCallback)
-{
-  COM_TRY_BEGIN
-  if (numItems == 0)
-    return S_OK;
-  if (numItems != (UInt32)-1 && (numItems != 1 || indices[0] != 0))
-    return E_INVALIDARG;
-
-  RINOK(extractCallback->SetTotal(Footer.CurrentSize));
-  CMyComPtr<ISequentialOutStream> outStream;
-  Int32 askMode = testMode ?
-      NExtract::NAskMode::kTest :
-      NExtract::NAskMode::kExtract;
-  RINOK(extractCallback->GetStream(0, &outStream, askMode));
-  if (!testMode && !outStream)
-    return S_OK;
-  RINOK(extractCallback->PrepareOperation(askMode));
-
-  NCompress::CCopyCoder *copyCoderSpec = new NCompress::CCopyCoder();
-  CMyComPtr<ICompressCoder> copyCoder = copyCoderSpec;
-
-  CLocalProgress *lps = new CLocalProgress;
-  CMyComPtr<ICompressProgressInfo> progress = lps;
-  lps->Init(extractCallback, false);
-
-  int res = NExtract::NOperationResult::kDataError;
-  CMyComPtr<ISequentialInStream> inStream;
-  HRESULT hres = GetStream(0, &inStream);
-  if (hres == S_FALSE)
-    res = NExtract::NOperationResult::kUnSupportedMethod;
-  else
-  {
-    RINOK(hres);
-    HRESULT hres = copyCoder->Code(inStream, outStream, NULL, NULL, progress);
-    if (hres == S_OK)
-    {
-      if (copyCoderSpec->TotalSize == Footer.CurrentSize)
-        res = NExtract::NOperationResult::kOK;
-    }
-    else
-    {
-      if (hres != S_FALSE)
-      {
-        RINOK(hres);
-      }
-    }
-  }
-  outStream.Release();
-  return extractCallback->SetOperationResult(res);
-  COM_TRY_END
-}
 
 STDMETHODIMP CHandler::GetStream(UInt32 /* index */, ISequentialInStream **stream)
 {
@@ -715,7 +906,7 @@ STDMETHODIMP CHandler::GetStream(UInt32 /* index */, ISequentialInStream **strea
     *stream = streamTemp.Detach();
     return S_OK;
   }
-  if (!Footer.ThereIsDynamic() || !IsOK())
+  if (!Footer.ThereIsDynamic() || !AreParentsOK())
     return S_FALSE;
   CMyComPtr<ISequentialInStream> streamTemp = this;
   RINOK(InitAndSeek());
@@ -724,11 +915,11 @@ STDMETHODIMP CHandler::GetStream(UInt32 /* index */, ISequentialInStream **strea
   COM_TRY_END
 }
 
-static IInArchive *CreateArc() { return new CHandler; }
-
-static CArcInfo g_ArcInfo =
-  { L"VHD", L"vhd", L".mbr", 0xDC, { 'c', 'o', 'n', 'e', 'c', 't', 'i', 'x', 0, 0 }, 10, false, CreateArc, 0 };
-
-REGISTER_ARC(Vhd)
+REGISTER_ARC_I(
+  "VHD", "vhd", NULL, 0xDC,
+  kSignature,
+  0,
+  NArcInfoFlags::kUseGlobalOffset,
+  NULL)
 
 }}