7zip-native 0.0.0-stage → 0.0.1

package/vendor/7zip/CPP/7zip/Archive/CpioHandler.cpp

@@ -0,0 +1,1110 @@
+// CpioHandler.cpp
+
+#include "StdAfx.h"
+
+#include "../../../C/CpuArch.h"
+
+#include "../../Common/ComTry.h"
+#include "../../Common/MyLinux.h"
+#include "../../Common/StringConvert.h"
+#include "../../Common/StringToInt.h"
+#include "../../Common/UTFConvert.h"
+
+#include "../../Windows/PropVariant.h"
+#include "../../Windows/TimeUtils.h"
+
+#include "../Common/LimitedStreams.h"
+#include "../Common/ProgressUtils.h"
+#include "../Common/RegisterArc.h"
+#include "../Common/StreamUtils.h"
+
+#include "../Compress/CopyCoder.h"
+
+#include "Common/ItemNameUtils.h"
+
+using namespace NWindows;
+
+namespace NArchive {
+namespace NCpio {
+
+static const Byte kMagicBin0 = 0xC7;
+static const Byte kMagicBin1 = 0x71;
+
+static const Byte kMagicHex    = '1'; // New ASCII Format
+static const Byte kMagicHexCrc = '2'; // New CRC Format
+static const Byte kMagicOct    = '7'; // Portable ASCII Format
+
+static const char * const kName_TRAILER = "TRAILER!!!";
+
+static const unsigned k_BinRecord_Size = 2 + 8 * 2 + 2 * 4;
+static const unsigned k_OctRecord_Size = 6 + 8 * 6 + 2 * 11;
+static const unsigned k_HexRecord_Size = 6 + 13 * 8;
+
+static const unsigned k_RecordSize_Max = k_HexRecord_Size;
+
+enum EType
+{
+  k_Type_BinLe,
+  k_Type_BinBe,
+  k_Type_Oct,
+  k_Type_Hex,
+  k_Type_HexCrc
+};
+
+static const char * const k_Types[] =
+{
+    "Binary LE"
+  , "Binary BE"
+  , "Portable ASCII"
+  , "New ASCII"
+  , "New CRC"
+};
+
+struct CItem
+{
+  UInt32 inode;
+  unsigned MainIndex_ForInode;
+  UInt32 Mode;
+  UInt32 MTime;
+  UInt32 DevMajor;
+  UInt32 DevMinor;
+  UInt64 Size;
+  AString Name;
+  UInt32 NumLinks;
+  UInt32 UID;
+  UInt32 GID;
+  UInt32 RDevMajor;
+  UInt32 RDevMinor;
+  UInt32 ChkSum;
+
+  UInt32 AlignMask;
+  EType Type;
+
+  UInt32 HeaderSize;
+  UInt64 HeaderPos;
+
+  CByteBuffer Data; // for symlink
+
+
+  UInt32 GetAlignedSize(UInt32 size) const
+  {
+    return (size + AlignMask) & ~(UInt32)AlignMask;
+  }
+
+  UInt64 GetPackSize() const
+  {
+    const UInt64 alignMask64 = AlignMask;
+    return (Size + alignMask64) & ~(UInt64)alignMask64;
+  }
+
+  bool IsSame_inode_Dev(const CItem &item) const
+  {
+    return inode == item.inode
+        && DevMajor == item.DevMajor
+        && DevMinor == item.DevMinor;
+  }
+
+  bool IsBin() const { return Type == k_Type_BinLe || Type == k_Type_BinBe; }
+  bool IsCrcFormat() const { return Type == k_Type_HexCrc; }
+  bool IsDir() const { return MY_LIN_S_ISDIR(Mode); }
+  bool Is_SymLink() const { return MY_LIN_S_ISLNK(Mode); }
+  bool IsTrailer() const { return strcmp(Name, kName_TRAILER) == 0; }
+  UInt64 GetDataPosition() const { return HeaderPos + HeaderSize; }
+};
+
+
+enum EErrorType
+{
+  k_ErrorType_OK,
+  k_ErrorType_BadSignature,
+  k_ErrorType_Corrupted,
+  k_ErrorType_UnexpectedEnd
+};
+
+
+struct CInArchive
+{
+  EErrorType errorType;
+  ISequentialInStream *Stream;
+  UInt64 Processed;
+  CItem item;
+  
+  HRESULT Read(void *data, size_t *size);
+  HRESULT GetNextItem();
+};
+
+HRESULT CInArchive::Read(void *data, size_t *size)
+{
+  const HRESULT res = ReadStream(Stream, data, size);
+  Processed += *size;
+  return res;
+}
+
+
+static bool CheckOctRecord(const Byte *p)
+{
+  for (unsigned i = 6; i < k_OctRecord_Size; i++)
+  {
+    const unsigned c = (unsigned)p[i] - '0';
+    if (c > 7)
+      return false;
+  }
+  return true;
+}
+
+static bool CheckHexRecord(const Byte *p)
+{
+  for (unsigned i = 6; i < k_HexRecord_Size; i++)
+  {
+    unsigned c = p[i];
+    c -= '0';
+    if (c > 9)
+    {
+      c -= 'A' - '0';
+      c &= ~0x20u;
+      if (c > 5)
+        return false;
+    }
+  }
+  return true;
+}
+
+static UInt32 ReadHex(const Byte *p)
+{
+  char sz[16];
+  memcpy(sz, p, 8);
+  sz[8] = 0;
+  const char *end;
+  return ConvertHexStringToUInt32(sz, &end);
+}
+
+static UInt32 ReadOct6(const Byte *p)
+{
+  char sz[16];
+  memcpy(sz, p, 6);
+  sz[6] = 0;
+  const char *end;
+  return ConvertOctStringToUInt32(sz, &end);
+}
+
+static UInt64 ReadOct11(const Byte *p)
+{
+  char sz[16];
+  memcpy(sz, p, 11);
+  sz[11] = 0;
+  const char *end;
+  return ConvertOctStringToUInt64(sz, &end);
+}
+
+
+#define READ_HEX(    y, dest)  dest = ReadHex  (p + 6 + (y) * 8);
+#define READ_OCT_6(  y, dest)  dest = ReadOct6 (p + 6 + (y));
+#define READ_OCT_11( y, dest)  dest = ReadOct11(p + 6 + (y));
+
+#define Get32spec(p) (((UInt32)GetUi16(p) << 16) + GetUi16(p + 2))
+#define G16(offs, v) v = GetUi16(p + (offs))
+#define G32(offs, v) v = Get32spec(p + (offs))
+
+static const unsigned kNameSizeMax = 1 << 12;
+
+
+API_FUNC_static_IsArc IsArc_Cpio(const Byte *p, size_t size)
+{
+  if (size < k_BinRecord_Size)
+    return k_IsArc_Res_NEED_MORE;
+
+  UInt32 namePos;
+  UInt32 nameSize;
+  UInt32 mode;
+  // UInt32 rDevMinor;
+  UInt32 rDevMajor = 0;
+
+  if (p[0] == '0')
+  {
+    if (p[1] != '7' ||
+        p[2] != '0' ||
+        p[3] != '7' ||
+        p[4] != '0')
+      return k_IsArc_Res_NO;
+    if (p[5] == kMagicOct)
+    {
+      if (size < k_OctRecord_Size)
+        return k_IsArc_Res_NEED_MORE;
+      if (!CheckOctRecord(p))
+        return k_IsArc_Res_NO;
+      READ_OCT_6 (2 * 6, mode)
+      // READ_OCT_6 (6 * 6, rDevMinor)
+      READ_OCT_6 (7 * 6 + 11, nameSize)
+      namePos = k_OctRecord_Size;
+    }
+    else if (p[5] == kMagicHex || p[5] == kMagicHexCrc)
+    {
+      if (size < k_HexRecord_Size)
+        return k_IsArc_Res_NEED_MORE;
+      if (!CheckHexRecord(p))
+        return k_IsArc_Res_NO;
+      READ_HEX (1, mode)
+      READ_HEX (9, rDevMajor)
+      // READ_HEX (10, rDevMinor)
+      READ_HEX (11, nameSize)
+      namePos = k_HexRecord_Size;
+    }
+    else
+      return k_IsArc_Res_NO;
+  }
+  else
+  {
+    if (p[0] == kMagicBin0 && p[1] == kMagicBin1)
+    {
+      mode = GetUi16(p + 6);
+      // rDevMinor = GetUi16(p + 14);
+      nameSize = GetUi16(p + 20);
+    }
+    else if (p[0] == kMagicBin1 && p[1] == kMagicBin0)
+    {
+      mode = GetBe16(p + 6);
+      // rDevMinor = GetBe16(p + 14);
+      nameSize = GetBe16(p + 20);
+    }
+    else
+      return k_IsArc_Res_NO;
+    namePos = k_BinRecord_Size;
+  }
+
+  if (mode >= (1 << 16))
+    return k_IsArc_Res_NO;
+
+  /* v23.02: we have disabled rDevMinor check because real file
+     from Apple contains rDevMinor==255 by some unknown reason */
+  if (rDevMajor != 0
+      // || rDevMinor != 0
+      )
+  {
+    if (!MY_LIN_S_ISCHR(mode) &&
+        !MY_LIN_S_ISBLK(mode))
+      return k_IsArc_Res_NO;
+  }
+
+  // nameSize must include the null byte
+  if (nameSize == 0 || nameSize > kNameSizeMax)
+    return k_IsArc_Res_NO;
+  {
+    unsigned lim = namePos + nameSize - 1;
+    if (lim >= size)
+      lim = (unsigned)size;
+    else if (p[lim] != 0)
+      return k_IsArc_Res_NO;
+    for (unsigned i = namePos; i < lim; i++)
+      if (p[i] == 0)
+        return k_IsArc_Res_NO;
+  }
+
+  return k_IsArc_Res_YES;
+}
+}
+
+
+#define READ_STREAM(_dest_, _size_) \
+  { size_t processed = (_size_); RINOK(Read(_dest_, &processed)); \
+if (processed != (_size_)) { errorType = k_ErrorType_UnexpectedEnd; return S_OK; } }
+
+HRESULT CInArchive::GetNextItem()
+{
+  errorType = k_ErrorType_BadSignature;
+
+  Byte p[k_RecordSize_Max];
+
+  READ_STREAM(p, k_BinRecord_Size)
+
+  UInt32 nameSize;
+  UInt32 namePos;
+
+  /* we try to reduce probability of false detection,
+     so we check some fields for unuxpected values */
+
+  if (p[0] != '0')
+  {
+         if (p[0] == kMagicBin0 && p[1] == kMagicBin1) { item.Type = k_Type_BinLe; }
+    else if (p[0] == kMagicBin1 && p[1] == kMagicBin0)
+    {
+      for (unsigned i = 2; i < k_BinRecord_Size; i += 2)
+      {
+        const Byte b = p[i];
+        p[i] = p[i + 1];
+        p[i + 1] = b;
+      }
+      item.Type = k_Type_BinBe;
+    }
+    else
+      return S_OK;
+
+    errorType = k_ErrorType_Corrupted;
+
+    item.AlignMask = 2 - 1;
+    item.DevMajor = 0;
+    item.RDevMajor = 0;
+    item.ChkSum = 0;
+
+    G16(2, item.DevMinor);
+    G16(4, item.inode);
+    G16(6, item.Mode);
+    G16(8, item.UID);
+    G16(10, item.GID);
+    G16(12, item.NumLinks);
+    G16(14, item.RDevMinor);
+    G32(16, item.MTime);
+    G16(20, nameSize);
+    G32(22, item.Size);
+
+    namePos = k_BinRecord_Size;
+  }
+  else
+  {
+    if (p[1] != '7' ||
+        p[2] != '0' ||
+        p[3] != '7' ||
+        p[4] != '0')
+      return S_OK;
+    if (p[5] == kMagicOct)
+    {
+      errorType = k_ErrorType_Corrupted;
+
+      item.Type = k_Type_Oct;
+      READ_STREAM(p + k_BinRecord_Size, k_OctRecord_Size - k_BinRecord_Size)
+      item.AlignMask = 1 - 1;
+      item.DevMajor = 0;
+      item.RDevMajor = 0;
+      item.ChkSum = 0;
+
+      if (!CheckOctRecord(p))
+        return S_OK;
+
+      READ_OCT_6 (0, item.DevMinor)
+      READ_OCT_6 (1 * 6, item.inode)
+      READ_OCT_6 (2 * 6, item.Mode)
+      READ_OCT_6 (3 * 6, item.UID)
+      READ_OCT_6 (4 * 6, item.GID)
+      READ_OCT_6 (5 * 6, item.NumLinks)
+      READ_OCT_6 (6 * 6, item.RDevMinor)
+      {
+        UInt64 mTime64;
+        READ_OCT_11 (7 * 6, mTime64)
+        item.MTime = 0;
+        if (mTime64 <= (UInt32)(Int32)-1)
+          item.MTime = (UInt32)mTime64;
+      }
+      READ_OCT_6 (7 * 6 + 11, nameSize)
+      READ_OCT_11 (8 * 6 + 11, item.Size)  // ?????
+
+      namePos = k_OctRecord_Size;
+    }
+    else
+    {
+           if (p[5] == kMagicHex)    item.Type = k_Type_Hex;
+      else if (p[5] == kMagicHexCrc) item.Type = k_Type_HexCrc;
+      else return S_OK;
+
+      errorType = k_ErrorType_Corrupted;
+
+      READ_STREAM(p + k_BinRecord_Size, k_HexRecord_Size - k_BinRecord_Size)
+
+      if (!CheckHexRecord(p))
+        return S_OK;
+
+      item.AlignMask = 4 - 1;
+      READ_HEX (0, item.inode)
+      READ_HEX (1, item.Mode)
+      READ_HEX (2, item.UID)
+      READ_HEX (3, item.GID)
+      READ_HEX (4, item.NumLinks)
+      READ_HEX (5, item.MTime)
+      READ_HEX (6, item.Size)
+      READ_HEX (7, item.DevMajor)
+      READ_HEX (8, item.DevMinor)
+      READ_HEX (9, item.RDevMajor)
+      READ_HEX (10, item.RDevMinor)
+      READ_HEX (11, nameSize)
+      READ_HEX (12, item.ChkSum)
+
+      if (item.Type == k_Type_Hex && item.ChkSum != 0)
+        return S_OK;
+
+      namePos = k_HexRecord_Size;
+    }
+  }
+
+  if (item.Mode >= (1 << 16))
+    return S_OK;
+
+  /* v23.02: we have disabled rDevMinor check because real file
+     from Apple contains rDevMinor==255 by some unknown reason
+     cpio 2.13 and older versions: it copies stat::st_rdev to archive.
+        and stat::st_rdev can be non-zero for some old linux/filesystems cases for regular files.
+     cpio 2.14 (2023) copies st_rdev to archive only if (S_ISBLK (st->st_mode) || S_ISCHR (st->st_mode))
+     v25.00: we have disabled RDevMajor check here to support some rare case created by cpio 2.13- with old linux.
+     But we still keep full check in IsArc_Cpio() to reduce false cpio detection cases.
+  */
+#if 0 // 0 : to disable check to support some old linux cpio archives.
+  if (item.RDevMajor != 0
+      // || item.RDevMinor != 0
+      )
+  {
+    if (!MY_LIN_S_ISCHR(item.Mode) &&
+        !MY_LIN_S_ISBLK(item.Mode))
+      return S_OK;
+  }
+#endif
+
+  // Size must be 0 for FIFOs and directories
+  if (item.IsDir() || MY_LIN_S_ISFIFO(item.Mode))
+    if (item.Size != 0)
+      return S_OK;
+
+  // nameSize must include the null byte
+  if (nameSize == 0 || nameSize > kNameSizeMax)
+    return S_OK;
+  item.HeaderSize = item.GetAlignedSize(namePos + nameSize);
+  const UInt32 rem = item.HeaderSize - namePos;
+  char *s = item.Name.GetBuf(rem);
+  size_t processedSize = rem;
+  RINOK(Read(s, &processedSize))
+  if (processedSize != rem)
+  {
+    item.Name.ReleaseBuf_SetEnd(0);
+    errorType = k_ErrorType_UnexpectedEnd;
+    return S_OK;
+  }
+  bool pad_error = false;
+  for (size_t i = nameSize; i < processedSize; i++)
+    if (s[i] != 0)
+      pad_error = true;
+  item.Name.ReleaseBuf_CalcLen(nameSize);
+  if (item.Name.Len() + 1 != nameSize || pad_error)
+    return S_OK;
+  errorType = k_ErrorType_OK;
+  return S_OK;
+}
+
+
+
+Z7_CLASS_IMP_CHandler_IInArchive_1(
+  IInArchiveGetStream
+)
+  CObjectVector<CItem> _items;
+  CMyComPtr<IInStream> _stream;
+  UInt64 _phySize;
+  EType _type;
+  EErrorType _error;
+  bool _isArc;
+  bool _moreThanOneHardLinks_Error;
+  bool _numLinks_Error;
+  bool _pad_Error;
+  bool _symLink_Error;
+};
+
+static const Byte kArcProps[] =
+{
+  kpidSubType
+};
+
+static const Byte kProps[] =
+{
+  kpidPath,
+  kpidIsDir,
+  kpidSize,
+  kpidPackSize,
+  kpidMTime,
+  kpidPosixAttrib,
+  kpidLinks,
+  kpidINode,
+  kpidUserId,
+  kpidGroupId,
+  kpidDevMajor,
+  kpidDevMinor,
+  kpidDeviceMajor,
+  kpidDeviceMinor,
+  kpidChecksum,
+  kpidSymLink,
+  kpidStreamId, // for debug
+  kpidOffset
+};
+
+IMP_IInArchive_Props
+IMP_IInArchive_ArcProps
+
+Z7_COM7F_IMF(CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value))
+{
+  COM_TRY_BEGIN
+  NCOM::CPropVariant prop;
+  switch (propID)
+  {
+    case kpidSubType: prop = k_Types[(unsigned)_type]; break;
+    case kpidPhySize: prop = _phySize; break;
+    case kpidINode: prop = true; break;
+    case kpidErrorFlags:
+    {
+      UInt32 v = 0;
+      if (!_isArc)
+        v |= kpv_ErrorFlags_IsNotArc;
+      switch (_error)
+      {
+        case k_ErrorType_UnexpectedEnd: v |= kpv_ErrorFlags_UnexpectedEnd; break;
+        case k_ErrorType_Corrupted:     v |= kpv_ErrorFlags_HeadersError; break;
+        case k_ErrorType_OK:
+        case k_ErrorType_BadSignature:
+        // default:
+          break;
+      }
+      prop = v;
+      break;
+    }
+    case kpidWarningFlags:
+    {
+      UInt32 v = 0;
+      if (_moreThanOneHardLinks_Error)
+        v |= kpv_ErrorFlags_UnsupportedFeature; // kpv_ErrorFlags_HeadersError
+      if (_numLinks_Error
+          || _pad_Error
+          || _symLink_Error)
+        v |= kpv_ErrorFlags_HeadersError;
+      if (v != 0)
+        prop = v;
+      break;
+    }
+  }
+  prop.Detach(value);
+  return S_OK;
+  COM_TRY_END
+}
+
+
+static int CompareItems(const unsigned *p1, const unsigned *p2, void *param)
+{
+  const CObjectVector<CItem> &items = *(const CObjectVector<CItem> *)param;
+  const unsigned index1 = *p1;
+  const unsigned index2 = *p2;
+  const CItem &i1 = items[index1];
+  const CItem &i2 = items[index2];
+  if (i1.DevMajor < i2.DevMajor) return -1;
+  if (i1.DevMajor > i2.DevMajor) return 1;
+  if (i1.DevMinor < i2.DevMinor) return -1;
+  if (i1.DevMinor > i2.DevMinor) return 1;
+  if (i1.inode < i2.inode) return -1;
+  if (i1.inode > i2.inode) return 1;
+  if (i1.IsDir())
+  {
+    if (!i2.IsDir())
+      return -1;
+  }
+  else if (i2.IsDir())
+    return 1;
+  return MyCompare(index1, index2);
+}
+
+
+Z7_COM7F_IMF(CHandler::Open(IInStream *stream, const UInt64 *, IArchiveOpenCallback *callback))
+{
+  COM_TRY_BEGIN
+  {
+    Close();
+    
+    UInt64 endPos;
+    RINOK(InStream_AtBegin_GetSize(stream, endPos))
+    if (callback)
+    {
+      RINOK(callback->SetTotal(NULL, &endPos))
+    }
+
+    CInArchive arc;
+
+    arc.Stream = stream;
+    arc.Processed = 0;
+
+    for (;;)
+    {
+      CItem &item = arc.item;
+      item.HeaderPos = arc.Processed;
+      
+      RINOK(arc.GetNextItem())
+
+      _error = arc.errorType;
+      
+      if (_error != k_ErrorType_OK)
+      {
+        if (_error == k_ErrorType_BadSignature ||
+            _error == k_ErrorType_Corrupted)
+          arc.Processed = item.HeaderPos;
+        break;
+      }
+      
+      if (_items.IsEmpty())
+        _type = item.Type;
+      else if (_items.Back().Type != item.Type)
+      {
+        _error = k_ErrorType_Corrupted;
+        arc.Processed = item.HeaderPos;
+        break;
+      }
+      
+      if (item.IsTrailer())
+        break;
+      
+      item.MainIndex_ForInode = _items.Size();
+      _items.Add(item);
+
+      const UInt64 dataSize = item.GetPackSize();
+      arc.Processed += dataSize;
+      if (arc.Processed > endPos)
+      {
+        _error = k_ErrorType_UnexpectedEnd;
+        break;
+      }
+        
+      if (item.Is_SymLink() && dataSize <= (1 << 12) && item.Size != 0)
+      {
+        size_t cur = (size_t)dataSize;
+        CByteBuffer buf;
+        buf.Alloc(cur);
+        RINOK(ReadStream(stream, buf, &cur))
+        if (cur != dataSize)
+        {
+          _error = k_ErrorType_UnexpectedEnd;
+          break;
+        }
+        size_t i;
+        
+        for (i = (size_t)item.Size; i < dataSize; i++)
+          if (buf[i] != 0)
+            break;
+        if (i != dataSize)
+          _pad_Error = true;
+
+        for (i = 0; i < (size_t)item.Size; i++)
+          if (buf[i] == 0)
+            break;
+        if (i != (size_t)item.Size)
+          _symLink_Error = true;
+        else
+          _items.Back().Data.CopyFrom(buf, (size_t)item.Size);
+      }
+      else if (dataSize != 0)
+      {
+        UInt64 newPos;
+        RINOK(stream->Seek((Int64)dataSize, STREAM_SEEK_CUR, &newPos))
+        if (arc.Processed != newPos)
+          return E_FAIL;
+      }
+
+      if (callback && (_items.Size() & 0xFFF) == 0)
+      {
+        const UInt64 numFiles = _items.Size();
+        RINOK(callback->SetCompleted(&numFiles, &item.HeaderPos))
+      }
+    }
+
+    _phySize = arc.Processed;
+  }
+
+  {
+    if (_error != k_ErrorType_OK)
+    {
+      // we try to reduce probability of false detection
+      if (_items.Size() == 0)
+        return S_FALSE;
+      // bin file uses small signature. So we do additional check for single item case.
+      if (_items.Size() == 1 && _items[0].IsBin())
+        return S_FALSE;
+    }
+    else
+    {
+      // Read tailing zeros.
+      // Most of cpio files use 512-bytes aligned zeros
+      // rare case: 4K/8K aligment is possible also
+      const unsigned kTailSize_MAX = 1 << 9;
+      Byte buf[kTailSize_MAX];
+      
+      unsigned pos = (unsigned)_phySize & (kTailSize_MAX - 1);
+      if (pos != 0) // use this check to support 512 bytes alignment only
+      for (;;)
+      {
+        const unsigned rem = kTailSize_MAX - pos;
+        size_t processed = rem;
+        RINOK(ReadStream(stream, buf + pos, &processed))
+        if (processed != rem)
+          break;
+        for (; pos < kTailSize_MAX && buf[pos] == 0; pos++)
+        {}
+        if (pos != kTailSize_MAX)
+          break;
+        _phySize += processed;
+        pos = 0;
+
+        //       use break to support 512   bytes alignment zero tail
+        // don't use break to support 512*n bytes alignment zero tail
+        break;
+      }
+    }
+  }
+  
+  {
+    /* there was such cpio archive example with hard links:
+       {
+         all hard links (same dev/inode) are stored in neighboring items, and
+           (item.Size == 0)  for non last hard link items
+           (item.Size != 0)  for     last hard link item
+       }
+       but here we sort items by (dev/inode) to support cases
+       where hard links (same dev/inode) are not stored in neighboring items.
+
+       // note: some cpio files have (numLinks == 0) ??
+    */
+
+    CUIntVector indices;
+    {
+      const unsigned numItems = _items.Size();
+      indices.ClearAndSetSize(numItems);
+      if (numItems != 0)
+      {
+        unsigned *vals = &indices[0];
+        for (unsigned i = 0; i < numItems; i++)
+          vals[i] = i;
+        indices.Sort(CompareItems, (void *)&_items);
+      }
+    }
+
+    /* Note: if cpio archive (maybe incorrect) contains
+       more then one non empty streams with identical inode number,
+       we want to extract all such data streams too.
+       
+       So we place items with identical inode to groups:
+       all items in group will have same MainIndex_ForInode,
+       that is index of last item in group with (Size != 0).
+       Another (non last) items in group have (Size == 0).
+       If there are another hard links with same inode number
+       after (Size != 0) item, we place them to another next group(s).
+       
+       Check it: maybe we should use single group for items
+       with identical inode instead, and ignore some extra data streams ?
+    */
+    
+    for (unsigned i = 0; i < indices.Size();)
+    {
+      unsigned k;
+      {
+        const CItem &item_Base = _items[indices[i]];
+
+        if (item_Base.IsDir())
+        {
+          i++;
+          continue;
+        }
+        
+        if (i != 0)
+        {
+          const CItem &item_Prev = _items[indices[i - 1]];
+          if (!item_Prev.IsDir())
+            if (item_Base.IsSame_inode_Dev(item_Prev))
+              _moreThanOneHardLinks_Error = true;
+        }
+        
+        if (item_Base.Size != 0)
+        {
+          if (item_Base.NumLinks != 1)
+            _numLinks_Error = true;
+          i++;
+          continue;
+        }
+        
+        for (k = i + 1; k < indices.Size();)
+        {
+          const CItem &item = _items[indices[k]];
+          if (item.IsDir())
+            break;
+          if (!item.IsSame_inode_Dev(item_Base))
+            break;
+          k++;
+          if (item.Size != 0)
+            break;
+        }
+      }
+
+      const unsigned numLinks = k - i;
+      for (;;)
+      {
+        CItem &item = _items[indices[i]];
+        if (item.NumLinks != numLinks)
+          _numLinks_Error = true;
+        if (++i == k)
+          break;
+        // if (item.Size == 0)
+        item.MainIndex_ForInode = indices[k - 1];
+      }
+    }
+  }
+
+  _isArc = true;
+  _stream = stream;
+
+  return S_OK;
+  COM_TRY_END
+}
+
+
+Z7_COM7F_IMF(CHandler::Close())
+{
+  _items.Clear();
+  _stream.Release();
+  _phySize = 0;
+  _type = k_Type_BinLe;
+  _isArc = false;
+  _moreThanOneHardLinks_Error = false;
+  _numLinks_Error = false;
+  _pad_Error = false;
+  _symLink_Error = false;
+  _error = k_ErrorType_OK;
+  return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetNumberOfItems(UInt32 *numItems))
+{
+  *numItems = _items.Size();
+  return S_OK;
+}
+
+Z7_COM7F_IMF(CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value))
+{
+  COM_TRY_BEGIN
+  NCOM::CPropVariant prop;
+  const CItem &item = _items[index];
+
+  switch (propID)
+  {
+    case kpidPath:
+    {
+#ifdef _WIN32
+      UString u;
+      ConvertUTF8ToUnicode(item.Name, u);
+#else
+      const UString u = MultiByteToUnicodeString(item.Name, CP_OEMCP);
+#endif
+      prop = NItemName::GetOsPath(u);
+      break;
+    }
+    case kpidIsDir: prop = item.IsDir(); break;
+
+    case kpidSize:
+      prop = (UInt64)_items[item.MainIndex_ForInode].Size;
+      break;
+    
+    case kpidPackSize:
+      prop = (UInt64)item.GetPackSize();
+      break;
+    
+    case kpidMTime:
+    {
+      if (item.MTime != 0)
+        PropVariant_SetFrom_UnixTime(prop, item.MTime);
+      break;
+    }
+    case kpidPosixAttrib: prop = item.Mode; break;
+    case kpidINode: prop = item.inode; break;
+    case kpidStreamId:
+      if (!item.IsDir())
+        prop = (UInt32)item.MainIndex_ForInode;
+      break;
+    case kpidDevMajor: prop = (UInt32)item.DevMajor; break;
+    case kpidDevMinor: prop = (UInt32)item.DevMinor; break;
+
+    case kpidUserId: prop = item.UID; break;
+    case kpidGroupId: prop = item.GID; break;
+
+    case kpidSymLink:
+      if (item.Is_SymLink() && item.Data.Size() != 0)
+      {
+        AString s;
+        s.SetFrom_CalcLen((const char *)(const void *)(const Byte *)item.Data, (unsigned)item.Data.Size());
+        if (s.Len() == item.Data.Size())
+        {
+#ifdef _WIN32
+          UString u;
+          ConvertUTF8ToUnicode(s, u);
+#else
+          const UString u = MultiByteToUnicodeString(s, CP_OEMCP);
+#endif
+          prop = u;
+        }
+      }
+      break;
+
+    case kpidLinks: prop = item.NumLinks; break;
+    case kpidDeviceMajor:
+      // if (item.RDevMajor != 0)
+        prop = (UInt32)item.RDevMajor;
+      break;
+    case kpidDeviceMinor:
+      // if (item.RDevMinor != 0)
+        prop = (UInt32)item.RDevMinor;
+      break;
+    case kpidChecksum:
+      if (item.IsCrcFormat())
+        prop = item.ChkSum;
+      break;
+    case kpidOffset: prop = item.GetDataPosition(); break;
+  }
+  prop.Detach(value);
+  return S_OK;
+  COM_TRY_END
+}
+
+
+Z7_CLASS_IMP_NOQIB_1(
+  COutStreamWithSum
+  , ISequentialOutStream
+)
+  CMyComPtr<ISequentialOutStream> _stream;
+  UInt32 _checksum;
+  bool _calculate;
+public:
+  void SetStream(ISequentialOutStream *stream) { _stream = stream; }
+  void ReleaseStream() { _stream.Release(); }
+  void Init(bool calculate)
+  {
+    _calculate = calculate;
+    _checksum = 0;
+  }
+  UInt32 GetChecksum() const { return _checksum; }
+};
+
+
+Z7_COM7F_IMF(COutStreamWithSum::Write(const void *data, UInt32 size, UInt32 *processedSize))
+{
+  HRESULT result = S_OK;
+  if (_stream)
+    result = _stream->Write(data, size, &size);
+  if (processedSize)
+    *processedSize = size;
+  if (_calculate)
+  {
+    const Byte *p = (const Byte *)data;
+    const Byte *lim = p + size;
+    UInt32 sum = _checksum;
+    if (size >= 4)
+    {
+      lim -= 4 - 1;
+      do
+      {
+        sum += p[0] + p[1] + p[2] + p[3];
+        p += 4;
+      }
+      while (p < lim);
+      lim += 4 - 1;
+    }
+    if (p != lim) { sum += *p++;
+    if (p != lim) { sum += *p++;
+    if (p != lim) { sum += *p++; }}}
+    _checksum = sum;
+  }
+  return result;
+}
+
+Z7_COM7F_IMF(CHandler::Extract(const UInt32 *indices, UInt32 numItems,
+    Int32 testMode, IArchiveExtractCallback *extractCallback))
+{
+  COM_TRY_BEGIN
+  const bool allFilesMode = (numItems == (UInt32)(Int32)-1);
+  if (allFilesMode)
+    numItems = _items.Size();
+  if (numItems == 0)
+    return S_OK;
+  UInt64 totalSize = 0;
+  UInt32 i;
+  for (i = 0; i < numItems; i++)
+  {
+    const UInt32 index = allFilesMode ? i : indices[i];
+    const CItem &item2 = _items[index];
+    const CItem &item = _items[item2.MainIndex_ForInode];
+    totalSize += item.Size;
+  }
+  RINOK(extractCallback->SetTotal(totalSize))
+
+  CMyComPtr2_Create<ICompressCoder, NCompress::CCopyCoder> copyCoder;
+  CMyComPtr2_Create<ICompressProgressInfo, CLocalProgress> lps;
+  lps->Init(extractCallback, false);
+  CMyComPtr2_Create<ISequentialInStream, CLimitedSequentialInStream> inStream;
+  inStream->SetStream(_stream);
+  CMyComPtr2_Create<ISequentialOutStream, COutStreamWithSum> outStreamSum;
+
+  UInt64 total_PackSize = 0;
+  UInt64 total_UnpackSize = 0;
+
+  for (i = 0;; i++)
+  {
+    lps->InSize = total_PackSize;
+    lps->OutSize = total_UnpackSize;
+    RINOK(lps->SetCur())
+    if (i >= numItems)
+      break;
+    const Int32 askMode = testMode ?
+        NExtract::NAskMode::kTest :
+        NExtract::NAskMode::kExtract;
+    const UInt32 index = allFilesMode ? i : indices[i];
+    const CItem &item2 = _items[index];
+    const CItem &item = _items[item2.MainIndex_ForInode];
+    {
+      CMyComPtr<ISequentialOutStream> outStream;
+      RINOK(extractCallback->GetStream(index, &outStream, askMode))
+        
+      total_PackSize += item2.GetPackSize();
+      total_UnpackSize += item.Size;
+      
+      if (item2.IsDir())
+      {
+        RINOK(extractCallback->PrepareOperation(askMode))
+        RINOK(extractCallback->SetOperationResult(NExtract::NOperationResult::kOK))
+        continue;
+      }
+      if (!testMode && !outStream)
+        continue;
+      outStreamSum->Init(item.IsCrcFormat());
+      outStreamSum->SetStream(outStream);
+      RINOK(extractCallback->PrepareOperation(askMode))
+    }
+    RINOK(InStream_SeekSet(_stream, item.GetDataPosition()))
+    inStream->Init(item.Size);
+    RINOK(copyCoder.Interface()->Code(inStream, outStreamSum, NULL, NULL, lps))
+    outStreamSum->ReleaseStream();
+    Int32 res = NExtract::NOperationResult::kDataError;
+    if (copyCoder->TotalSize == item.Size)
+    {
+      res = NExtract::NOperationResult::kOK;
+      if (item.IsCrcFormat() && item.ChkSum != outStreamSum->GetChecksum())
+        res = NExtract::NOperationResult::kCRCError;
+    }
+    RINOK(extractCallback->SetOperationResult(res))
+  }
+  return S_OK;
+  COM_TRY_END
+}
+
+Z7_COM7F_IMF(CHandler::GetStream(UInt32 index, ISequentialInStream **stream))
+{
+  COM_TRY_BEGIN
+  const CItem &item2 = _items[index];
+  const CItem &item = _items[item2.MainIndex_ForInode];
+  return CreateLimitedInStream(_stream, item.GetDataPosition(), item.Size, stream);
+  COM_TRY_END
+}
+
+static const Byte k_Signature[] = {
+    5, '0', '7', '0', '7', '0',
+    2, kMagicBin0, kMagicBin1,
+    2, kMagicBin1, kMagicBin0 };
+
+REGISTER_ARC_I(
+  "Cpio", "cpio", NULL, 0xED,
+  k_Signature,
+  0,
+  NArcInfoFlags::kMultiSignature,
+  IsArc_Cpio)
+
+}}