Initialer Commit

CPP/7zip/Archive/XarHandler.cpp

@@ -0,0 +1,732 @@
+// XarHandler.cpp
+
+#include "StdAfx.h"
+
+#include "../../../C/CpuArch.h"
+
+#include "../../Common/ComTry.h"
+#include "../../Common/MyLinux.h"
+#include "../../Common/MyXml.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/StreamObjects.h"
+#include "../Common/StreamUtils.h"
+
+#include "../Compress/BZip2Decoder.h"
+#include "../Compress/CopyCoder.h"
+#include "../Compress/ZlibDecoder.h"
+
+#include "Common/OutStreamWithSha1.h"
+
+using namespace NWindows;
+
+#define XAR_SHOW_RAW
+
+#define Get16(p) GetBe16(p)
+#define Get32(p) GetBe32(p)
+#define Get64(p) GetBe64(p)
+
+namespace NArchive {
+namespace NXar {
+
+static const size_t kXmlSizeMax = ((size_t )1 << 30) - (1 << 14);
+static const size_t kXmlPackSizeMax = kXmlSizeMax;
+
+/*
+#define XAR_CKSUM_NONE  0
+#define XAR_CKSUM_SHA1  1
+#define XAR_CKSUM_MD5   2
+
+static const char * const k_ChecksumAlgos[] =
+{
+    "None"
+  , "SHA-1"
+  , "MD5"
+};
+*/
+
+#define METHOD_NAME_ZLIB "zlib"
+
+
+struct CFile
+{
+  AString Name;
+  AString Method;
+  UInt64 Size;
+  UInt64 PackSize;
+  UInt64 Offset;
+  
+  UInt64 CTime;
+  UInt64 MTime;
+  UInt64 ATime;
+  UInt32 Mode;
+
+  AString User;
+  AString Group;
+  
+  bool IsDir;
+  bool HasData;
+  bool ModeDefined;
+  bool Sha1IsDefined;
+  // bool packSha1IsDefined;
+
+  Byte Sha1[SHA1_DIGEST_SIZE];
+  // Byte packSha1[SHA1_DIGEST_SIZE];
+
+  int Parent;
+
+  CFile(): IsDir(false), HasData(false), ModeDefined(false), Sha1IsDefined(false),
+      /* packSha1IsDefined(false), */
+      Parent(-1),
+      Size(0), PackSize(0), Offset(0),
+      CTime(0), MTime(0), ATime(0), Mode(0) {}
+
+  bool IsCopyMethod() const
+  {
+    return Method.IsEmpty() || Method == "octet-stream";
+  }
+
+  void UpdateTotalPackSize(UInt64 &totalSize) const
+  {
+    UInt64 t = Offset + PackSize;
+    if (totalSize < t)
+      totalSize = t;
+  }
+};
+
+class CHandler:
+  public IInArchive,
+  public IInArchiveGetStream,
+  public CMyUnknownImp
+{
+  UInt64 _dataStartPos;
+  CMyComPtr<IInStream> _inStream;
+  CByteArr _xml;
+  size_t _xmlLen;
+  CObjectVector<CFile> _files;
+  // UInt32 _checkSumAlgo;
+  UInt64 _phySize;
+  Int32 _mainSubfile;
+  bool _is_pkg;
+
+  HRESULT Open2(IInStream *stream);
+  HRESULT Extract(IInStream *stream);
+public:
+  MY_UNKNOWN_IMP2(IInArchive, IInArchiveGetStream)
+  INTERFACE_IInArchive(;)
+  STDMETHOD(GetStream)(UInt32 index, ISequentialInStream **stream);
+};
+
+static const Byte kArcProps[] =
+{
+  kpidSubType,
+  kpidHeadersSize
+};
+
+static const Byte kProps[] =
+{
+  kpidPath,
+  kpidSize,
+  kpidPackSize,
+  kpidMTime,
+  kpidCTime,
+  kpidATime,
+  kpidPosixAttrib,
+  kpidUser,
+  kpidGroup,
+  kpidMethod
+};
+
+IMP_IInArchive_Props
+IMP_IInArchive_ArcProps
+
+#define PARSE_NUM(_num_, _dest_) \
+    { const char *end; _dest_ = ConvertStringToUInt32(p, &end); \
+    if ((unsigned)(end - p) != _num_) return 0; p += _num_ + 1; }
+
+static bool ParseUInt64(const CXmlItem &item, const char *name, UInt64 &res)
+{
+  const AString s = item.GetSubStringForTag(name);
+  if (s.IsEmpty())
+    return false;
+  const char *end;
+  res = ConvertStringToUInt64(s, &end);
+  return *end == 0;
+}
+
+static UInt64 ParseTime(const CXmlItem &item, const char *name)
+{
+  const AString s = item.GetSubStringForTag(name);
+  if (s.Len() < 20)
+    return 0;
+  const char *p = s;
+  if (p[ 4] != '-' || p[ 7] != '-' || p[10] != 'T' ||
+      p[13] != ':' || p[16] != ':' || p[19] != 'Z')
+    return 0;
+  UInt32 year, month, day, hour, min, sec;
+  PARSE_NUM(4, year)
+  PARSE_NUM(2, month)
+  PARSE_NUM(2, day)
+  PARSE_NUM(2, hour)
+  PARSE_NUM(2, min)
+  PARSE_NUM(2, sec)
+  
+  UInt64 numSecs;
+  if (!NTime::GetSecondsSince1601(year, month, day, hour, min, sec, numSecs))
+    return 0;
+  return numSecs * 10000000;
+}
+
+static int HexToByte(unsigned char c)
+{
+  if (c >= '0' && c <= '9') return c - '0';
+  if (c >= 'A' && c <= 'F') return c - 'A' + 10;
+  if (c >= 'a' && c <= 'f') return c - 'a' + 10;
+  return -1;
+}
+
+static bool ParseSha1(const CXmlItem &item, const char *name, Byte *digest)
+{
+  int index = item.FindSubTag(name);
+  if (index < 0)
+    return false;
+  const CXmlItem &checkItem = item.SubItems[index];
+  const AString style = checkItem.GetPropVal("style");
+  if (style == "SHA1")
+  {
+    const AString s = checkItem.GetSubString();
+    if (s.Len() != SHA1_DIGEST_SIZE * 2)
+      return false;
+    for (unsigned i = 0; i < s.Len(); i += 2)
+    {
+      int b0 = HexToByte(s[i]);
+      int b1 = HexToByte(s[i + 1]);
+      if (b0 < 0 || b1 < 0)
+        return false;
+      digest[i / 2] = (Byte)((b0 << 4) | b1);
+    }
+    return true;
+  }
+  return false;
+}
+
+static bool AddItem(const CXmlItem &item, CObjectVector<CFile> &files, int parent)
+{
+  if (!item.IsTag)
+    return true;
+  if (item.Name == "file")
+  {
+    CFile file;
+    file.Parent = parent;
+    parent = files.Size();
+    file.Name = item.GetSubStringForTag("name");
+    AString type = item.GetSubStringForTag("type");
+    if (type == "directory")
+      file.IsDir = true;
+    else if (type == "file")
+      file.IsDir = false;
+    else
+      return false;
+
+    int dataIndex = item.FindSubTag("data");
+    if (dataIndex >= 0 && !file.IsDir)
+    {
+      file.HasData = true;
+      const CXmlItem &dataItem = item.SubItems[dataIndex];
+      if (!ParseUInt64(dataItem, "size", file.Size))
+        return false;
+      if (!ParseUInt64(dataItem, "length", file.PackSize))
+        return false;
+      if (!ParseUInt64(dataItem, "offset", file.Offset))
+        return false;
+      file.Sha1IsDefined = ParseSha1(dataItem, "extracted-checksum", file.Sha1);
+      // file.packSha1IsDefined = ParseSha1(dataItem, "archived-checksum",  file.packSha1);
+      int encodingIndex = dataItem.FindSubTag("encoding");
+      if (encodingIndex >= 0)
+      {
+        const CXmlItem &encodingItem = dataItem.SubItems[encodingIndex];
+        if (encodingItem.IsTag)
+        {
+          AString s = encodingItem.GetPropVal("style");
+          if (s.Len() >= 0)
+          {
+            AString appl = "application/";
+            if (s.IsPrefixedBy(appl))
+            {
+              s.DeleteFrontal(appl.Len());
+              AString xx = "x-";
+              if (s.IsPrefixedBy(xx))
+              {
+                s.DeleteFrontal(xx.Len());
+                if (s == "gzip")
+                  s = METHOD_NAME_ZLIB;
+              }
+            }
+            file.Method = s;
+          }
+        }
+      }
+    }
+
+    file.CTime = ParseTime(item, "ctime");
+    file.MTime = ParseTime(item, "mtime");
+    file.ATime = ParseTime(item, "atime");
+
+    {
+      const AString s = item.GetSubStringForTag("mode");
+      if (s[0] == '0')
+      {
+        const char *end;
+        file.Mode = ConvertOctStringToUInt32(s, &end);
+        file.ModeDefined = (*end == 0);
+      }
+    }
+
+    file.User = item.GetSubStringForTag("user");
+    file.Group = item.GetSubStringForTag("group");
+
+    files.Add(file);
+  }
+  FOR_VECTOR (i, item.SubItems)
+    if (!AddItem(item.SubItems[i], files, parent))
+      return false;
+  return true;
+}
+
+HRESULT CHandler::Open2(IInStream *stream)
+{
+  const UInt32 kHeaderSize = 0x1C;
+  Byte buf[kHeaderSize];
+  RINOK(ReadStream_FALSE(stream, buf, kHeaderSize));
+
+  UInt32 size = Get16(buf + 4);
+  // UInt32 ver = Get16(buf + 6); // == 1
+  if (Get32(buf) != 0x78617221 || size != kHeaderSize)
+    return S_FALSE;
+
+  UInt64 packSize = Get64(buf + 8);
+  UInt64 unpackSize = Get64(buf + 0x10);
+
+  // _checkSumAlgo = Get32(buf + 0x18);
+
+  if (packSize >= kXmlPackSizeMax ||
+      unpackSize >= kXmlSizeMax)
+    return S_FALSE;
+
+  _dataStartPos = kHeaderSize + packSize;
+  _phySize = _dataStartPos;
+
+  _xml.Alloc((size_t)unpackSize + 1);
+  _xmlLen = (size_t)unpackSize;
+  
+  NCompress::NZlib::CDecoder *zlibCoderSpec = new NCompress::NZlib::CDecoder();
+  CMyComPtr<ICompressCoder> zlibCoder = zlibCoderSpec;
+
+  CLimitedSequentialInStream *inStreamLimSpec = new CLimitedSequentialInStream;
+  CMyComPtr<ISequentialInStream> inStreamLim(inStreamLimSpec);
+  inStreamLimSpec->SetStream(stream);
+  inStreamLimSpec->Init(packSize);
+
+  CBufPtrSeqOutStream *outStreamLimSpec = new CBufPtrSeqOutStream;
+  CMyComPtr<ISequentialOutStream> outStreamLim(outStreamLimSpec);
+  outStreamLimSpec->Init(_xml, (size_t)unpackSize);
+
+  RINOK(zlibCoder->Code(inStreamLim, outStreamLim, NULL, NULL, NULL));
+
+  if (outStreamLimSpec->GetPos() != (size_t)unpackSize)
+    return S_FALSE;
+
+  _xml[(size_t)unpackSize] = 0;
+  if (strlen((const char *)(const Byte *)_xml) != unpackSize) return S_FALSE;
+
+  CXml xml;
+  if (!xml.Parse((const char *)(const Byte *)_xml))
+    return S_FALSE;
+  
+  if (!xml.Root.IsTagged("xar") || xml.Root.SubItems.Size() != 1)
+    return S_FALSE;
+  const CXmlItem &toc = xml.Root.SubItems[0];
+  if (!toc.IsTagged("toc"))
+    return S_FALSE;
+  if (!AddItem(toc, _files, -1))
+    return S_FALSE;
+
+  UInt64 totalPackSize = 0;
+  unsigned numMainFiles = 0;
+  
+  FOR_VECTOR (i, _files)
+  {
+    const CFile &file = _files[i];
+    file.UpdateTotalPackSize(totalPackSize);
+    if (file.Name == "Payload")
+    {
+      _mainSubfile = i;
+      numMainFiles++;
+    }
+    if (file.Name == "PackageInfo")
+      _is_pkg = true;
+  }
+
+  if (numMainFiles > 1)
+    _mainSubfile = -1;
+  
+  _phySize = _dataStartPos + totalPackSize;
+
+  return S_OK;
+}
+
+STDMETHODIMP CHandler::Open(IInStream *stream,
+    const UInt64 * /* maxCheckStartPosition */,
+    IArchiveOpenCallback * /* openArchiveCallback */)
+{
+  COM_TRY_BEGIN
+  {
+    Close();
+    if (Open2(stream) != S_OK)
+      return S_FALSE;
+    _inStream = stream;
+  }
+  return S_OK;
+  COM_TRY_END
+}
+
+STDMETHODIMP CHandler::Close()
+{
+  _phySize = 0;
+  _inStream.Release();
+  _files.Clear();
+  _xmlLen = 0;
+  _xml.Free();
+  _mainSubfile = -1;
+  _is_pkg = false;
+  return S_OK;
+}
+
+STDMETHODIMP CHandler::GetNumberOfItems(UInt32 *numItems)
+{
+  *numItems = _files.Size()
+    #ifdef XAR_SHOW_RAW
+    + 1
+    #endif
+  ;
+  return S_OK;
+}
+
+static void TimeToProp(UInt64 t, NCOM::CPropVariant &prop)
+{
+  if (t != 0)
+  {
+    FILETIME ft;
+    ft.dwLowDateTime = (UInt32)(t);
+    ft.dwHighDateTime = (UInt32)(t >> 32);
+    prop = ft;
+  }
+}
+
+static void Utf8StringToProp(const AString &s, NCOM::CPropVariant &prop)
+{
+  if (!s.IsEmpty())
+  {
+    UString us;
+    if (ConvertUTF8ToUnicode(s, us))
+      prop = us;
+  }
+}
+
+STDMETHODIMP CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value)
+{
+  COM_TRY_BEGIN
+  NCOM::CPropVariant prop;
+  switch (propID)
+  {
+    case kpidHeadersSize: prop = _dataStartPos; break;
+    case kpidPhySize: prop = _phySize; break;
+    case kpidMainSubfile: if (_mainSubfile >= 0) prop = (UInt32)_mainSubfile; break;
+    case kpidSubType: if (_is_pkg) prop = "pkg"; break;
+    case kpidExtension: prop = _is_pkg ? "pkg" : "xar"; break;
+  }
+  prop.Detach(value);
+  return S_OK;
+  COM_TRY_END
+}
+
+STDMETHODIMP CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value)
+{
+  COM_TRY_BEGIN
+  NCOM::CPropVariant prop;
+  
+  #ifdef XAR_SHOW_RAW
+  if (index == _files.Size())
+  {
+    switch (propID)
+    {
+      case kpidPath: prop = "[TOC].xml"; break;
+      case kpidSize:
+      case kpidPackSize: prop = (UInt64)_xmlLen; break;
+    }
+  }
+  else
+  #endif
+  {
+    const CFile &item = _files[index];
+    switch (propID)
+    {
+      case kpidMethod: Utf8StringToProp(item.Method, prop); break;
+
+      case kpidPath:
+      {
+        AString path;
+        int cur = index;
+        do
+        {
+          const CFile &item2 = _files[cur];
+          if (!path.IsEmpty())
+            path.InsertAtFront(CHAR_PATH_SEPARATOR);
+          if (item2.Name.IsEmpty())
+            path.Insert(0, "unknown");
+          else
+            path.Insert(0, item2.Name);
+          cur = item2.Parent;
+        }
+        while (cur >= 0);
+
+        Utf8StringToProp(path, prop);
+        break;
+      }
+      
+      case kpidIsDir: prop = item.IsDir; break;
+      case kpidSize: if (!item.IsDir) prop = item.Size; break;
+      case kpidPackSize: if (!item.IsDir) prop = item.PackSize; break;
+      
+      case kpidMTime: TimeToProp(item.MTime, prop); break;
+      case kpidCTime: TimeToProp(item.CTime, prop); break;
+      case kpidATime: TimeToProp(item.ATime, prop); break;
+      case kpidPosixAttrib:
+        if (item.ModeDefined)
+        {
+          UInt32 mode = item.Mode;
+          if ((mode & MY_LIN_S_IFMT) == 0)
+            mode |= (item.IsDir ? MY_LIN_S_IFDIR : MY_LIN_S_IFREG);
+          prop = mode;
+        }
+        break;
+      case kpidUser: Utf8StringToProp(item.User, prop); break;
+      case kpidGroup: Utf8StringToProp(item.Group, prop); 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
+  bool allFilesMode = (numItems == (UInt32)(Int32)-1);
+  if (allFilesMode)
+    numItems = _files.Size();
+  if (numItems == 0)
+    return S_OK;
+  UInt64 totalSize = 0;
+  UInt32 i;
+  for (i = 0; i < numItems; i++)
+  {
+    UInt32 index = (allFilesMode ? i : indices[i]);
+    #ifdef XAR_SHOW_RAW
+    if (index == _files.Size())
+      totalSize += _xmlLen;
+    else
+    #endif
+      totalSize += _files[index].Size;
+  }
+  extractCallback->SetTotal(totalSize);
+
+  UInt64 currentPackTotal = 0;
+  UInt64 currentUnpTotal = 0;
+  UInt64 currentPackSize = 0;
+  UInt64 currentUnpSize = 0;
+
+  const UInt32 kZeroBufSize = (1 << 14);
+  CByteBuffer zeroBuf(kZeroBufSize);
+  memset(zeroBuf, 0, kZeroBufSize);
+  
+  NCompress::CCopyCoder *copyCoderSpec = new NCompress::CCopyCoder();
+  CMyComPtr<ICompressCoder> copyCoder = copyCoderSpec;
+
+  NCompress::NZlib::CDecoder *zlibCoderSpec = new NCompress::NZlib::CDecoder();
+  CMyComPtr<ICompressCoder> zlibCoder = zlibCoderSpec;
+  
+  NCompress::NBZip2::CDecoder *bzip2CoderSpec = new NCompress::NBZip2::CDecoder();
+  CMyComPtr<ICompressCoder> bzip2Coder = bzip2CoderSpec;
+
+  NCompress::NDeflate::NDecoder::CCOMCoder *deflateCoderSpec = new NCompress::NDeflate::NDecoder::CCOMCoder();
+  CMyComPtr<ICompressCoder> deflateCoder = deflateCoderSpec;
+
+  CLocalProgress *lps = new CLocalProgress;
+  CMyComPtr<ICompressProgressInfo> progress = lps;
+  lps->Init(extractCallback, false);
+
+  CLimitedSequentialInStream *inStreamSpec = new CLimitedSequentialInStream;
+  CMyComPtr<ISequentialInStream> inStream(inStreamSpec);
+  inStreamSpec->SetStream(_inStream);
+
+  
+  CLimitedSequentialOutStream *outStreamLimSpec = new CLimitedSequentialOutStream;
+  CMyComPtr<ISequentialOutStream> outStream(outStreamLimSpec);
+
+  COutStreamWithSha1 *outStreamSha1Spec = new COutStreamWithSha1;
+  {
+    CMyComPtr<ISequentialOutStream> outStreamSha1(outStreamSha1Spec);
+    outStreamLimSpec->SetStream(outStreamSha1);
+  }
+
+  for (i = 0; i < numItems; i++, currentPackTotal += currentPackSize, currentUnpTotal += currentUnpSize)
+  {
+    lps->InSize = currentPackTotal;
+    lps->OutSize = currentUnpTotal;
+    currentPackSize = 0;
+    currentUnpSize = 0;
+    RINOK(lps->SetCur());
+    CMyComPtr<ISequentialOutStream> realOutStream;
+    Int32 askMode = testMode ?
+        NExtract::NAskMode::kTest :
+        NExtract::NAskMode::kExtract;
+    UInt32 index = allFilesMode ? i : indices[i];
+    RINOK(extractCallback->GetStream(index, &realOutStream, askMode));
+    
+    if (index < _files.Size())
+    {
+      const CFile &item = _files[index];
+      if (item.IsDir)
+      {
+        RINOK(extractCallback->PrepareOperation(askMode));
+        RINOK(extractCallback->SetOperationResult(NExtract::NOperationResult::kOK));
+        continue;
+      }
+    }
+
+    if (!testMode && !realOutStream)
+      continue;
+    RINOK(extractCallback->PrepareOperation(askMode));
+
+    outStreamSha1Spec->SetStream(realOutStream);
+    realOutStream.Release();
+
+    Int32 opRes = NExtract::NOperationResult::kOK;
+    #ifdef XAR_SHOW_RAW
+    if (index == _files.Size())
+    {
+      outStreamSha1Spec->Init(false);
+      outStreamLimSpec->Init(_xmlLen);
+      RINOK(WriteStream(outStream, _xml, _xmlLen));
+      currentPackSize = currentUnpSize = _xmlLen;
+    }
+    else
+    #endif
+    {
+      const CFile &item = _files[index];
+      if (item.HasData)
+      {
+        currentPackSize = item.PackSize;
+        currentUnpSize = item.Size;
+        
+        RINOK(_inStream->Seek(_dataStartPos + item.Offset, STREAM_SEEK_SET, NULL));
+        inStreamSpec->Init(item.PackSize);
+        outStreamSha1Spec->Init(item.Sha1IsDefined);
+        outStreamLimSpec->Init(item.Size);
+        HRESULT res = S_OK;
+        
+        ICompressCoder *coder = NULL;
+        if (item.IsCopyMethod())
+          if (item.PackSize == item.Size)
+            coder = copyCoder;
+          else
+            opRes = NExtract::NOperationResult::kUnsupportedMethod;
+        else if (item.Method == METHOD_NAME_ZLIB)
+          coder = zlibCoder;
+        else if (item.Method == "bzip2")
+          coder = bzip2Coder;
+        else
+          opRes = NExtract::NOperationResult::kUnsupportedMethod;
+        
+        if (coder)
+          res = coder->Code(inStream, outStream, NULL, NULL, progress);
+        
+        if (res != S_OK)
+        {
+          if (!outStreamLimSpec->IsFinishedOK())
+            opRes = NExtract::NOperationResult::kDataError;
+          else if (res != S_FALSE)
+            return res;
+          if (opRes == NExtract::NOperationResult::kOK)
+            opRes = NExtract::NOperationResult::kDataError;
+        }
+
+        if (opRes == NExtract::NOperationResult::kOK)
+        {
+          if (outStreamLimSpec->IsFinishedOK() &&
+              outStreamSha1Spec->GetSize() == item.Size)
+          {
+            if (!outStreamLimSpec->IsFinishedOK())
+            {
+              opRes = NExtract::NOperationResult::kDataError;
+            }
+            else if (item.Sha1IsDefined)
+            {
+              Byte digest[SHA1_DIGEST_SIZE];
+              outStreamSha1Spec->Final(digest);
+              if (memcmp(digest, item.Sha1, SHA1_DIGEST_SIZE) != 0)
+                opRes = NExtract::NOperationResult::kCRCError;
+            }
+          }
+          else
+            opRes = NExtract::NOperationResult::kDataError;
+        }
+      }
+    }
+    outStreamSha1Spec->ReleaseStream();
+    RINOK(extractCallback->SetOperationResult(opRes));
+  }
+  return S_OK;
+  COM_TRY_END
+}
+
+STDMETHODIMP CHandler::GetStream(UInt32 index, ISequentialInStream **stream)
+{
+  *stream = NULL;
+  COM_TRY_BEGIN
+  #ifdef XAR_SHOW_RAW
+  if (index == _files.Size())
+  {
+    Create_BufInStream_WithNewBuffer(_xml, _xmlLen, stream);
+    return S_OK;
+  }
+  else
+  #endif
+  {
+    const CFile &item = _files[index];
+    if (item.HasData && item.IsCopyMethod() && item.PackSize == item.Size)
+      return CreateLimitedInStream(_inStream, _dataStartPos + item.Offset, item.Size, stream);
+  }
+  return S_FALSE;
+  COM_TRY_END
+}
+
+static const Byte k_Signature[] = { 'x', 'a', 'r', '!', 0, 0x1C };
+
+REGISTER_ARC_I(
+  "Xar", "xar pkg", 0, 0xE1,
+  k_Signature,
+  0,
+  0,
+  NULL)
+
+}}