seven-zip 1.4.2 → 1.7.0.rc1

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

@@ -0,0 +1,1618 @@
+// UefiHandler.cpp
+
+#include "StdAfx.h"
+
+// #define SHOW_DEBUG_INFO
+
+#ifdef SHOW_DEBUG_INFO
+#include <stdio.h>
+#endif
+
+#include "../../../C/7zCrc.h"
+#include "../../../C/Alloc.h"
+#include "../../../C/CpuArch.h"
+#include "../../../C/LzmaDec.h"
+
+#include "../../Common/ComTry.h"
+#include "../../Common/IntToString.h"
+#include "../../Common/MyBuffer.h"
+#include "../../Common/StringConvert.h"
+
+#include "../../Windows/PropVariantUtils.h"
+
+#include "../Common/ProgressUtils.h"
+#include "../Common/RegisterArc.h"
+#include "../Common/StreamObjects.h"
+#include "../Common/StreamUtils.h"
+
+#include "../Compress/CopyCoder.h"
+#include "../Compress/LzhDecoder.h"
+
+#ifdef SHOW_DEBUG_INFO
+#define PRF(x) x
+#else
+#define PRF(x)
+#endif
+
+#define Get16(p) GetUi16(p)
+#define Get32(p) GetUi32(p)
+#define Get64(p) GetUi64(p)
+#define Get24(p) (Get32(p) & 0xFFFFFF)
+
+namespace NArchive {
+namespace NUefi {
+
+static const size_t kBufTotalSizeMax = (1 << 29);
+static const unsigned kNumFilesMax = (1 << 18);
+static const unsigned kLevelMax = 64;
+
+static const unsigned kFvHeaderSize = 0x38;
+
+static const unsigned kGuidSize = 16;
+#define CAPSULE_SIGNATURE \
+  { 0xBD,0x86,0x66,0x3B,0x76,0x0D,0x30,0x40,0xB7,0x0E,0xB5,0x51,0x9E,0x2F,0xC5,0xA0 }
+static const Byte kCapsuleSig[kGuidSize] = CAPSULE_SIGNATURE;
+
+static const unsigned kFfsGuidOffset = 16;
+#define FFS_SIGNATURE \
+  { 0xD9,0x54,0x93,0x7A,0x68,0x04,0x4A,0x44,0x81,0xCE,0x0B,0xF6,0x17,0xD8,0x90,0xDF }
+static const Byte k_FFS_Guid[kGuidSize] = FFS_SIGNATURE;
+
+static const Byte k_MacFS_Guid[kGuidSize] =
+  { 0xAD,0xEE,0xAD,0x04,0xFF,0x61,0x31,0x4D,0xB6,0xBA,0x64,0xF8,0xBF,0x90,0x1F,0x5A };
+
+static const UInt32 kFvSignature = 0x4856465F; // "_FVH"
+
+static const Byte kGuids[][kGuidSize] =
+{
+  { 0xB0,0xCD,0x1B,0xFC,0x31,0x7D,0xAA,0x49,0x93,0x6A,0xA4,0x60,0x0D,0x9D,0xD0,0x83 },
+  { 0x2E,0x06,0xA0,0x1B,0x79,0xC7,0x82,0x45,0x85,0x66,0x33,0x6A,0xE8,0xF7,0x8F,0x09 },
+  { 0x25,0x4E,0x37,0x7E,0x01,0x8E,0xEE,0x4F,0x87,0xf2,0x39,0x0C,0x23,0xC6,0x06,0xCD },
+  { 0x97,0xE5,0x1B,0x16,0xC5,0xE9,0xDB,0x49,0xAE,0x50,0xC4,0x62,0xAB,0x54,0xEE,0xDA },
+  { 0xDB,0x7F,0xAD,0x77,0x2A,0xDF,0x02,0x43,0x88,0x98,0xC7,0x2E,0x4C,0xDB,0xD0,0xF4 },
+  { 0xAB,0x71,0xCF,0xF5,0x4B,0xB0,0x7E,0x4B,0x98,0x8A,0xD8,0xA0,0xD4,0x98,0xE6,0x92 },
+  { 0x91,0x45,0x53,0x7A,0xCE,0x37,0x81,0x48,0xB3,0xC9,0x71,0x38,0x14,0xF4,0x5D,0x6B },
+  { 0x84,0xE6,0x7A,0x36,0x5D,0x33,0x71,0x46,0xA1,0x6D,0x89,0x9D,0xBF,0xEA,0x6B,0x88 },
+  { 0x98,0x07,0x40,0x24,0x07,0x38,0x42,0x4A,0xB4,0x13,0xA1,0xEC,0xEE,0x20,0x5D,0xD8 },
+  { 0xEE,0xA2,0x3F,0x28,0x2C,0x53,0x4D,0x48,0x93,0x83,0x9F,0x93,0xB3,0x6F,0x0B,0x7E },
+  { 0x9B,0xD5,0xB8,0x98,0xBA,0xE8,0xEE,0x48,0x98,0xDD,0xC2,0x95,0x39,0x2F,0x1E,0xDB },
+  { 0x09,0x6D,0xE3,0xC3,0x94,0x82,0x97,0x4B,0xA8,0x57,0xD5,0x28,0x8F,0xE3,0x3E,0x28 },
+  { 0x18,0x88,0x53,0x4A,0xE0,0x5A,0xB2,0x4E,0xB2,0xEB,0x48,0x8B,0x23,0x65,0x70,0x22 }
+};
+
+
+static const char * const kGuidNames[] =
+{
+    "CRC"
+  , "VolumeTopFile"
+  , "ACPI"
+  , "ACPI2"
+  , "Main"
+  , "Intel32"
+  , "Intel64"
+  , "Intel32c"
+  , "Intel64c"
+  , "MacVolume"
+  , "MacUpdate.txt"
+  , "MacName"
+  , "Insyde"
+};
+
+enum
+{
+  kGuidIndex_CRC = 0
+};
+
+struct CSigExtPair
+{
+  const char *ext;
+  unsigned sigSize;
+  Byte sig[16];
+};
+
+static const CSigExtPair g_Sigs[] =
+{
+  { "bmp",  2, { 'B','M' } },
+  { "riff", 4, { 'R','I','F','F' } },
+  { "pe",   2, { 'M','Z'} },
+  { "gif",  6, { 'G','I','F','8','9', 'a' } },
+  { "png",  8, { 0x89,0x50,0x4E,0x47,0x0D,0x0A,0x1A,0x0A } },
+  { "jpg", 10, { 0xFF,0xD8,0xFF,0xE0,0x00,0x10,0x4A,0x46,0x49,0x46 } },
+  { "rom",  2, { 0x55,0xAA } }
+};
+
+enum
+{
+  kSig_BMP,
+  kSig_RIFF,
+  kSig_PE
+};
+
+static const char *FindExt(const Byte *p, size_t size)
+{
+  unsigned i;
+  for (i = 0; i < ARRAY_SIZE(g_Sigs); i++)
+  {
+    const CSigExtPair &pair = g_Sigs[i];
+    if (size >= pair.sigSize)
+      if (memcmp(p, pair.sig, pair.sigSize) == 0)
+        break;
+  }
+  if (i == ARRAY_SIZE(g_Sigs))
+    return NULL;
+  switch (i)
+  {
+    case kSig_BMP:
+      if (GetUi32(p + 2) > size || GetUi32(p + 0xA) > size)
+        return NULL;
+      break;
+    case kSig_RIFF:
+      if (GetUi32(p + 8) == 0x45564157 || GetUi32(p + 0xC) == 0x20746D66 )
+        return "wav";
+      break;
+    case kSig_PE:
+    {
+      if (size < 512)
+        return NULL;
+      UInt32 peOffset = GetUi32(p + 0x3C);
+      if (peOffset >= 0x1000 || peOffset + 512 > size || (peOffset & 7) != 0)
+        return NULL;
+      if (GetUi32(p + peOffset) != 0x00004550)
+        return NULL;
+      break;
+    }
+  }
+  return g_Sigs[i].ext;
+}
+
+static bool AreGuidsEq(const Byte *p1, const Byte *p2)
+{
+  return memcmp(p1, p2, kGuidSize) == 0;
+}
+
+static int FindGuid(const Byte *p)
+{
+  for (unsigned i = 0; i < ARRAY_SIZE(kGuids); i++)
+    if (AreGuidsEq(p, kGuids[i]))
+      return i;
+  return -1;
+}
+ 
+static bool IsFfs(const Byte *p)
+{
+  return (Get32(p + 0x28) == kFvSignature && AreGuidsEq(p + kFfsGuidOffset, k_FFS_Guid));
+}
+
+#define FVB_ERASE_POLARITY  (1 << 11)
+
+/*
+static const CUInt32PCharPair g_FV_Attribs[] =
+{
+  {  0, "ReadDisabledCap" },
+  {  1, "ReadEnabledCap" },
+  {  2, "ReadEnabled" },
+  {  3, "WriteDisabledCap" },
+  {  4, "WriteEnabledCap" },
+  {  5, "WriteEnabled" },
+  {  6, "LockCap" },
+  {  7, "Locked" },
+
+  {  9, "StickyWrite" },
+  { 10, "MemoryMapped" },
+  { 11, "ErasePolarity" },
+  
+  { 12, "ReadLockCap" },
+  { 13, "WriteLockCap" },
+  { 14, "WriteLockCap" }
+};
+*/
+
+enum
+{
+  FV_FILETYPE_ALL,
+  FV_FILETYPE_RAW,
+  FV_FILETYPE_FREEFORM,
+  FV_FILETYPE_SECURITY_CORE,
+  FV_FILETYPE_PEI_CORE,
+  FV_FILETYPE_DXE_CORE,
+  FV_FILETYPE_PEIM,
+  FV_FILETYPE_DRIVER,
+  FV_FILETYPE_COMBINED_PEIM_DRIVER,
+  FV_FILETYPE_APPLICATION,
+  // The value 0x0A is reserved and should not be used
+  FV_FILETYPE_FIRMWARE_VOLUME_IMAGE = 0x0B,
+  // types 0xF0 - 0xFF are FFS file types
+  FV_FILETYPE_FFS_PAD = 0xF0
+};
+
+static const char *g_FileTypes[] =
+{
+    "ALL"
+  , "RAW"
+  , "FREEFORM"
+  , "SECURITY_CORE"
+  , "PEI_CORE"
+  , "DXE_CORE"
+  , "PEIM"
+  , "DRIVER"
+  , "COMBINED_PEIM_DRIVER"
+  , "APPLICATION"
+  , "0xA"
+  , "VOLUME"
+};
+
+// typedef Byte FFS_FILE_ATTRIBUTES;
+// FFS File Attributes
+#define FFS_ATTRIB_TAIL_PRESENT 0x01
+// #define FFS_ATTRIB_RECOVERY 0x02
+// #define FFS_ATTRIB_HEADER_EXTENSION 0x04
+// #define FFS_ATTRIB_DATA_ALIGNMENT 0x38
+#define FFS_ATTRIB_CHECKSUM 0x40
+
+static const CUInt32PCharPair g_FFS_FILE_ATTRIBUTES[] =
+{
+  { 0, "" /* "TAIL" */ },
+  { 1, "RECOVERY" },
+  // { 2, "HEADER_EXTENSION" }, // reserved for future
+  { 6, "" /* "CHECKSUM" */ }
+};
+
+// static const Byte g_Allignment[8] = { 3, 4, 7, 9, 10, 12, 15, 16 };
+
+// typedef Byte FFS_FILE_STATE;
+
+// Look also FVB_ERASE_POLARITY.
+// Lower-order State bits are superceded by higher-order State bits.
+
+// #define FILE_HEADER_CONSTRUCTION  0x01
+// #define FILE_HEADER_VALID         0x02
+#define FILE_DATA_VALID           0x04
+// #define FILE_MARKED_FOR_UPDATE    0x08
+// #define FILE_DELETED              0x10
+// #define FILE_HEADER_INVALID       0x20
+
+// SECTION_TYPE
+
+#define SECTION_ALL 0x00
+
+#define SECTION_COMPRESSION  0x01
+#define SECTION_GUID_DEFINED 0x02
+
+// Leaf section Type values
+#define SECTION_PE32      0x10
+#define SECTION_PIC       0x11
+#define SECTION_TE        0x12
+#define SECTION_DXE_DEPEX 0x13
+#define SECTION_VERSION   0x14
+#define SECTION_USER_INTERFACE 0x15
+#define SECTION_COMPATIBILITY16 0x16
+#define SECTION_FIRMWARE_VOLUME_IMAGE 0x17
+#define SECTION_FREEFORM_SUBTYPE_GUID 0x18
+#define SECTION_RAW       0x19
+#define SECTION_PEI_DEPEX 0x1B
+
+
+// #define GUIDED_SECTION_PROCESSING_REQUIRED 0x01
+// #define GUIDED_SECTION_AUTH_STATUS_VALID 0x02
+
+static const CUInt32PCharPair g_GUIDED_SECTION_ATTRIBUTES[] =
+{
+  { 0, "PROCESSING_REQUIRED" },
+  { 1, "AUTH" }
+};
+
+static const CUInt32PCharPair g_SECTION_TYPE[] =
+{
+  { 0x01, "COMPRESSION" },
+  { 0x02, "GUID" },
+  { 0x10, "efi" },
+  { 0x11, "PIC" },
+  { 0x12, "te" },
+  { 0x13, "DXE_DEPEX" },
+  { 0x14, "VERSION" },
+  { 0x15, "USER_INTERFACE" },
+  { 0x16, "COMPATIBILITY16" },
+  { 0x17, "VOLUME" },
+  { 0x18, "FREEFORM_SUBTYPE_GUID" },
+  { 0x19, "raw" },
+  { 0x1B, "PEI_DEPEX" }
+};
+
+#define COMPRESSION_TYPE_NONE 0
+#define COMPRESSION_TYPE_LZH  1
+#define COMPRESSION_TYPE_LZMA 2
+
+static const char * const g_Methods[] =
+{
+    "COPY"
+  , "LZH"
+  , "LZMA"
+};
+
+static AString UInt32ToString(UInt32 val)
+{
+  char sz[16];
+  ConvertUInt32ToString(val, sz);
+  return sz;
+}
+
+static void ConvertByteToHex(unsigned value, char *s)
+{
+  for (int i = 0; i < 2; i++)
+  {
+    unsigned t = value & 0xF;
+    value >>= 4;
+    s[1 - i] = (char)((t < 10) ? ('0' + t) : ('A' + (t - 10)));
+  }
+}
+
+static AString GuidToString(const Byte *p, bool full)
+{
+  char s[16 * 2 + 8];
+  int i;
+  for (i = 0; i < 4; i++)
+    ConvertByteToHex(p[3 - i], s + i * 2);
+  s[8] = 0;
+
+  if (full)
+  {
+    s[8] = '-';
+    for (i = 4; i < kGuidSize; i++)
+      ConvertByteToHex(p[i], s + 1 + i * 2);
+    s[32 + 1] = 0;
+  }
+  return s;
+}
+
+static const char * const kExpressionCommands[] =
+{
+  "BEFORE", "AFTER", "PUSH", "AND", "OR", "NOT", "TRUE", "FALSE", "END", "SOR"
+};
+
+static bool ParseDepedencyExpression(const Byte *p, UInt32 size, AString &res)
+{
+  res.Empty();
+  for (UInt32 i = 0; i < size;)
+  {
+    unsigned command = p[i++];
+    if (command > ARRAY_SIZE(kExpressionCommands))
+      return false;
+    res += kExpressionCommands[command];
+    if (command < 3)
+    {
+      if (i + kGuidSize > size)
+        return false;
+      res.Add_Space();
+      res += GuidToString(p + i, false);
+      i += kGuidSize;
+    }
+    res += "; ";
+  }
+  return true;
+}
+
+static bool ParseUtf16zString(const Byte *p, UInt32 size, UString &res)
+{
+  if ((size & 1) != 0)
+    return false;
+  res.Empty();
+  UInt32 i;
+  for (i = 0; i < size; i += 2)
+  {
+    wchar_t c = Get16(p + i);
+    if (c == 0)
+      break;
+    res += c;
+  }
+  return (i == size - 2);
+}
+
+static bool ParseUtf16zString2(const Byte *p, UInt32 size, AString &res)
+{
+  UString s;
+  if (!ParseUtf16zString(p, size, s))
+    return false;
+  res = UnicodeStringToMultiByte(s);
+  return true;
+}
+
+#define FLAGS_TO_STRING(pairs, value) FlagsToString(pairs, ARRAY_SIZE(pairs), value)
+#define TYPE_TO_STRING(table, value) TypeToString(table, ARRAY_SIZE(table), value)
+#define TYPE_PAIR_TO_STRING(table, value) TypePairToString(table, ARRAY_SIZE(table), value)
+
+static const UInt32 kFileHeaderSize = 24;
+
+static void AddSpaceAndString(AString &res, const AString &newString)
+{
+  if (!newString.IsEmpty())
+  {
+    res.Add_Space_if_NotEmpty();
+    res += newString;
+  }
+}
+
+class CFfsFileHeader
+{
+  Byte CheckHeader;
+  Byte CheckFile;
+  Byte Attrib;
+  Byte State;
+
+  UInt16 GetTailReference() const { return (UInt16)(CheckHeader | ((UInt16)CheckFile << 8)); }
+  UInt32 GetTailSize() const { return IsThereTail() ? 2 : 0; }
+  bool IsThereFileChecksum() const { return (Attrib & FFS_ATTRIB_CHECKSUM) != 0; }
+  bool IsThereTail() const { return (Attrib & FFS_ATTRIB_TAIL_PRESENT) != 0; }
+public:
+  Byte GuidName[kGuidSize];
+  Byte Type;
+  UInt32 Size;
+  
+  bool Parse(const Byte *p)
+  {
+    int i;
+    for (i = 0; i < kFileHeaderSize; i++)
+      if (p[i] != 0xFF)
+        break;
+    if (i == kFileHeaderSize)
+      return false;
+    memcpy(GuidName, p, kGuidSize);
+    CheckHeader = p[0x10];
+    CheckFile = p[0x11];
+    Type = p[0x12];
+    Attrib = p[0x13];
+    Size = Get24(p + 0x14);
+    State = p[0x17];
+    return true;
+  }
+
+  UInt32 GetDataSize() const { return Size - kFileHeaderSize - GetTailSize(); }
+  UInt32 GetDataSize2(UInt32 rem) const { return rem - kFileHeaderSize - GetTailSize(); }
+
+  bool Check(const Byte *p, UInt32 size)
+  {
+    if (Size > size)
+      return false;
+    UInt32 tailSize = GetTailSize();
+    if (Size < kFileHeaderSize + tailSize)
+      return false;
+    
+    {
+      unsigned checkSum = 0;
+      for (UInt32 i = 0; i < kFileHeaderSize; i++)
+        checkSum += p[i];
+      checkSum -= p[0x17];
+      checkSum -= p[0x11];
+      if ((Byte)checkSum != 0)
+        return false;
+    }
+    
+    if (IsThereFileChecksum())
+    {
+      unsigned checkSum = 0;
+      UInt32 checkSize = Size - tailSize;
+      for (UInt32 i = 0; i < checkSize; i++)
+        checkSum += p[i];
+      checkSum -= p[0x17];
+      if ((Byte)checkSum != 0)
+        return false;
+    }
+    
+    if (IsThereTail())
+      if (GetTailReference() != (UInt16)~Get16(p + Size - 2))
+        return false;
+
+    int polarity = 0;
+    int i;
+    for (i = 5; i >= 0; i--)
+      if (((State >> i) & 1) == polarity)
+      {
+        // AddSpaceAndString(s, g_FFS_FILE_STATE_Flags[i]);
+        if ((1 << i) != FILE_DATA_VALID)
+          return false;
+        break;
+      }
+    if (i < 0)
+      return false;
+
+    return true;
+  }
+
+  AString GetCharacts() const
+  {
+    AString s;
+    if (Type == FV_FILETYPE_FFS_PAD)
+      s += "PAD";
+    else
+      s += TYPE_TO_STRING(g_FileTypes, Type);
+    AddSpaceAndString(s, FLAGS_TO_STRING(g_FFS_FILE_ATTRIBUTES, Attrib & 0xC7));
+    /*
+    int align = (Attrib >> 3) & 7;
+    if (align != 0)
+    {
+      s += " Align:";
+      s += UInt32ToString((UInt32)1 << g_Allignment[align]);
+    }
+    */
+    return s;
+  }
+};
+
+#define G32(_offs_, dest) dest = Get32(p + (_offs_));
+
+struct CCapsuleHeader
+{
+  UInt32 HeaderSize;
+  UInt32 Flags;
+  UInt32 CapsuleImageSize;
+  UInt32 SequenceNumber;
+  // Guid InstanceId;
+  UInt32 OffsetToSplitInformation;
+  UInt32 OffsetToCapsuleBody;
+  UInt32 OffsetToOemDefinedHeader;
+  UInt32 OffsetToAuthorInformation;
+  UInt32 OffsetToRevisionInformation;
+  UInt32 OffsetToShortDescription;
+  UInt32 OffsetToLongDescription;
+  UInt32 OffsetToApplicableDevices;
+
+  void Clear() { memset(this, 0, sizeof(*this)); }
+
+  void Parse(const Byte *p)
+  {
+    G32(0x10, HeaderSize);
+    G32(0x14, Flags);
+    G32(0x18, CapsuleImageSize);
+    G32(0x1C, SequenceNumber);
+    G32(0x30, OffsetToSplitInformation);
+    G32(0x34, OffsetToCapsuleBody);
+    G32(0x38, OffsetToOemDefinedHeader);
+    G32(0x3C, OffsetToAuthorInformation);
+    G32(0x40, OffsetToRevisionInformation);
+    G32(0x44, OffsetToShortDescription);
+    G32(0x48, OffsetToLongDescription);
+    G32(0x4C, OffsetToApplicableDevices);
+  }
+};
+
+struct CItem
+{
+  AString Name;
+  AString Characts;
+  int Parent;
+  int Method;
+  int NameIndex;
+  int NumChilds;
+  bool IsDir;
+  bool Skip;
+  bool ThereAreSubDirs;
+  bool ThereIsUniqueName;
+  bool KeepName;
+
+  int BufIndex;
+  UInt32 Offset;
+  UInt32 Size;
+
+  CItem(): Parent(-1), Method(-1), NameIndex(-1), NumChilds(0),
+      IsDir(false), Skip(false), ThereAreSubDirs(false), ThereIsUniqueName(false), KeepName(true) {}
+  void SetGuid(const Byte *guidName, bool full = false);
+  AString GetName(int numChildsInParent) const;
+};
+
+void CItem::SetGuid(const Byte *guidName, bool full)
+{
+  ThereIsUniqueName = true;
+  int index = FindGuid(guidName);
+  if (index >= 0)
+    Name = kGuidNames[(unsigned)index];
+  else
+    Name = GuidToString(guidName, full);
+}
+
+AString CItem::GetName(int numChildsInParent) const
+{
+  if (numChildsInParent <= 1 || NameIndex < 0)
+    return Name;
+  char sz[32];
+  char sz2[32];
+  ConvertUInt32ToString(NameIndex, sz);
+  ConvertUInt32ToString(numChildsInParent - 1, sz2);
+  unsigned numZeros = (unsigned)strlen(sz2) - (unsigned)strlen(sz);
+  AString res;
+  for (unsigned i = 0; i < numZeros; i++)
+    res += '0';
+  return res + (AString)sz + '.' + Name;
+}
+
+struct CItem2
+{
+  AString Name;
+  AString Characts;
+  int MainIndex;
+  int Parent;
+
+  CItem2(): Parent(-1) {}
+};
+
+class CHandler:
+  public IInArchive,
+  public IInArchiveGetStream,
+  public CMyUnknownImp
+{
+  CObjectVector<CItem> _items;
+  CObjectVector<CItem2> _items2;
+  CObjectVector<CByteBuffer> _bufs;
+  UString _comment;
+  UInt32 _methodsMask;
+  bool _capsuleMode;
+
+  size_t _totalBufsSize;
+  CCapsuleHeader _h;
+  UInt64 _phySize;
+
+  void AddCommentString(const wchar_t *name, UInt32 pos);
+  int AddItem(const CItem &item);
+  int AddFileItemWithIndex(CItem &item);
+  int AddDirItem(CItem &item);
+  unsigned AddBuf(size_t size);
+
+  HRESULT ParseSections(int bufIndex, UInt32 pos, UInt32 size, int parent, int method, unsigned level);
+  HRESULT ParseVolume(int bufIndex, UInt32 posBase,
+      UInt32 exactSize, UInt32 limitSize,
+      int parent, int method, int level);
+  HRESULT OpenCapsule(IInStream *stream);
+  HRESULT OpenFv(IInStream *stream, const UInt64 *maxCheckStartPosition, IArchiveOpenCallback *callback);
+  HRESULT Open2(IInStream *stream, const UInt64 *maxCheckStartPosition, IArchiveOpenCallback *callback);
+public:
+  CHandler(bool capsuleMode): _capsuleMode(capsuleMode) {}
+  MY_UNKNOWN_IMP2(IInArchive, IInArchiveGetStream)
+  INTERFACE_IInArchive(;)
+  STDMETHOD(GetStream)(UInt32 index, ISequentialInStream **stream);
+};
+
+static const Byte kProps[] =
+{
+  kpidPath,
+  kpidIsDir,
+  kpidSize,
+  kpidMethod,
+  kpidCharacts
+};
+
+static const Byte kArcProps[] =
+{
+  kpidComment,
+  kpidMethod,
+  kpidCharacts
+};
+
+IMP_IInArchive_Props
+IMP_IInArchive_ArcProps
+
+STDMETHODIMP CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value)
+{
+  COM_TRY_BEGIN
+  NWindows::NCOM::CPropVariant prop;
+  const CItem2 &item2 = _items2[index];
+  const CItem &item = _items[item2.MainIndex];
+  switch (propID)
+  {
+    case kpidPath:
+    {
+      AString path = item2.Name;
+      int cur = item2.Parent;
+      while (cur >= 0)
+      {
+        const CItem2 &item3 = _items2[cur];
+        path.InsertAtFront(CHAR_PATH_SEPARATOR);
+        path.Insert(0, item3.Name);
+        cur = item3.Parent;
+      }
+      prop = path;
+      break;
+    }
+    case kpidIsDir: prop = item.IsDir; break;
+    case kpidMethod: if (item.Method >= 0) prop = g_Methods[(unsigned)item.Method]; break;
+    case kpidCharacts: if (!item2.Characts.IsEmpty()) prop = item2.Characts; break;
+    case kpidSize: if (!item.IsDir) prop = (UInt64)item.Size; break;
+  }
+  prop.Detach(value);
+  return S_OK;
+  COM_TRY_END
+}
+
+void CHandler::AddCommentString(const wchar_t *name, UInt32 pos)
+{
+  UString s;
+  const Byte *buf = _bufs[0];
+  if (pos < _h.HeaderSize)
+    return;
+  for (UInt32 i = pos;; i += 2)
+  {
+    if (s.Len() > (1 << 16) || i >= _h.OffsetToCapsuleBody)
+      return;
+    wchar_t c = Get16(buf + i);
+    if (c == 0)
+    {
+      i += 2;
+      if (i >= _h.OffsetToCapsuleBody)
+        return;
+      c = Get16(buf + i);
+      if (c == 0)
+        break;
+      s.Add_LF();
+    }
+    s += c;
+  }
+  if (s.IsEmpty())
+    return;
+  _comment.Add_LF();
+  _comment += name;
+  _comment.AddAscii(": ");
+  _comment += s;
+}
+
+STDMETHODIMP CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value)
+{
+  COM_TRY_BEGIN
+  NWindows::NCOM::CPropVariant prop;
+  switch (propID)
+  {
+    case kpidMethod:
+    {
+      AString s;
+      for (unsigned i = 0; i < 32; i++)
+        if ((_methodsMask & ((UInt32)1 << i)) != 0)
+          AddSpaceAndString(s, g_Methods[i]);
+      if (!s.IsEmpty())
+        prop = s;
+      break;
+    }
+    case kpidComment: if (!_comment.IsEmpty()) prop = _comment; break;
+    case kpidPhySize: prop = (UInt64)_phySize; break;
+  }
+  prop.Detach(value);
+  return S_OK;
+  COM_TRY_END
+}
+
+#ifdef SHOW_DEBUG_INFO
+static void PrintLevel(int level)
+{
+  PRF(printf("\n"));
+  for (int i = 0; i < level; i++)
+    PRF(printf("  "));
+}
+static void MyPrint(UInt32 posBase, UInt32 size, int level, const char *name)
+{
+  PrintLevel(level);
+  PRF(printf("%s, pos = %6x, size = %6d", name, posBase, size));
+}
+#else
+#define PrintLevel(level)
+#define MyPrint(posBase, size, level, name)
+#endif
+
+
+
+int CHandler::AddItem(const CItem &item)
+{
+  if (_items.Size() >= kNumFilesMax)
+    throw 2;
+  return _items.Add(item);
+}
+
+int CHandler::AddFileItemWithIndex(CItem &item)
+{
+  int nameIndex = _items.Size();
+  if (item.Parent >= 0)
+    nameIndex = _items[item.Parent].NumChilds++;
+  item.NameIndex = nameIndex;
+  return AddItem(item);
+}
+
+int CHandler::AddDirItem(CItem &item)
+{
+  if (item.Parent >= 0)
+    _items[item.Parent].ThereAreSubDirs = true;
+  item.IsDir = true;
+  item.Size = 0;
+  return AddItem(item);
+}
+
+unsigned CHandler::AddBuf(size_t size)
+{
+  if (size > kBufTotalSizeMax - _totalBufsSize)
+    throw 1;
+  _totalBufsSize += size;
+  unsigned index = _bufs.Size();
+  _bufs.AddNew().Alloc(size);
+  return index;
+}
+
+HRESULT CHandler::ParseSections(int bufIndex, UInt32 posBase, UInt32 size, int parent, int method, unsigned level)
+{
+  if (level > kLevelMax)
+    return S_FALSE;
+  MyPrint(posBase, size, level, "Sections");
+  level++;
+  const Byte *bufData = _bufs[bufIndex];
+  UInt32 pos = 0;
+  for (;;)
+  {
+    if (size == pos)
+      return S_OK;
+    PrintLevel(level);
+    PRF(printf("%s, pos = %6x", "Sect", pos));
+    pos = (pos + 3) & ~(UInt32)3;
+    if (pos > size)
+      return S_FALSE;
+    UInt32 rem = size - pos;
+    if (rem == 0)
+      return S_OK;
+    if (rem < 4)
+      return S_FALSE;
+    const Byte *p = bufData + posBase + pos;
+    UInt32 sectSize = Get24(p);
+    if (sectSize > rem || sectSize < 4)
+      return S_FALSE;
+    
+    Byte type = p[3];
+    PrintLevel(level);
+    PRF(printf("%s, type = %2x, pos = %6x, size = %6d", "Sect", type, pos, sectSize));
+    CItem item;
+    item.Method = method;
+    item.BufIndex = bufIndex;
+    item.Parent = parent;
+    item.Offset = posBase + pos + 4;
+    UInt32 sectDataSize = sectSize - 4;
+    item.Size = sectDataSize;
+    item.Name = TYPE_PAIR_TO_STRING(g_SECTION_TYPE, type);
+
+    if (type == SECTION_COMPRESSION)
+    {
+      if (sectSize < 4 + 5)
+        return S_FALSE;
+      UInt32 uncompressedSize = Get32(p + 4);
+      Byte compressionType = p[8];
+
+      UInt32 newSectSize = sectSize - 9;
+      UInt32 newOffset = posBase + pos + 9;
+      const Byte *pStart = p + 9;
+
+      item.KeepName = false;
+      if (compressionType > 2)
+      {
+        // AddFileItemWithIndex(item);
+        return S_FALSE;
+      }
+      else
+      {
+        item.Name = g_Methods[compressionType];
+        // int parent = AddDirItem(item);
+        if (compressionType == COMPRESSION_TYPE_NONE)
+        {
+          RINOK(ParseSections(bufIndex, newOffset, newSectSize, parent, method, level));
+        }
+        else if (compressionType == COMPRESSION_TYPE_LZH)
+        {
+          unsigned newBufIndex = AddBuf(uncompressedSize);
+          CByteBuffer &buf = _bufs[newBufIndex];
+
+          NCompress::NLzh::NDecoder::CCoder *lzhDecoderSpec = 0;
+          CMyComPtr<ICompressCoder> lzhDecoder;
+ 
+          lzhDecoderSpec = new NCompress::NLzh::NDecoder::CCoder;
+          lzhDecoder = lzhDecoderSpec;
+
+          {
+            const Byte *src = pStart;
+            if (newSectSize < 8)
+              return S_FALSE;
+            UInt32 packSize = Get32(src);
+            UInt32 unpackSize = Get32(src + 4);
+            if (uncompressedSize != unpackSize || newSectSize - 8 != packSize)
+              return S_FALSE;
+            if (packSize < 1)
+              return S_FALSE;
+            packSize--;
+            src += 8;
+            if (src[packSize] != 0)
+              return S_FALSE;
+
+            CBufInStream *inStreamSpec = new CBufInStream;
+            CMyComPtr<IInStream> inStream = inStreamSpec;
+            inStreamSpec->Init(src, packSize);
+
+            CBufPtrSeqOutStream *outStreamSpec = new CBufPtrSeqOutStream;
+            CMyComPtr<ISequentialOutStream> outStream = outStreamSpec;
+            outStreamSpec->Init(buf, uncompressedSize);
+
+            UInt64 uncompressedSize64 = uncompressedSize;
+            lzhDecoderSpec->FinishMode = true;
+            /*
+              EFI 1.1 probably used small dictionary and (pbit = 4) in LZH. We don't support such archives.
+              New version of compression code (named Tiano) uses LZH with (1 << 19) dictionary.
+              But maybe LZH decoder in UEFI decoder supports larger than (1 << 19) dictionary.
+            */
+            lzhDecoderSpec->SetDictSize(1 << 19);
+            
+            HRESULT res = lzhDecoder->Code(inStream, outStream, NULL, &uncompressedSize64, NULL);
+            if (res != S_OK)
+              return res;
+            
+            if (lzhDecoderSpec->GetInputProcessedSize() != packSize)
+              return S_FALSE;
+          }
+
+          RINOK(ParseSections(newBufIndex, 0, uncompressedSize, parent, compressionType, level));
+        }
+        else
+        {
+          if (newSectSize < 4 + 5 + 8)
+            return S_FALSE;
+          unsigned addSize = 4;
+          if (pStart[0] == 0x5d && pStart[1] == 0 && pStart[2] == 0 && pStart[3] == 0x80 && pStart[4] == 0)
+          {
+            addSize = 0;
+            // some archives have such header
+          }
+          else
+          {
+            // normal BIOS contains uncompressed size here
+            // UInt32 uncompressedSize2 = Get24(pStart);
+            // Byte firstSectType = p[9 + 3];
+            // firstSectType can be 0 in some archives
+          }
+          pStart += addSize;
+          UInt64 lzmaUncompressedSize = Get64(pStart + 5);
+          if (lzmaUncompressedSize > (1 << 30))
+            return S_FALSE;
+          if (lzmaUncompressedSize < uncompressedSize)
+            return S_FALSE;
+          SizeT destLen = (SizeT)lzmaUncompressedSize;
+          unsigned newBufIndex = AddBuf((size_t)lzmaUncompressedSize);
+          CByteBuffer &buf = _bufs[newBufIndex];
+          ELzmaStatus status;
+          SizeT srcLen = newSectSize - (addSize + 5 + 8);
+          SizeT srcLen2 = srcLen;
+          SRes res = LzmaDecode(buf, &destLen, pStart + 13, &srcLen,
+              pStart, 5, LZMA_FINISH_END, &status, &g_Alloc);
+          if (res != 0)
+            return S_FALSE;
+          if (srcLen != srcLen2 || destLen != lzmaUncompressedSize || (
+              status != LZMA_STATUS_FINISHED_WITH_MARK &&
+              status != LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK))
+            return S_FALSE;
+          RINOK(ParseSections(newBufIndex, 0, (UInt32)lzmaUncompressedSize, parent, compressionType, level));
+        }
+        _methodsMask |= (1 << compressionType);
+      }
+    }
+    else if (type == SECTION_GUID_DEFINED)
+    {
+      const unsigned kHeaderSize = 4 + kGuidSize + 4;
+      if (sectSize < kHeaderSize)
+        return S_FALSE;
+      item.SetGuid(p + 4);
+      UInt32 dataOffset = Get16(p + 4 + kGuidSize);
+      UInt32 attrib = Get16(p + 4 + kGuidSize + 2);
+      if (dataOffset > sectSize || dataOffset < kHeaderSize)
+        return S_FALSE;
+      UInt32 newSectSize = sectSize - dataOffset;
+      item.Size = newSectSize;
+      UInt32 newOffset = posBase + pos + dataOffset;
+      item.Offset = newOffset;
+      UInt32 propsSize = dataOffset - kHeaderSize;
+      bool needDir = true;
+      AddSpaceAndString(item.Characts, FLAGS_TO_STRING(g_GUIDED_SECTION_ATTRIBUTES, attrib));
+      if (AreGuidsEq(p + 0x4, kGuids[kGuidIndex_CRC]) && propsSize == 4)
+      {
+        needDir = false;
+        item.KeepName = false;
+        if (CrcCalc(bufData + newOffset, newSectSize) != Get32(p + kHeaderSize))
+          return S_FALSE;
+      }
+      else
+      {
+        if (propsSize != 0)
+        {
+          CItem item2 = item;
+          item2.Name += ".prop";
+          item2.Size = propsSize;
+          item2.Offset = posBase + pos + kHeaderSize;
+          AddItem(item2);
+        }
+      }
+      int newParent = parent;
+      if (needDir)
+        newParent = AddDirItem(item);
+      RINOK(ParseSections(bufIndex, newOffset, newSectSize, newParent, method, level));
+    }
+    else if (type == SECTION_FIRMWARE_VOLUME_IMAGE)
+    {
+      item.KeepName = false;
+      int newParent = AddDirItem(item);
+      RINOK(ParseVolume(bufIndex, posBase + pos + 4,
+          sectSize - 4,
+          sectSize - 4,
+          newParent, method, level));
+    }
+    else
+    {
+      bool needAdd = true;
+      switch (type)
+      {
+        case SECTION_RAW:
+        {
+          const UInt32 kInsydeOffset = 12;
+          if (sectDataSize >= kFvHeaderSize + kInsydeOffset)
+          {
+            if (IsFfs(p + 4 + kInsydeOffset) &&
+                sectDataSize - kInsydeOffset == Get64(p + 4 + kInsydeOffset + 0x20))
+            {
+              needAdd = false;
+              item.Name = "vol";
+              int newParent = AddDirItem(item);
+              RINOK(ParseVolume(bufIndex, posBase + pos + 4 + kInsydeOffset,
+                  sectDataSize - kInsydeOffset,
+                  sectDataSize - kInsydeOffset,
+                  newParent, method, level));
+            }
+            
+            if (needAdd)
+            {
+              const char *ext = FindExt(p + 4, sectDataSize);
+              if (ext)
+                item.Name = ext;
+            }
+          }
+          break;
+        }
+        case SECTION_DXE_DEPEX:
+        case SECTION_PEI_DEPEX:
+        {
+          AString s;
+          if (ParseDepedencyExpression(p + 4, sectDataSize, s))
+          {
+            if (s.Len() < (1 << 9))
+            {
+              s.InsertAtFront('[');
+              s += ']';
+              AddSpaceAndString(_items[item.Parent].Characts, s);
+              needAdd = false;
+            }
+            else
+            {
+              item.BufIndex = AddBuf(s.Len());
+              CByteBuffer &buf0 = _bufs[item.BufIndex];
+              if (s.Len() != 0)
+                memcpy(buf0, s, s.Len());
+              item.Offset = 0;
+              item.Size = s.Len();
+            }
+          }
+          break;
+        }
+        case SECTION_VERSION:
+        {
+          if (sectDataSize > 2)
+          {
+            AString s;
+            if (ParseUtf16zString2(p + 6, sectDataSize - 2, s))
+            {
+              AString s2 = "ver:";
+              s2 += UInt32ToString(Get16(p + 4));
+              s2.Add_Space();
+              s2 += s;
+              AddSpaceAndString(_items[item.Parent].Characts, s2);
+              needAdd = false;
+            }
+          }
+          break;
+        }
+        case SECTION_USER_INTERFACE:
+        {
+          AString s;
+          if (ParseUtf16zString2(p + 4, sectDataSize, s))
+          {
+            _items[parent].Name = s;
+            needAdd = false;
+          }
+          break;
+        }
+        case SECTION_FREEFORM_SUBTYPE_GUID:
+        {
+          if (sectDataSize >= kGuidSize)
+          {
+            item.SetGuid(p + 4);
+            item.Size = sectDataSize - kGuidSize;
+            item.Offset = posBase + pos + 4 + kGuidSize;
+          }
+          break;
+        }
+      }
+    
+      if (needAdd)
+        AddFileItemWithIndex(item);
+    }
+    pos += sectSize;
+  }
+}
+
+static UInt32 Count_FF_Bytes(const Byte *p, UInt32 size)
+{
+  UInt32 i;
+  for (i = 0; i < size && p[i] == 0xFF; i++);
+  return i;
+}
+
+static bool Is_FF_Stream(const Byte *p, UInt32 size)
+{
+  return (Count_FF_Bytes(p, size) == size);
+}
+
+struct CVolFfsHeader
+{
+  UInt32 HeaderLen;
+  UInt64 VolSize;
+  
+  bool Parse(const Byte *p);
+};
+
+bool CVolFfsHeader::Parse(const Byte *p)
+{
+  if (Get32(p + 0x28) != kFvSignature)
+    return false;
+
+  UInt32 attribs = Get32(p + 0x2C);
+  if ((attribs & FVB_ERASE_POLARITY) == 0)
+    return false;
+  VolSize = Get64(p + 0x20);
+  HeaderLen = Get16(p + 0x30);
+  if (HeaderLen < kFvHeaderSize || (HeaderLen & 0x7) != 0 || VolSize < HeaderLen)
+    return false;
+  return true;
+};
+
+HRESULT CHandler::ParseVolume(
+    int bufIndex, UInt32 posBase,
+    UInt32 exactSize, UInt32 limitSize,
+    int parent, int method, int level)
+{
+  if (level > kLevelMax)
+    return S_FALSE;
+  MyPrint(posBase, size, level, "Volume");
+  level++;
+  if (exactSize < kFvHeaderSize)
+    return S_FALSE;
+  const Byte *p = _bufs[bufIndex] + posBase;
+  // first 16 bytes must be zeros, but they are not zeros sometimes.
+  if (!AreGuidsEq(p + kFfsGuidOffset, k_FFS_Guid) &&
+      !AreGuidsEq(p + kFfsGuidOffset, k_MacFS_Guid))
+  {
+    CItem item;
+    item.Method = method;
+    item.BufIndex = bufIndex;
+    item.Parent = parent;
+    item.Offset = posBase;
+    item.Size = exactSize;
+    item.SetGuid(p + kFfsGuidOffset);
+    item.Name += " [VOLUME]";
+    AddItem(item);
+    return S_OK;
+  }
+  
+  CVolFfsHeader ffsHeader;
+  if (!ffsHeader.Parse(p))
+    return S_FALSE;
+  // if (parent >= 0) AddSpaceAndString(_items[parent].Characts, FLAGS_TO_STRING(g_FV_Attribs, attribs));
+  
+  // VolSize > exactSize (fh.Size) for some UEFI archives (is it correct UEFI?)
+  // so we check VolSize for limitSize instead.
+
+  if (ffsHeader.HeaderLen > limitSize || ffsHeader.VolSize > limitSize)
+    return S_FALSE;
+  
+  {
+    UInt32 checkCalc = 0;
+    for (UInt32 i = 0; i < ffsHeader.HeaderLen; i += 2)
+      checkCalc += Get16(p + i);
+    if ((checkCalc & 0xFFFF) != 0)
+      return S_FALSE;
+  }
+  
+  // 3 reserved bytes are not zeros sometimes.
+  // UInt16 ExtHeaderOffset; // in new SPECIFICATION?
+  // Byte revision = p[0x37];
+  
+  UInt32 pos = kFvHeaderSize;
+  for (;;)
+  {
+    if (pos >= ffsHeader.HeaderLen)
+      return S_FALSE;
+    UInt32 numBlocks = Get32(p + pos);
+    UInt32 length = Get32(p + pos + 4);
+    pos += 8;
+    if (numBlocks == 0 && length == 0)
+      break;
+  }
+  if (pos != ffsHeader.HeaderLen)
+    return S_FALSE;
+  
+  CRecordVector<UInt32> guidsVector;
+  
+  for (;;)
+  {
+    UInt32 rem = (UInt32)ffsHeader.VolSize - pos;
+    if (rem < kFileHeaderSize)
+      break;
+    pos = (pos + 7) & ~7;
+    rem = (UInt32)ffsHeader.VolSize - pos;
+    if (rem < kFileHeaderSize)
+      break;
+
+    CItem item;
+    item.Method = method;
+    item.BufIndex = bufIndex;
+    item.Parent = parent;
+
+    const Byte *pFile = p + pos;
+    CFfsFileHeader fh;
+    if (!fh.Parse(pFile))
+    {
+      UInt32 num_FF_bytes = Count_FF_Bytes(pFile, rem);
+      if (num_FF_bytes != rem)
+      {
+        item.Name = "[junk]";
+        item.Offset = posBase + pos + num_FF_bytes;
+        item.Size = rem - num_FF_bytes;
+        AddItem(item);
+      }
+      break;
+    }
+    PrintLevel(level); PRF(printf("%s, pos = %6x, size = %6d", "FILE", posBase + pos, fh.Size));
+    if (!fh.Check(pFile, rem))
+      return S_FALSE;
+    
+    UInt32 offset = posBase + pos + kFileHeaderSize;
+    UInt32 sectSize = fh.GetDataSize();
+    item.Offset = offset;
+    item.Size = sectSize;
+
+    pos += fh.Size;
+
+    if (fh.Type == FV_FILETYPE_FFS_PAD)
+      if (Is_FF_Stream(pFile + kFileHeaderSize, sectSize))
+        continue;
+    
+    UInt32 guid32 = Get32(fh.GuidName);
+    bool full = true;
+    if (guidsVector.FindInSorted(guid32) < 0)
+    {
+      guidsVector.AddToUniqueSorted(guid32);
+      full = false;
+    }
+    item.SetGuid(fh.GuidName, full);
+    
+    item.Characts = fh.GetCharacts();
+    PrintLevel(level);
+    PRF(printf("%s", item.Characts));
+    
+    if (fh.Type == FV_FILETYPE_FFS_PAD ||
+        fh.Type == FV_FILETYPE_RAW)
+    {
+      bool isVolume = false;
+      if (fh.Type == FV_FILETYPE_RAW)
+      {
+        if (sectSize >= kFvHeaderSize)
+          if (IsFfs(pFile + kFileHeaderSize))
+            isVolume = true;
+      }
+      if (isVolume)
+      {
+        int newParent = AddDirItem(item);
+        UInt32 limSize = fh.GetDataSize2(rem);
+        // volume.VolSize > fh.Size for some UEFI archives (is it correct UEFI?)
+        // so we will check VolSize for limitSize instead.
+        RINOK(ParseVolume(bufIndex, offset, sectSize, limSize, newParent, method, level));
+      }
+      else
+        AddItem(item);
+    }
+    else
+    {
+      int newParent = AddDirItem(item);
+      RINOK(ParseSections(bufIndex, offset, sectSize, newParent, method, level));
+    }
+  }
+  return S_OK;
+}
+
+HRESULT CHandler::OpenCapsule(IInStream *stream)
+{
+  const unsigned kHeaderSize = 80;
+  Byte buf[kHeaderSize];
+  RINOK(ReadStream_FALSE(stream, buf, kHeaderSize));
+  _h.Parse(buf);
+  if (_h.HeaderSize != kHeaderSize ||
+      _h.CapsuleImageSize < kHeaderSize ||
+      _h.OffsetToCapsuleBody < kHeaderSize ||
+      _h.OffsetToCapsuleBody > _h.CapsuleImageSize)
+    return S_FALSE;
+  _phySize = _h.CapsuleImageSize;
+
+  if (_h.SequenceNumber != 0 ||
+      _h.OffsetToSplitInformation != 0 )
+    return E_NOTIMPL;
+
+  unsigned bufIndex = AddBuf(_h.CapsuleImageSize);
+  CByteBuffer &buf0 = _bufs[bufIndex];
+  memcpy(buf0, buf, kHeaderSize);
+  ReadStream_FALSE(stream, buf0 + kHeaderSize, _h.CapsuleImageSize - kHeaderSize);
+
+  AddCommentString(L"Author", _h.OffsetToAuthorInformation);
+  AddCommentString(L"Revision", _h.OffsetToRevisionInformation);
+  AddCommentString(L"Short Description", _h.OffsetToShortDescription);
+  AddCommentString(L"Long Description", _h.OffsetToLongDescription);
+
+  return ParseVolume(bufIndex, _h.OffsetToCapsuleBody,
+    _h.CapsuleImageSize - _h.OffsetToCapsuleBody,
+    _h.CapsuleImageSize - _h.OffsetToCapsuleBody,
+    -1, -1, 0);
+}
+
+HRESULT CHandler::OpenFv(IInStream *stream, const UInt64 * /* maxCheckStartPosition */, IArchiveOpenCallback * /* callback */)
+{
+  Byte buf[kFvHeaderSize];
+  RINOK(ReadStream_FALSE(stream, buf, kFvHeaderSize));
+  if (!IsFfs(buf))
+    return S_FALSE;
+  CVolFfsHeader ffsHeader;
+  if (!ffsHeader.Parse(buf))
+    return S_FALSE;
+  if (ffsHeader.VolSize > ((UInt32)1 << 30))
+    return S_FALSE;
+  _phySize = ffsHeader.VolSize;
+  RINOK(stream->Seek(0, STREAM_SEEK_SET, NULL));
+  UInt32 fvSize32 = (UInt32)ffsHeader.VolSize;
+  unsigned bufIndex = AddBuf(fvSize32);
+  RINOK(ReadStream_FALSE(stream, _bufs[bufIndex], fvSize32));
+  return ParseVolume(bufIndex, 0, fvSize32, fvSize32, -1, -1, 0);
+}
+
+HRESULT CHandler::Open2(IInStream *stream, const UInt64 *maxCheckStartPosition, IArchiveOpenCallback *callback)
+{
+  if (_capsuleMode)
+  {
+    RINOK(OpenCapsule(stream));
+  }
+  else
+  {
+    RINOK(OpenFv(stream, maxCheckStartPosition, callback));
+  }
+
+  unsigned num = _items.Size();
+  CIntArr numChilds(num);
+  
+  unsigned i;
+  
+  for (i = 0; i < num; i++)
+    numChilds[i] = 0;
+  
+  for (i = 0; i < num; i++)
+  {
+    int parent = _items[i].Parent;
+    if (parent >= 0)
+      numChilds[(unsigned)parent]++;
+  }
+
+  for (i = 0; i < num; i++)
+  {
+    const CItem &item = _items[i];
+    int parent = item.Parent;
+    if (parent >= 0)
+    {
+      CItem &parentItem = _items[(unsigned)parent];
+      if (numChilds[(unsigned)parent] == 1)
+        if (!item.ThereIsUniqueName || !parentItem.ThereIsUniqueName || !parentItem.ThereAreSubDirs)
+          parentItem.Skip = true;
+    }
+  }
+
+  CUIntVector mainToReduced;
+  
+  for (i = 0; i < _items.Size(); i++)
+  {
+    mainToReduced.Add(_items2.Size());
+    const CItem &item = _items[i];
+    if (item.Skip)
+      continue;
+    AString name;
+    int numItems = -1;
+    int parent = item.Parent;
+    if (parent >= 0)
+      numItems = numChilds[(unsigned)parent];
+    AString name2 = item.GetName(numItems);
+    AString characts2 = item.Characts;
+    if (item.KeepName)
+      name = name2;
+    
+    while (parent >= 0)
+    {
+      const CItem &item3 = _items[(unsigned)parent];
+      if (!item3.Skip)
+        break;
+      if (item3.KeepName)
+      {
+        AString name3 = item3.GetName(-1);
+        if (name.IsEmpty())
+          name = name3;
+        else
+          name = name3 + '.' + name;
+      }
+      AddSpaceAndString(characts2, item3.Characts);
+      parent = item3.Parent;
+    }
+    
+    if (name.IsEmpty())
+      name = name2;
+    
+    CItem2 item2;
+    item2.MainIndex = i;
+    item2.Name = name;
+    item2.Characts = characts2;
+    if (parent >= 0)
+      item2.Parent = mainToReduced[(unsigned)parent];
+    _items2.Add(item2);
+    /*
+    CItem2 item2;
+    item2.MainIndex = i;
+    item2.Name = item.Name;
+    item2.Parent = item.Parent;
+    _items2.Add(item2);
+    */
+  }
+  
+  return S_OK;
+}
+
+STDMETHODIMP CHandler::Open(IInStream *inStream,
+    const UInt64 *maxCheckStartPosition,
+    IArchiveOpenCallback *callback)
+{
+  COM_TRY_BEGIN
+  Close();
+  {
+    HRESULT res = Open2(inStream, maxCheckStartPosition, callback);
+    if (res == E_NOTIMPL)
+      res = S_FALSE;
+    return res;
+  }
+  COM_TRY_END
+}
+
+STDMETHODIMP CHandler::Close()
+{
+  _phySize = 0;
+  _totalBufsSize = 0;
+  _methodsMask = 0;
+  _items.Clear();
+  _items2.Clear();
+  _bufs.Clear();
+  _comment.Empty();
+  _h.Clear();
+  return S_OK;
+}
+
+STDMETHODIMP CHandler::GetNumberOfItems(UInt32 *numItems)
+{
+  *numItems = _items2.Size();
+  return S_OK;
+}
+
+STDMETHODIMP CHandler::Extract(const UInt32 *indices, UInt32 numItems,
+    Int32 testMode, IArchiveExtractCallback *extractCallback)
+{
+  COM_TRY_BEGIN
+  bool allFilesMode = (numItems == (UInt32)(Int32)-1);
+  if (allFilesMode)
+    numItems = _items2.Size();
+  if (numItems == 0)
+    return S_OK;
+  UInt64 totalSize = 0;
+  UInt32 i;
+  for (i = 0; i < numItems; i++)
+    totalSize += _items[_items2[allFilesMode ? i : indices[i]].MainIndex].Size;
+  extractCallback->SetTotal(totalSize);
+
+  UInt64 currentTotalSize = 0;
+  
+  NCompress::CCopyCoder *copyCoderSpec = new NCompress::CCopyCoder();
+  CMyComPtr<ICompressCoder> copyCoder = copyCoderSpec;
+
+  CLocalProgress *lps = new CLocalProgress;
+  CMyComPtr<ICompressProgressInfo> progress = lps;
+  lps->Init(extractCallback, false);
+
+  for (i = 0; i < numItems; i++)
+  {
+    lps->InSize = lps->OutSize = currentTotalSize;
+    RINOK(lps->SetCur());
+    CMyComPtr<ISequentialOutStream> realOutStream;
+    Int32 askMode = testMode ?
+        NExtract::NAskMode::kTest :
+        NExtract::NAskMode::kExtract;
+    UInt32 index = allFilesMode ? i : indices[i];
+    const CItem &item = _items[_items2[index].MainIndex];
+    RINOK(extractCallback->GetStream(index, &realOutStream, askMode));
+    currentTotalSize += item.Size;
+    
+    if (!testMode && !realOutStream)
+      continue;
+    RINOK(extractCallback->PrepareOperation(askMode));
+    if (testMode || item.IsDir)
+    {
+      RINOK(extractCallback->SetOperationResult(NExtract::NOperationResult::kOK));
+      continue;
+    }
+    int res = NExtract::NOperationResult::kDataError;
+    CMyComPtr<ISequentialInStream> inStream;
+    GetStream(index, &inStream);
+    if (inStream)
+    {
+      RINOK(copyCoder->Code(inStream, realOutStream, NULL, NULL, progress));
+      if (copyCoderSpec->TotalSize == item.Size)
+        res = NExtract::NOperationResult::kOK;
+    }
+    realOutStream.Release();
+    RINOK(extractCallback->SetOperationResult(res));
+  }
+  return S_OK;
+  COM_TRY_END
+}
+
+STDMETHODIMP CHandler::GetStream(UInt32 index, ISequentialInStream **stream)
+{
+  COM_TRY_BEGIN
+  const CItem &item = _items[_items2[index].MainIndex];
+  if (item.IsDir)
+    return S_FALSE;
+  CBufInStream *streamSpec = new CBufInStream;
+  CMyComPtr<IInStream> streamTemp = streamSpec;
+  const CByteBuffer &buf = _bufs[item.BufIndex];
+  /*
+  if (item.Offset + item.Size > buf.GetCapacity())
+    return S_FALSE;
+  */
+  streamSpec->Init(buf + item.Offset, item.Size, (IInArchive *)this);
+  *stream = streamTemp.Detach();
+  return S_OK;
+  COM_TRY_END
+}
+
+
+namespace UEFIc {
+  
+REGISTER_ARC_I_CLS(
+  CHandler(true),
+  "UEFIc", "scap", 0, 0xD0,
+  kCapsuleSig,
+  0,
+  NArcInfoFlags::kFindSignature,
+  NULL)
+  
+}
+
+namespace UEFIf {
+  
+REGISTER_ARC_I_CLS(
+  CHandler(false),
+  "UEFIf", "uefif", 0, 0xD1,
+  k_FFS_Guid,
+  kFfsGuidOffset,
+  NArcInfoFlags::kFindSignature,
+  NULL)
+
+}
+
+}}