tor-browser

OpenArchive.cpp (93545B)

---

// OpenArchive.cpp

#include "StdAfx.h"

// #define SHOW_DEBUG_INFO

#ifdef SHOW_DEBUG_INFO
#include <stdio.h>
#endif

#include "../../../../C/CpuArch.h"

#include "../../../Common/ComTry.h"
#include "../../../Common/IntToString.h"
#include "../../../Common/StringConvert.h"
#include "../../../Common/StringToInt.h"
#include "../../../Common/Wildcard.h"

#include "../../../Windows/FileDir.h"

#include "../../Common/FileStreams.h"
#include "../../Common/LimitedStreams.h"
#include "../../Common/ProgressUtils.h"
#include "../../Common/StreamUtils.h"

#include "../../Compress/CopyCoder.h"

#include "DefaultName.h"
#include "OpenArchive.h"

#ifndef _SFX
#include "SetProperties.h"
#endif

#ifdef SHOW_DEBUG_INFO
#define PRF(x) x
#else
#define PRF(x)
#endif

// increase it, if you need to support larger SFX stubs
static const UInt64 kMaxCheckStartPosition = 1 << 23;

/*
Open:
 - formatIndex >= 0 (exact Format)
      1) Open with main type. Archive handler is allowed to use archive start finder.
         Warning, if there is tail.
 
 - formatIndex = -1 (Parser:0) (default)
   - same as #1 but doesn't return Parser

 - formatIndex = -2 (#1)
   - file has supported extension (like a.7z)
     Open with that main type (only starting from start of file).
       - open OK:
           - if there is no tail - return OK
           - if there is tail:
             - archive is not "Self Exe" - return OK with Warning, that there is tail
             - archive is "Self Exe"
               ignore "Self Exe" stub, and tries to open tail
                 - tail can be open as archive - shows that archive and stub size property.
                 - tail can't be open as archive - shows Parser ???
       - open FAIL:
          Try to open with all other types from offset 0 only.
          If some open type is OK and physical archive size is uequal or larger
          than file size, then return that archive with warning that can not be open as [extension type].
          If extension was EXE, it will try to open as unknown_extension case
   - file has unknown extension (like a.hhh)
      It tries to open via parser code.
        - if there is full archive or tail archive and unknown block or "Self Exe"
          at front, it shows tail archive and stub size property.
        - in another cases, if there is some archive inside file, it returns parser/
        - in another cases, it retuens S_FALSE

      
 - formatIndex = -3 (#2)
   - same as #1, but
   - stub (EXE) + archive is open in Parser

 - formatIndex = -4 (#3)
   - returns only Parser. skip full file archive. And show other sub-archives

 - formatIndex = -5 (#4)
   - returns only Parser. skip full file archive. And show other sub-archives for each byte pos

*/




using namespace NWindows;

/*
#ifdef _SFX
#define OPEN_PROPS_PARAM
#else
#define OPEN_PROPS_PARAM  , props
#endif
*/

/*
CArc::~CArc()
{
 GetRawProps.Release();
 Archive.Release();
 printf("\nCArc::~CArc()\n");
}
*/

#ifndef _SFX

namespace NArchive {
namespace NParser {

struct CParseItem
{
 UInt64 Offset;
 UInt64 Size;
 // UInt64 OkSize;
 UString Name;
 UString Extension;
 FILETIME FileTime;
 UString Comment;
 UString ArcType;
 
 bool FileTime_Defined;
 bool UnpackSize_Defined;
 bool NumSubDirs_Defined;
 bool NumSubFiles_Defined;

 bool IsSelfExe;
 bool IsNotArcType;
 
 UInt64 UnpackSize;
 UInt64 NumSubDirs;
 UInt64 NumSubFiles;

 int FormatIndex;

 bool LenIsUnknown;

 CParseItem():
     LenIsUnknown(false),
     FileTime_Defined(false),
     UnpackSize_Defined(false),
     NumSubFiles_Defined(false),
     NumSubDirs_Defined(false),
     IsSelfExe(false),
     IsNotArcType(false)
     // OkSize(0)
   {}

 /*
 bool IsEqualTo(const CParseItem &item) const
 {
   return Offset == item.Offset && Size == item.Size;
 }
 */

 void NormalizeOffset()
 {
   if ((Int64)Offset < 0)
   {
     Size += Offset;
     // OkSize += Offset;
     Offset = 0;
   }
 }
};

class CHandler:
 public IInArchive,
 public IInArchiveGetStream,
 public CMyUnknownImp
{
public:
 CObjectVector<CParseItem> _items;
 UInt64 _maxEndOffset;
 CMyComPtr<IInStream> _stream;

 MY_UNKNOWN_IMP2(
   IInArchive,
   IInArchiveGetStream)

 INTERFACE_IInArchive(;)
 STDMETHOD(GetStream)(UInt32 index, ISequentialInStream **stream);

 UInt64 GetLastEnd() const
 {
   if (_items.IsEmpty())
     return 0;
   const CParseItem &back = _items.Back();
   return back.Offset + back.Size;
 }

 void AddUnknownItem(UInt64 next);
 int FindInsertPos(const CParseItem &item) const;
 void AddItem(const CParseItem &item);
 
 CHandler(): _maxEndOffset(0) {}
};

int CHandler::FindInsertPos(const CParseItem &item) const
{
 unsigned left = 0, right = _items.Size();
 while (left != right)
 {
   unsigned mid = (left + right) / 2;
   const CParseItem & midItem = _items[mid];
   if (item.Offset < midItem.Offset)
     right = mid;
   else if (item.Offset > midItem.Offset)
     left = mid + 1;
   else if (item.Size < midItem.Size)
     right = mid;
   else if (item.Size > midItem.Size)
     left = mid + 1;
   else
   {
     left = mid + 1;
     // return -1;
   }
 }
 return left;
}

void CHandler::AddUnknownItem(UInt64 next)
{
 /*
 UInt64 prevEnd = 0;
 if (!_items.IsEmpty())
 {
   const CParseItem &back = _items.Back();
   prevEnd = back.Offset + back.Size;
 }
 */
 if (_maxEndOffset < next)
 {
   CParseItem item2;
   item2.Offset = _maxEndOffset;
   item2.Size = next - _maxEndOffset;
   _maxEndOffset = next;
   _items.Add(item2);
 }
 else if (_maxEndOffset > next && !_items.IsEmpty())
 {
   CParseItem &back = _items.Back();
   if (back.LenIsUnknown)
   {
     back.Size = next - back.Offset;
     _maxEndOffset = next;
   }
 }
}

void CHandler::AddItem(const CParseItem &item)
{
 AddUnknownItem(item.Offset);
 int pos = FindInsertPos(item);
 if (pos >= 0)
 {
   _items.Insert(pos, item);
   UInt64 next = item.Offset + item.Size;
   if (_maxEndOffset < next)
     _maxEndOffset = next;
 }
}

/*
static const CStatProp kProps[] =
{
 { NULL, kpidPath, VT_BSTR},
 { NULL, kpidSize, VT_UI8},
 { NULL, kpidMTime, VT_FILETIME},
 { NULL, kpidType, VT_BSTR},
 { NULL, kpidComment, VT_BSTR},
 { NULL, kpidOffset, VT_UI8},
 { NULL, kpidUnpackSize, VT_UI8},
//   { NULL, kpidNumSubDirs, VT_UI8},
};
*/

static const Byte kProps[] =
{
 kpidPath,
 kpidSize,
 kpidMTime,
 kpidType,
 kpidComment,
 kpidOffset,
 kpidUnpackSize
};

IMP_IInArchive_Props
IMP_IInArchive_ArcProps_NO

STDMETHODIMP CHandler::Open(IInStream *stream, const UInt64 *, IArchiveOpenCallback * /* openArchiveCallback */)
{
 COM_TRY_BEGIN
 {
   Close();
   _stream = stream;
 }
 return S_OK;
 COM_TRY_END
}

STDMETHODIMP CHandler::Close()
{
 _items.Clear();
 _stream.Release();
 return S_OK;
}

STDMETHODIMP CHandler::GetNumberOfItems(UInt32 *numItems)
{
 *numItems = _items.Size();
 return S_OK;
}

STDMETHODIMP CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value)
{
 COM_TRY_BEGIN
 NCOM::CPropVariant prop;

 const CParseItem &item = _items[index];

 switch (propID)
 {
   case kpidPath:
   {
     char sz[32];
     ConvertUInt32ToString(index + 1, sz);
     UString s(sz);
     if (!item.Name.IsEmpty())
     {
       s += '.';
       s += item.Name;
     }
     if (!item.Extension.IsEmpty())
     {
       s += '.';
       s += item.Extension;
     }
     prop = s; break;
   }
   case kpidSize:
   case kpidPackSize: prop = item.Size; break;
   case kpidOffset: prop = item.Offset; break;
   case kpidUnpackSize: if (item.UnpackSize_Defined) prop = item.UnpackSize; break;
   case kpidNumSubFiles: if (item.NumSubFiles_Defined) prop = item.NumSubFiles; break;
   case kpidNumSubDirs: if (item.NumSubDirs_Defined) prop = item.NumSubDirs; break;
   case kpidMTime: if (item.FileTime_Defined) prop = item.FileTime; break;
   case kpidComment: if (!item.Comment.IsEmpty()) prop = item.Comment; break;
   case kpidType: if (!item.ArcType.IsEmpty()) prop = item.ArcType; break;
 }
 prop.Detach(value);
 return S_OK;
 COM_TRY_END
}

HRESULT CHandler::Extract(const UInt32 *indices, UInt32 numItems,
   Int32 testMode, IArchiveExtractCallback *extractCallback)
{
 COM_TRY_BEGIN
 
 bool allFilesMode = (numItems == (UInt32)(Int32)-1);
 if (allFilesMode)
   numItems = _items.Size();
 if (_stream && numItems == 0)
   return S_OK;
 UInt64 totalSize = 0;
 UInt32 i;
 for (i = 0; i < numItems; i++)
   totalSize += _items[allFilesMode ? i : indices[i]].Size;
 extractCallback->SetTotal(totalSize);

 totalSize = 0;
 
 CLocalProgress *lps = new CLocalProgress;
 CMyComPtr<ICompressProgressInfo> progress = lps;
 lps->Init(extractCallback, false);

 CLimitedSequentialInStream *streamSpec = new CLimitedSequentialInStream;
 CMyComPtr<ISequentialInStream> inStream(streamSpec);
 streamSpec->SetStream(_stream);

 CLimitedSequentialOutStream *outStreamSpec = new CLimitedSequentialOutStream;
 CMyComPtr<ISequentialOutStream> outStream(outStreamSpec);

 NCompress::CCopyCoder *copyCoderSpec = new NCompress::CCopyCoder();
 CMyComPtr<ICompressCoder> copyCoder = copyCoderSpec;

 for (i = 0; i < numItems; i++)
 {
   lps->InSize = totalSize;
   lps->OutSize = totalSize;
   RINOK(lps->SetCur());
   CMyComPtr<ISequentialOutStream> realOutStream;
   Int32 askMode = testMode ?
       NExtract::NAskMode::kTest :
       NExtract::NAskMode::kExtract;
   Int32 index = allFilesMode ? i : indices[i];
   const CParseItem &item = _items[index];

   RINOK(extractCallback->GetStream(index, &realOutStream, askMode));
   UInt64 unpackSize = item.Size;
   totalSize += unpackSize;
   bool skipMode = false;
   if (!testMode && !realOutStream)
     continue;
   RINOK(extractCallback->PrepareOperation(askMode));

   outStreamSpec->SetStream(realOutStream);
   realOutStream.Release();
   outStreamSpec->Init(skipMode ? 0 : unpackSize, true);

   Int32 opRes = NExtract::NOperationResult::kOK;
   RINOK(_stream->Seek(item.Offset, STREAM_SEEK_SET, NULL));
   streamSpec->Init(unpackSize);
   RINOK(copyCoder->Code(inStream, outStream, NULL, NULL, progress));

   if (outStreamSpec->GetRem() != 0)
     opRes = NExtract::NOperationResult::kDataError;
   outStreamSpec->ReleaseStream();
   RINOK(extractCallback->SetOperationResult(opRes));
 }
 
 return S_OK;
 
 COM_TRY_END
}


STDMETHODIMP CHandler::GetStream(UInt32 index, ISequentialInStream **stream)
{
 COM_TRY_BEGIN
 const CParseItem &item = _items[index];
 return CreateLimitedInStream(_stream, item.Offset, item.Size, stream);
 COM_TRY_END
}

}}

#endif

HRESULT Archive_GetItemBoolProp(IInArchive *arc, UInt32 index, PROPID propID, bool &result) throw()
{
 NCOM::CPropVariant prop;
 result = false;
 RINOK(arc->GetProperty(index, propID, &prop));
 if (prop.vt == VT_BOOL)
   result = VARIANT_BOOLToBool(prop.boolVal);
 else if (prop.vt != VT_EMPTY)
   return E_FAIL;
 return S_OK;
}

HRESULT Archive_IsItem_Dir(IInArchive *arc, UInt32 index, bool &result) throw()
{
 return Archive_GetItemBoolProp(arc, index, kpidIsDir, result);
}

HRESULT Archive_IsItem_Aux(IInArchive *arc, UInt32 index, bool &result) throw()
{
 return Archive_GetItemBoolProp(arc, index, kpidIsAux, result);
}

HRESULT Archive_IsItem_AltStream(IInArchive *arc, UInt32 index, bool &result) throw()
{
 return Archive_GetItemBoolProp(arc, index, kpidIsAltStream, result);
}

HRESULT Archive_IsItem_Deleted(IInArchive *arc, UInt32 index, bool &result) throw()
{
 return Archive_GetItemBoolProp(arc, index, kpidIsDeleted, result);
}

static HRESULT Archive_GetArcBoolProp(IInArchive *arc, PROPID propid, bool &result) throw()
{
 NCOM::CPropVariant prop;
 result = false;
 RINOK(arc->GetArchiveProperty(propid, &prop));
 if (prop.vt == VT_BOOL)
   result = VARIANT_BOOLToBool(prop.boolVal);
 else if (prop.vt != VT_EMPTY)
   return E_FAIL;
 return S_OK;
}

static HRESULT Archive_GetArcProp_UInt(IInArchive *arc, PROPID propid, UInt64 &result, bool &defined)
{
 defined = false;
 NCOM::CPropVariant prop;
 RINOK(arc->GetArchiveProperty(propid, &prop));
 switch (prop.vt)
 {
   case VT_UI4: result = prop.ulVal; defined = true; break;
   case VT_I4: result = (Int64)prop.lVal; defined = true; break;
   case VT_UI8: result = (UInt64)prop.uhVal.QuadPart; defined = true; break;
   case VT_I8: result = (UInt64)prop.hVal.QuadPart; defined = true; break;
   case VT_EMPTY: break;
   default: return E_FAIL;
 }
 return S_OK;
}

static HRESULT Archive_GetArcProp_Int(IInArchive *arc, PROPID propid, Int64 &result, bool &defined)
{
 defined = false;
 NCOM::CPropVariant prop;
 RINOK(arc->GetArchiveProperty(propid, &prop));
 switch (prop.vt)
 {
   case VT_UI4: result = prop.ulVal; defined = true; break;
   case VT_I4: result = prop.lVal; defined = true; break;
   case VT_UI8: result = (Int64)prop.uhVal.QuadPart; defined = true; break;
   case VT_I8: result = (Int64)prop.hVal.QuadPart; defined = true; break;
   case VT_EMPTY: break;
   default: return E_FAIL;
 }
 return S_OK;
}

#ifndef _SFX

HRESULT CArc::GetItemPathToParent(UInt32 index, UInt32 parent, UStringVector &parts) const
{
 if (!GetRawProps)
   return E_FAIL;
 if (index == parent)
   return S_OK;
 UInt32 curIndex = index;
 
 UString s;
 
 bool prevWasAltStream = false;
 
 for (;;)
 {
   #ifdef MY_CPU_LE
   const void *p;
   UInt32 size;
   UInt32 propType;
   RINOK(GetRawProps->GetRawProp(curIndex, kpidName, &p, &size, &propType));
   if (p && propType == PROP_DATA_TYPE_wchar_t_PTR_Z_LE)
     s = (const wchar_t *)p;
   else
   #endif
   {
     NCOM::CPropVariant prop;
     RINOK(Archive->GetProperty(curIndex, kpidName, &prop));
     if (prop.vt == VT_BSTR && prop.bstrVal)
       s.SetFromBstr(prop.bstrVal);
     else if (prop.vt == VT_EMPTY)
       s.Empty();
     else
       return E_FAIL;
   }

   UInt32 curParent = (UInt32)(Int32)-1;
   UInt32 parentType = 0;
   RINOK(GetRawProps->GetParent(curIndex, &curParent, &parentType));

   if (parentType != NParentType::kAltStream)
   {
     for (;;)
     {
       int pos = s.ReverseFind_PathSepar();
       if (pos < 0)
       {
         break;
       }
       parts.Insert(0, s.Ptr(pos + 1));
       s.DeleteFrom(pos);
     }
   }
   
   parts.Insert(0, s);

   if (prevWasAltStream)
   {
     {
       UString &s2 = parts[parts.Size() - 2];
       s2 += ':';
       s2 += parts.Back();
     }
     parts.DeleteBack();
   }

   if (parent == curParent)
     return S_OK;
   
   prevWasAltStream = false;
   if (parentType == NParentType::kAltStream)
     prevWasAltStream = true;
   
   if (curParent == (UInt32)(Int32)-1)
     return E_FAIL;
   curIndex = curParent;
 }
}

#endif

HRESULT CArc::GetItemPath(UInt32 index, UString &result) const
{
 #ifdef MY_CPU_LE
 if (GetRawProps)
 {
   const void *p;
   UInt32 size;
   UInt32 propType;
   if (!IsTree)
   {
     if (GetRawProps->GetRawProp(index, kpidPath, &p, &size, &propType) == S_OK &&
         propType == NPropDataType::kUtf16z)
     {
       unsigned len = size / 2 - 1;
       wchar_t *s = result.GetBuf(len);
       for (unsigned i = 0; i < len; i++)
       {
         wchar_t c = GetUi16(p);
         p = (const void *)((const Byte *)p + 2);
         #if WCHAR_PATH_SEPARATOR != L'/'
         if (c == L'/')
           c = WCHAR_PATH_SEPARATOR;
         #endif
         *s++ = c;
       }
       *s = 0;
       result.ReleaseBuf_SetLen(len);
       if (len != 0)
         return S_OK;
     }
   }
   /*
   else if (GetRawProps->GetRawProp(index, kpidName, &p, &size, &propType) == S_OK &&
       p && propType == NPropDataType::kUtf16z)
   {
     size -= 2;
     UInt32 totalSize = size;
     bool isOK = false;
     
     {
       UInt32 index2 = index;
       for (;;)
       {
         UInt32 parent = (UInt32)(Int32)-1;
         UInt32 parentType = 0;
         if (GetRawProps->GetParent(index2, &parent, &parentType) != S_OK)
           break;
         if (parent == (UInt32)(Int32)-1)
         {
           if (parentType != 0)
             totalSize += 2;
           isOK = true;
           break;
         }
         index2 = parent;
         UInt32 size2;
         const void *p2;
         if (GetRawProps->GetRawProp(index2, kpidName, &p2, &size2, &propType) != S_OK &&
             p2 && propType == NPropDataType::kUtf16z)
           break;
         totalSize += size2;
       }
     }

     if (isOK)
     {
       wchar_t *sz = result.GetBuf_SetEnd(totalSize / 2);
       UInt32 pos = totalSize - size;
       memcpy((Byte *)sz + pos, p, size);
       UInt32 index2 = index;
       for (;;)
       {
         UInt32 parent = (UInt32)(Int32)-1;
         UInt32 parentType = 0;
         if (GetRawProps->GetParent(index2, &parent, &parentType) != S_OK)
           break;
         if (parent == (UInt32)(Int32)-1)
         {
           if (parentType != 0)
             sz[pos / 2 - 1] = L':';
           break;
         }
         index2 = parent;
         UInt32 size2;
         const void *p2;
         if (GetRawProps->GetRawProp(index2, kpidName, &p2, &size2, &propType) != S_OK)
           break;
         pos -= size2;
         memcpy((Byte *)sz + pos, p2, size2);
         sz[(pos + size2 - 2) / 2] = (parentType == 0) ? WCHAR_PATH_SEPARATOR : L':';
       }
       #ifdef _WIN32
       // result.Replace(L'/', WCHAR_PATH_SEPARATOR);
       #endif
       return S_OK;
     }
   }
   */
 }
 #endif
 
 {
   NCOM::CPropVariant prop;
   RINOK(Archive->GetProperty(index, kpidPath, &prop));
   if (prop.vt == VT_BSTR && prop.bstrVal)
     result.SetFromBstr(prop.bstrVal);
   else if (prop.vt == VT_EMPTY)
     result.Empty();
   else
     return E_FAIL;
 }
 
 if (result.IsEmpty())
   return GetDefaultItemPath(index, result);
 return S_OK;
}

HRESULT CArc::GetDefaultItemPath(UInt32 index, UString &result) const
{
 result.Empty();
 bool isDir;
 RINOK(Archive_IsItem_Dir(Archive, index, isDir));
 if (!isDir)
 {
   result = DefaultName;
   NCOM::CPropVariant prop;
   RINOK(Archive->GetProperty(index, kpidExtension, &prop));
   if (prop.vt == VT_BSTR)
   {
     result += '.';
     result += prop.bstrVal;
   }
   else if (prop.vt != VT_EMPTY)
     return E_FAIL;
 }
 return S_OK;
}

HRESULT CArc::GetItemPath2(UInt32 index, UString &result) const
{
 RINOK(GetItemPath(index, result));
 if (Ask_Deleted)
 {
   bool isDeleted = false;
   RINOK(Archive_IsItem_Deleted(Archive, index, isDeleted));
   if (isDeleted)
     result.Insert(0, L"[DELETED]" WSTRING_PATH_SEPARATOR);
 }
 return S_OK;
}

#ifdef SUPPORT_ALT_STREAMS

int FindAltStreamColon_in_Path(const wchar_t *path)
{
 unsigned i = 0;
 int colonPos = -1;
 for (;; i++)
 {
   wchar_t c = path[i];
   if (c == 0)
     return colonPos;
   if (c == ':')
   {
     if (colonPos < 0)
       colonPos = i;
     continue;
   }
   if (c == WCHAR_PATH_SEPARATOR)
     colonPos = -1;
 }
}

#endif

HRESULT CArc::GetItem(UInt32 index, CReadArcItem &item) const
{
 #ifdef SUPPORT_ALT_STREAMS
 item.IsAltStream = false;
 item.AltStreamName.Empty();
 item.MainPath.Empty();
 #endif

 item.IsDir = false;
 item.Path.Empty();
 item.ParentIndex = (UInt32)(Int32)-1;
 
 item.PathParts.Clear();

 RINOK(Archive_IsItem_Dir(Archive, index, item.IsDir));
 item.MainIsDir = item.IsDir;

 RINOK(GetItemPath2(index, item.Path));

 #ifndef _SFX
 UInt32 mainIndex = index;
 #endif

 #ifdef SUPPORT_ALT_STREAMS

 item.MainPath = item.Path;
 if (Ask_AltStream)
 {
   RINOK(Archive_IsItem_AltStream(Archive, index, item.IsAltStream));
 }
 
 bool needFindAltStream = false;

 if (item.IsAltStream)
 {
   needFindAltStream = true;
   if (GetRawProps)
   {
     UInt32 parentType = 0;
     UInt32 parentIndex;
     RINOK(GetRawProps->GetParent(index, &parentIndex, &parentType));
     if (parentType == NParentType::kAltStream)
     {
       NCOM::CPropVariant prop;
       RINOK(Archive->GetProperty(index, kpidName, &prop));
       if (prop.vt == VT_BSTR && prop.bstrVal)
         item.AltStreamName.SetFromBstr(prop.bstrVal);
       else if (prop.vt != VT_EMPTY)
         return E_FAIL;
       else
       {
         // item.IsAltStream = false;
       }
       /*
       if (item.AltStreamName.IsEmpty())
         item.IsAltStream = false;
       */

       needFindAltStream = false;
       item.ParentIndex = parentIndex;
       mainIndex = parentIndex;

       if (parentIndex == (UInt32)(Int32)-1)
       {
         item.MainPath.Empty();
         item.MainIsDir = true;
       }
       else
       {
         RINOK(GetItemPath2(parentIndex, item.MainPath));
         RINOK(Archive_IsItem_Dir(Archive, parentIndex, item.MainIsDir));
       }
     }
   }
 }

 if (item.WriteToAltStreamIfColon || needFindAltStream)
 {
   /* Good handler must support GetRawProps::GetParent for alt streams.
      So the following code currently is not used */
   int colon = FindAltStreamColon_in_Path(item.Path);
   if (colon >= 0)
   {
     item.MainPath.DeleteFrom(colon);
     item.AltStreamName = item.Path.Ptr(colon + 1);
     item.MainIsDir = (colon == 0 || IsPathSepar(item.Path[(unsigned)colon - 1]));
     item.IsAltStream = true;
   }
 }

 #endif
 
 #ifndef _SFX
 if (item._use_baseParentFolder_mode)
 {
   RINOK(GetItemPathToParent(mainIndex, item._baseParentFolder, item.PathParts));
   
   #ifdef SUPPORT_ALT_STREAMS
   if ((item.WriteToAltStreamIfColon || needFindAltStream) && !item.PathParts.IsEmpty())
   {
     int colon;
     {
       UString &s = item.PathParts.Back();
       colon = FindAltStreamColon_in_Path(s);
       if (colon >= 0)
       {
         item.AltStreamName = s.Ptr(colon + 1);
         item.MainIsDir = (colon == 0 || IsPathSepar(s[(unsigned)colon - 1]));
         item.IsAltStream = true;
         s.DeleteFrom(colon);
       }
     }
     if (colon == 0)
       item.PathParts.DeleteBack();
   }
   #endif
   
 }
 else
 #endif
   SplitPathToParts(
         #ifdef SUPPORT_ALT_STREAMS
           item.MainPath
         #else
           item.Path
         #endif
     , item.PathParts);

 return S_OK;
}

#ifndef _SFX

static HRESULT Archive_GetItem_Size(IInArchive *archive, UInt32 index, UInt64 &size, bool &defined)
{
 NCOM::CPropVariant prop;
 defined = false;
 size = 0;
 RINOK(archive->GetProperty(index, kpidSize, &prop));
 switch (prop.vt)
 {
   case VT_UI1: size = prop.bVal; break;
   case VT_UI2: size = prop.uiVal; break;
   case VT_UI4: size = prop.ulVal; break;
   case VT_UI8: size = (UInt64)prop.uhVal.QuadPart; break;
   case VT_EMPTY: return S_OK;
   default: return E_FAIL;
 }
 defined = true;
 return S_OK;
}

#endif

HRESULT CArc::GetItemSize(UInt32 index, UInt64 &size, bool &defined) const
{
 NCOM::CPropVariant prop;
 defined = false;
 size = 0;
 RINOK(Archive->GetProperty(index, kpidSize, &prop));
 switch (prop.vt)
 {
   case VT_UI1: size = prop.bVal; break;
   case VT_UI2: size = prop.uiVal; break;
   case VT_UI4: size = prop.ulVal; break;
   case VT_UI8: size = (UInt64)prop.uhVal.QuadPart; break;
   case VT_EMPTY: return S_OK;
   default: return E_FAIL;
 }
 defined = true;
 return S_OK;
}

HRESULT CArc::GetItemMTime(UInt32 index, FILETIME &ft, bool &defined) const
{
 NCOM::CPropVariant prop;
 defined = false;
 ft.dwHighDateTime = ft.dwLowDateTime = 0;
 RINOK(Archive->GetProperty(index, kpidMTime, &prop));
 if (prop.vt == VT_FILETIME)
 {
   ft = prop.filetime;
   defined = true;
 }
 else if (prop.vt != VT_EMPTY)
   return E_FAIL;
 else if (MTimeDefined)
 {
   ft = MTime;
   defined = true;
 }
 return S_OK;
}

#ifndef _SFX

static inline bool TestSignature(const Byte *p1, const Byte *p2, size_t size)
{
 for (size_t i = 0; i < size; i++)
   if (p1[i] != p2[i])
     return false;
 return true;
}

static void MakeCheckOrder(CCodecs *codecs,
   CIntVector &orderIndices, unsigned numTypes, CIntVector &orderIndices2,
   const Byte *data, size_t dataSize)
{
 for (unsigned i = 0; i < numTypes; i++)
 {
   int index = orderIndices[i];
   if (index < 0)
     continue;
   const CArcInfoEx &ai = codecs->Formats[(unsigned)index];
   if (ai.SignatureOffset != 0)
   {
     orderIndices2.Add(index);
     orderIndices[i] = -1;
     continue;
   }

   const CObjectVector<CByteBuffer> &sigs = ai.Signatures;
   FOR_VECTOR (k, sigs)
   {
     const CByteBuffer &sig = sigs[k];
     if (sig.Size() == 0 && dataSize == 0 ||
         sig.Size() != 0 && sig.Size() <= dataSize &&
         TestSignature(data, sig, sig.Size()))
     {
       orderIndices2.Add(index);
       orderIndices[i] = -1;
       break;
     }
   }
 }
}

#endif

#ifdef UNDER_CE
 static const unsigned kNumHashBytes = 1;
 #define HASH_VAL(buf) ((buf)[0])
#else
 static const unsigned kNumHashBytes = 2;
 // #define HASH_VAL(buf) ((buf)[0] | ((UInt32)(buf)[1] << 8))
 #define HASH_VAL(buf) GetUi16(buf)
#endif


#ifndef _SFX

static bool IsExeExt(const UString &ext)
{
 return ext.IsEqualTo_Ascii_NoCase("exe");
}

static const char * const k_PreArcFormats[] =
{
   "pe"
 , "elf"
 , "macho"
 , "mub"
 , "te"
};

static bool IsNameFromList(const UString &s, const char * const names[], size_t num)
{
 for (unsigned i = 0; i < num; i++)
   if (StringsAreEqualNoCase_Ascii(s, names[i]))
     return true;
 return false;
}


static bool IsPreArcFormat(const CArcInfoEx &ai)
{
 if (ai.Flags_PreArc())
   return true;
 return IsNameFromList(ai.Name, k_PreArcFormats, ARRAY_SIZE(k_PreArcFormats));
}

static const char * const k_Formats_with_simple_signuature[] =
{
   "7z"
 , "xz"
 , "rar"
 , "bzip2"
 , "gzip"
 , "cab"
 , "wim"
 , "rpm"
 , "vhd"
 , "xar"
};

static bool IsNewStyleSignature(const CArcInfoEx &ai)
{
 // if (ai.Version >= 0x91F)
 if (ai.NewInterface)
   return true;
 return IsNameFromList(ai.Name, k_Formats_with_simple_signuature, ARRAY_SIZE(k_Formats_with_simple_signuature));
}

class CArchiveOpenCallback_Offset:
 public IArchiveOpenCallback,
 public IArchiveOpenVolumeCallback,
 #ifndef _NO_CRYPTO
 public ICryptoGetTextPassword,
 #endif
 public CMyUnknownImp
{
public:
 CMyComPtr<IArchiveOpenCallback> Callback;
 CMyComPtr<IArchiveOpenVolumeCallback> OpenVolumeCallback;
 UInt64 Files;
 UInt64 Offset;
 
 #ifndef _NO_CRYPTO
 CMyComPtr<ICryptoGetTextPassword> GetTextPassword;
 #endif

 MY_QUERYINTERFACE_BEGIN2(IArchiveOpenCallback)
 MY_QUERYINTERFACE_ENTRY(IArchiveOpenVolumeCallback)
 #ifndef _NO_CRYPTO
 MY_QUERYINTERFACE_ENTRY(ICryptoGetTextPassword)
 #endif
 MY_QUERYINTERFACE_END
 MY_ADDREF_RELEASE

 INTERFACE_IArchiveOpenCallback(;)
 INTERFACE_IArchiveOpenVolumeCallback(;)
 #ifndef _NO_CRYPTO
 STDMETHOD(CryptoGetTextPassword)(BSTR *password);
 #endif
};

#ifndef _NO_CRYPTO
STDMETHODIMP CArchiveOpenCallback_Offset::CryptoGetTextPassword(BSTR *password)
{
 COM_TRY_BEGIN
 if (GetTextPassword)
   return GetTextPassword->CryptoGetTextPassword(password);
 return E_NOTIMPL;
 COM_TRY_END
}
#endif

STDMETHODIMP CArchiveOpenCallback_Offset::SetTotal(const UInt64 *, const UInt64 *)
{
 return S_OK;
}

STDMETHODIMP CArchiveOpenCallback_Offset::SetCompleted(const UInt64 *, const UInt64 *bytes)
{
 if (!Callback)
   return S_OK;
 UInt64 value = Offset;
 if (bytes)
   value += *bytes;
 return Callback->SetCompleted(&Files, &value);
}

STDMETHODIMP CArchiveOpenCallback_Offset::GetProperty(PROPID propID, PROPVARIANT *value)
{
 if (OpenVolumeCallback)
   return OpenVolumeCallback->GetProperty(propID, value);
 NCOM::PropVariant_Clear(value);
 return S_OK;
 // return E_NOTIMPL;
}

STDMETHODIMP CArchiveOpenCallback_Offset::GetStream(const wchar_t *name, IInStream **inStream)
{
 if (OpenVolumeCallback)
   return OpenVolumeCallback->GetStream(name, inStream);
 return S_FALSE;
}

#endif


UInt32 GetOpenArcErrorFlags(const NCOM::CPropVariant &prop, bool *isDefinedProp)
{
 if (isDefinedProp != NULL)
   *isDefinedProp = false;

 switch (prop.vt)
 {
   case VT_UI8: if (isDefinedProp) *isDefinedProp = true; return (UInt32)prop.uhVal.QuadPart;
   case VT_UI4: if (isDefinedProp) *isDefinedProp = true; return prop.ulVal;
   case VT_EMPTY: return 0;
   default: throw 151199;
 }
}

void CArcErrorInfo::ClearErrors()
{
 // ErrorFormatIndex = -1; // we don't need to clear ErrorFormatIndex here !!!

 ThereIsTail = false;
 UnexpecedEnd = false;
 IgnoreTail = false;
 // NonZerosTail = false;
 ErrorFlags_Defined = false;
 ErrorFlags = 0;
 WarningFlags = 0;
 TailSize = 0;

 ErrorMessage.Empty();
 WarningMessage.Empty();
}

HRESULT CArc::ReadBasicProps(IInArchive *archive, UInt64 startPos, HRESULT openRes)
{
 // OkPhySize_Defined = false;
 PhySizeDefined = false;
 PhySize = 0;
 Offset = 0;
 AvailPhySize = FileSize - startPos;

 ErrorInfo.ClearErrors();
 {
   NCOM::CPropVariant prop;
   RINOK(archive->GetArchiveProperty(kpidErrorFlags, &prop));
   ErrorInfo.ErrorFlags = GetOpenArcErrorFlags(prop, &ErrorInfo.ErrorFlags_Defined);
 }
 {
   NCOM::CPropVariant prop;
   RINOK(archive->GetArchiveProperty(kpidWarningFlags, &prop));
   ErrorInfo.WarningFlags = GetOpenArcErrorFlags(prop);
 }

 {
   NCOM::CPropVariant prop;
   RINOK(archive->GetArchiveProperty(kpidError, &prop));
   if (prop.vt != VT_EMPTY)
     ErrorInfo.ErrorMessage = (prop.vt == VT_BSTR ? prop.bstrVal : L"Unknown error");
 }
 
 {
   NCOM::CPropVariant prop;
   RINOK(archive->GetArchiveProperty(kpidWarning, &prop));
   if (prop.vt != VT_EMPTY)
     ErrorInfo.WarningMessage = (prop.vt == VT_BSTR ? prop.bstrVal : L"Unknown warning");
 }
 
 if (openRes == S_OK || ErrorInfo.IsArc_After_NonOpen())
 {
   RINOK(Archive_GetArcProp_UInt(archive, kpidPhySize, PhySize, PhySizeDefined));
   /*
   RINOK(Archive_GetArcProp_UInt(archive, kpidOkPhySize, OkPhySize, OkPhySize_Defined));
   if (!OkPhySize_Defined)
   {
     OkPhySize_Defined = PhySizeDefined;
     OkPhySize = PhySize;
   }
   */

   bool offsetDefined;
   RINOK(Archive_GetArcProp_Int(archive, kpidOffset, Offset, offsetDefined));

   Int64 globalOffset = startPos + Offset;
   AvailPhySize = FileSize - globalOffset;
   if (PhySizeDefined)
   {
     UInt64 endPos = globalOffset + PhySize;
     if (endPos < FileSize)
     {
       AvailPhySize = PhySize;
       ErrorInfo.ThereIsTail = true;
       ErrorInfo.TailSize = FileSize - endPos;
     }
     else if (endPos > FileSize)
       ErrorInfo.UnexpecedEnd = true;
   }
 }

 return S_OK;
}

/*
static PrintNumber(const char *s, int n)
{
 char temp[100];
 sprintf(temp, "%s %d", s, n);
 OutputDebugStringA(temp);
}
*/

HRESULT CArc::PrepareToOpen(const COpenOptions &op, unsigned formatIndex, CMyComPtr<IInArchive> &archive)
{
 // OutputDebugStringA("a1");
 // PrintNumber("formatIndex", formatIndex);
   
 RINOK(op.codecs->CreateInArchive(formatIndex, archive));
 // OutputDebugStringA("a2");
 if (!archive)
   return S_OK;

 #ifdef EXTERNAL_CODECS
 if (op.codecs->NeedSetLibCodecs)
 {
   const CArcInfoEx &ai = op.codecs->Formats[formatIndex];
   if (ai.LibIndex >= 0 ?
       !op.codecs->Libs[ai.LibIndex].SetCodecs :
       !op.codecs->Libs.IsEmpty())
   {
     CMyComPtr<ISetCompressCodecsInfo> setCompressCodecsInfo;
     archive.QueryInterface(IID_ISetCompressCodecsInfo, (void **)&setCompressCodecsInfo);
     if (setCompressCodecsInfo)
     {
       RINOK(setCompressCodecsInfo->SetCompressCodecsInfo(op.codecs));
     }
   }
 }
 #endif
 
 
 #ifndef _SFX

 const CArcInfoEx &ai = op.codecs->Formats[formatIndex];

 // OutputDebugStringW(ai.Name);
 // OutputDebugStringA("a3");

 if (ai.Flags_PreArc())
 {
   /* we notify parsers that extract executables, that they don't need
      to open archive, if there is tail after executable (for SFX cases) */
   CMyComPtr<IArchiveAllowTail> allowTail;
   archive.QueryInterface(IID_IArchiveAllowTail, (void **)&allowTail);
   if (allowTail)
     allowTail->AllowTail(BoolToInt(true));
 }

 if (op.props)
 {
   /*
   FOR_VECTOR (y, op.props)
   {
     const COptionalOpenProperties &optProps = (*op.props)[y];
     if (optProps.FormatName.IsEmpty() || optProps.FormatName.CompareNoCase(ai.Name) == 0)
     {
       RINOK(SetProperties(archive, optProps.Props));
       break;
     }
   }
   */
   RINOK(SetProperties(archive, *op.props));
 }
 
 #endif
 return S_OK;
}

#ifndef _SFX

static HRESULT ReadParseItemProps(IInArchive *archive, const CArcInfoEx &ai, NArchive::NParser::CParseItem &pi)
{
 pi.Extension = ai.GetMainExt();
 pi.FileTime_Defined = false;
 pi.ArcType = ai.Name;
 
 RINOK(Archive_GetArcBoolProp(archive, kpidIsNotArcType, pi.IsNotArcType));

 // RINOK(Archive_GetArcBoolProp(archive, kpidIsSelfExe, pi.IsSelfExe));
 pi.IsSelfExe = ai.Flags_PreArc();
 
 {
   NCOM::CPropVariant prop;
   RINOK(archive->GetArchiveProperty(kpidMTime, &prop));
   if (prop.vt == VT_FILETIME)
   {
     pi.FileTime_Defined = true;
     pi.FileTime = prop.filetime;
   }
 }
 
 if (!pi.FileTime_Defined)
 {
   NCOM::CPropVariant prop;
   RINOK(archive->GetArchiveProperty(kpidCTime, &prop));
   if (prop.vt == VT_FILETIME)
   {
     pi.FileTime_Defined = true;
     pi.FileTime = prop.filetime;
   }
 }
 
 {
   NCOM::CPropVariant prop;
   RINOK(archive->GetArchiveProperty(kpidName, &prop));
   if (prop.vt == VT_BSTR)
   {
     pi.Name.SetFromBstr(prop.bstrVal);
     pi.Extension.Empty();
   }
   else
   {
     RINOK(archive->GetArchiveProperty(kpidExtension, &prop));
     if (prop.vt == VT_BSTR)
       pi.Extension.SetFromBstr(prop.bstrVal);
   }
 }
 
 {
   NCOM::CPropVariant prop;
   RINOK(archive->GetArchiveProperty(kpidShortComment, &prop));
   if (prop.vt == VT_BSTR)
     pi.Comment.SetFromBstr(prop.bstrVal);
 }


 UInt32 numItems;
 RINOK(archive->GetNumberOfItems(&numItems));
 
 // pi.NumSubFiles = numItems;
 // RINOK(Archive_GetArcProp_UInt(archive, kpidUnpackSize, pi.UnpackSize, pi.UnpackSize_Defined));
 // if (!pi.UnpackSize_Defined)
 {
   pi.NumSubFiles = 0;
   pi.NumSubDirs = 0;
   pi.UnpackSize = 0;
   for (UInt32 i = 0; i < numItems; i++)
   {
     UInt64 size = 0;
     bool defined = false;
     Archive_GetItem_Size(archive, i, size, defined);
     if (defined)
     {
       pi.UnpackSize_Defined = true;
       pi.UnpackSize += size;
     }

     bool isDir = false;
     Archive_IsItem_Dir(archive, i, isDir);
     if (isDir)
       pi.NumSubDirs++;
     else
       pi.NumSubFiles++;
   }
   if (pi.NumSubDirs != 0)
     pi.NumSubDirs_Defined = true;
   pi.NumSubFiles_Defined = true;
 }

 return S_OK;
}

#endif

HRESULT CArc::CheckZerosTail(const COpenOptions &op, UInt64 offset)
{
 if (!op.stream)
   return S_OK;
 RINOK(op.stream->Seek(offset, STREAM_SEEK_SET, NULL));
 const UInt32 kBufSize = 1 << 11;
 Byte buf[kBufSize];
 
 for (;;)
 {
   UInt32 processed = 0;
   RINOK(op.stream->Read(buf, kBufSize, &processed));
   if (processed == 0)
   {
     // ErrorInfo.NonZerosTail = false;
     ErrorInfo.IgnoreTail = true;
     return S_OK;
   }
   for (size_t i = 0; i < processed; i++)
   {
     if (buf[i] != 0)
     {
       // ErrorInfo.IgnoreTail = false;
       // ErrorInfo.NonZerosTail = true;
       return S_OK;
     }
   }
 }
}

#ifndef _SFX

class CExtractCallback_To_OpenCallback:
 public IArchiveExtractCallback,
 public ICompressProgressInfo,
 public CMyUnknownImp
{
public:
 CMyComPtr<IArchiveOpenCallback> Callback;
 UInt64 Files;
 UInt64 Offset;

 MY_UNKNOWN_IMP2(IArchiveExtractCallback, ICompressProgressInfo)
 INTERFACE_IArchiveExtractCallback(;)
 STDMETHOD(SetRatioInfo)(const UInt64 *inSize, const UInt64 *outSize);
 void Init(IArchiveOpenCallback *callback)
 {
   Callback = callback;
   Files = 0;
   Offset = 0;
 }
};

STDMETHODIMP CExtractCallback_To_OpenCallback::SetTotal(UInt64 /* size */)
{
 return S_OK;
}

STDMETHODIMP CExtractCallback_To_OpenCallback::SetCompleted(const UInt64 * /* completeValue */)
{
 return S_OK;
}

STDMETHODIMP CExtractCallback_To_OpenCallback::SetRatioInfo(const UInt64 *inSize, const UInt64 * /* outSize */)
{
 if (Callback)
 {
   UInt64 value = Offset;
   if (inSize)
     value += *inSize;
   return Callback->SetCompleted(&Files, &value);
 }
 return S_OK;
}

STDMETHODIMP CExtractCallback_To_OpenCallback::GetStream(UInt32 /* index */, ISequentialOutStream **outStream, Int32 /* askExtractMode */)
{
 *outStream = 0;
 return S_OK;
}

STDMETHODIMP CExtractCallback_To_OpenCallback::PrepareOperation(Int32 /* askExtractMode */)
{
 return S_OK;
}

STDMETHODIMP CExtractCallback_To_OpenCallback::SetOperationResult(Int32 /* operationResult */)
{
 return S_OK;
}

static HRESULT OpenArchiveSpec(IInArchive *archive, bool needPhySize,
   IInStream *stream, const UInt64 *maxCheckStartPosition,
   IArchiveOpenCallback *openCallback,
   IArchiveExtractCallback *extractCallback)
{
 /*
 if (needPhySize)
 {
   CMyComPtr<IArchiveOpen2> open2;
   archive->QueryInterface(IID_IArchiveOpen2, (void **)&open2);
   if (open2)
     return open2->ArcOpen2(stream, kOpenFlags_RealPhySize, openCallback);
 }
 */
 RINOK(archive->Open(stream, maxCheckStartPosition, openCallback));
 if (needPhySize)
 {
   bool phySize_Defined = false;
   UInt64 phySize = 0;
   RINOK(Archive_GetArcProp_UInt(archive, kpidPhySize, phySize, phySize_Defined));
   if (phySize_Defined)
     return S_OK;

   bool phySizeCantBeDetected = false;;
   RINOK(Archive_GetArcBoolProp(archive, kpidPhySizeCantBeDetected, phySizeCantBeDetected));

   if (!phySizeCantBeDetected)
   {
     RINOK(archive->Extract(0, (UInt32)(Int32)-1, BoolToInt(true), extractCallback));
   }
 }
 return S_OK;
}

static int FindFormatForArchiveType(CCodecs *codecs, CIntVector orderIndices, const char *name)
{
 FOR_VECTOR (i, orderIndices)
   if (StringsAreEqualNoCase_Ascii(codecs->Formats[orderIndices[i]].Name, name))
     return i;
 return -1;
}

#endif

HRESULT CArc::OpenStream2(const COpenOptions &op)
{
 // fprintf(stdout, "\nOpen: %S", Path); fflush(stdout);

 Archive.Release();
 GetRawProps.Release();
 GetRootProps.Release();

 ErrorInfo.ClearErrors();
 ErrorInfo.ErrorFormatIndex = -1;

 IsParseArc = false;
 ArcStreamOffset = 0;
 
 // OutputDebugStringA("1");
 // OutputDebugStringW(Path);

 const UString fileName = ExtractFileNameFromPath(Path);
 UString extension;
 {
   int dotPos = fileName.ReverseFind_Dot();
   if (dotPos >= 0)
     extension = fileName.Ptr(dotPos + 1);
 }
 
 CIntVector orderIndices;
 
 bool searchMarkerInHandler = false;
 #ifdef _SFX
   searchMarkerInHandler = true;
 #endif

 CBoolArr isMainFormatArr(op.codecs->Formats.Size());
 {
   FOR_VECTOR(i, op.codecs->Formats)
     isMainFormatArr[i] = false;
 }

 UInt64 maxStartOffset =
     op.openType.MaxStartOffset_Defined ?
     op.openType.MaxStartOffset :
     kMaxCheckStartPosition;

 #ifndef _SFX
 bool isUnknownExt = false;
 #endif

 bool isForced = false;
 unsigned numMainTypes = 0;
 int formatIndex = op.openType.FormatIndex;

 if (formatIndex >= 0)
 {
   isForced = true;
   orderIndices.Add(formatIndex);
   numMainTypes = 1;
   isMainFormatArr[(unsigned)formatIndex] = true;

   searchMarkerInHandler = true;
 }
 else
 {
   unsigned numFinded = 0;
   #ifndef _SFX
   bool isPrearcExt = false;
   #endif
   
   {
     #ifndef _SFX
     
     bool isZip = false;
     bool isRar = false;
     
     const wchar_t c = extension[0];
     if (c == 'z' || c == 'Z' || c == 'r' || c == 'R')
     {
       bool isNumber = false;
       for (unsigned k = 1;; k++)
       {
         const wchar_t d = extension[k];
         if (d == 0)
           break;
         if (d < '0' || d > '9')
         {
           isNumber = false;
           break;
         }
         isNumber = true;
       }
       if (isNumber)
         if (c == 'z' || c == 'Z')
           isZip = true;
         else
           isRar = true;
     }
     
     #endif

     FOR_VECTOR (i, op.codecs->Formats)
     {
       const CArcInfoEx &ai = op.codecs->Formats[i];

       if (IgnoreSplit || !op.openType.CanReturnArc)
         if (ai.IsSplit())
           continue;
       if (op.excludedFormats->FindInSorted(i) >= 0)
         continue;

       #ifndef _SFX
       if (IsPreArcFormat(ai))
         isPrearcExt = true;
       #endif

       if (ai.FindExtension(extension) >= 0
           #ifndef _SFX
           || isZip && StringsAreEqualNoCase_Ascii(ai.Name, "zip")
           || isRar && StringsAreEqualNoCase_Ascii(ai.Name, "rar")
           #endif
           )
       {
         // PrintNumber("orderIndices.Insert", i);
         orderIndices.Insert(numFinded++, i);
         isMainFormatArr[i] = true;
       }
       else
         orderIndices.Add(i);
     }
   }
 
   if (!op.stream)
   {
     if (numFinded != 1)
       return E_NOTIMPL;
     orderIndices.DeleteFrom(1);
   }
   // PrintNumber("numFinded", numFinded );

   /*
   if (op.openOnlySpecifiedByExtension)
   {
     if (numFinded != 0 && !IsExeExt(extension))
       orderIndices.DeleteFrom(numFinded);
   }
   */

   #ifndef _SFX

     if (op.stream && orderIndices.Size() >= 2)
     {
       RINOK(op.stream->Seek(0, STREAM_SEEK_SET, NULL));
       CByteBuffer byteBuffer;
       CIntVector orderIndices2;
       if (numFinded == 0 || IsExeExt(extension))
       {
         // signature search was here
       }
       else if (extension.IsEqualTo("000") || extension.IsEqualTo("001"))
       {
         int i = FindFormatForArchiveType(op.codecs, orderIndices, "rar");
         if (i >= 0)
         {
           const size_t kBufSize = (1 << 10);
           byteBuffer.Alloc(kBufSize);
           size_t processedSize = kBufSize;
           RINOK(ReadStream(op.stream, byteBuffer, &processedSize));
           if (processedSize >= 16)
           {
             const Byte *buf = byteBuffer;
             const Byte kRarHeader[] = { 0x52 , 0x61, 0x72, 0x21, 0x1a, 0x07, 0x00 };
             if (TestSignature(buf, kRarHeader, 7) && buf[9] == 0x73 && (buf[10] & 1) != 0)
             {
               orderIndices2.Add(orderIndices[i]);
               orderIndices[i] = -1;
               if (i >= (int)numFinded)
                 numFinded++;
             }
           }
         }
       }
       else
       {
         const size_t kBufSize = (1 << 10);
         byteBuffer.Alloc(kBufSize);
         size_t processedSize = kBufSize;
         RINOK(ReadStream(op.stream, byteBuffer, &processedSize));
         if (processedSize == 0)
           return S_FALSE;
         
         /*
         check type order:
           1) matched extension, no signuature
           2) matched extension, matched signuature
           // 3) no signuature
           // 4) matched signuature
         */

         MakeCheckOrder(op.codecs, orderIndices, numFinded, orderIndices2, NULL, 0);
         MakeCheckOrder(op.codecs, orderIndices, numFinded, orderIndices2, byteBuffer, processedSize);
         // MakeCheckOrder(op.codecs, orderIndices, orderIndices.Size(), orderIndices2, NULL, 0);
         // MakeCheckOrder(op.codecs, orderIndices, orderIndices.Size(), orderIndices2, byteBuffer, processedSize);
       }
     
       FOR_VECTOR (i, orderIndices)
       {
         int val = orderIndices[i];
         if (val != -1)
           orderIndices2.Add(val);
       }
       orderIndices = orderIndices2;
     }
     
     if (orderIndices.Size() >= 2)
     {
       int iIso = FindFormatForArchiveType(op.codecs, orderIndices, "iso");
       int iUdf = FindFormatForArchiveType(op.codecs, orderIndices, "udf");
       if (iUdf > iIso && iIso >= 0)
       {
         int isoIndex = orderIndices[iIso];
         int udfIndex = orderIndices[iUdf];
         orderIndices[iUdf] = isoIndex;
         orderIndices[iIso] = udfIndex;
       }
     }

     numMainTypes = numFinded;
     isUnknownExt = (numMainTypes == 0) || isPrearcExt;

   #else // _SFX

     numMainTypes = orderIndices.Size();

     // we need correct numMainTypes for mutlivolume SFX (if some volume is missing)
     if (numFinded != 0)
       numMainTypes = numFinded;
   
   #endif
 }

 UInt64 fileSize = 0;
 if (op.stream)
 {
   RINOK(op.stream->Seek(0, STREAM_SEEK_END, &fileSize));
   RINOK(op.stream->Seek(0, STREAM_SEEK_SET, NULL));
 }
 FileSize = fileSize;


 #ifndef _SFX

 CBoolArr skipFrontalFormat(op.codecs->Formats.Size());
 {
   FOR_VECTOR(i, op.codecs->Formats)
     skipFrontalFormat[i] = false;
 }
 
 #endif

 const COpenType &mode = op.openType;

 
 

 
 if (mode.CanReturnArc)
 {
   // ---------- OPEN main type by extenssion ----------
 
   unsigned numCheckTypes = orderIndices.Size();
   if (formatIndex >= 0)
     numCheckTypes = numMainTypes;
   
   for (unsigned i = 0; i < numCheckTypes; i++)
   {
     FormatIndex = orderIndices[i];
     
     bool exactOnly = false;

     #ifndef _SFX
   
     const CArcInfoEx &ai = op.codecs->Formats[FormatIndex];
     // OutputDebugStringW(ai.Name);
     if (i >= numMainTypes)
     {
       if (!ai.Flags_BackwardOpen()
           // && !ai.Flags_PureStartOpen()
           )
         continue;
       exactOnly = true;
     }

     #endif
     
     // Some handlers do not set total bytes. So we set it here
     if (op.callback)
       RINOK(op.callback->SetTotal(NULL, &fileSize));

     if (op.stream)
     {
       RINOK(op.stream->Seek(0, STREAM_SEEK_SET, NULL));
     }
     
     CMyComPtr<IInArchive> archive;
     
     RINOK(PrepareToOpen(op, FormatIndex, archive));
     if (!archive)
       continue;
     
     HRESULT result;
     if (op.stream)
     {
       UInt64 searchLimit = (!exactOnly && searchMarkerInHandler) ? maxStartOffset: 0;
       result = archive->Open(op.stream, &searchLimit, op.callback);
     }
     else
     {
       CMyComPtr<IArchiveOpenSeq> openSeq;
       archive.QueryInterface(IID_IArchiveOpenSeq, (void **)&openSeq);
       if (!openSeq)
         return E_NOTIMPL;
       result = openSeq->OpenSeq(op.seqStream);
     }
     
     RINOK(ReadBasicProps(archive, 0, result));
     
     if (result == S_FALSE)
     {
       bool isArc = ErrorInfo.IsArc_After_NonOpen();

       #ifndef _SFX
       // if it's archive, we allow another open attempt for parser
       if (!mode.CanReturnParser || !isArc)
         skipFrontalFormat[(unsigned)FormatIndex] = true;
       #endif
       
       if (exactOnly)
         continue;
       
       if (i == 0 && numMainTypes == 1)
       {
         // we set NonOpenErrorInfo, only if there is only one main format (defined by extension).
         ErrorInfo.ErrorFormatIndex = FormatIndex;
         NonOpen_ErrorInfo = ErrorInfo;
      
         if (!mode.CanReturnParser && isArc)
         {
           // if (formatIndex < 0 && !searchMarkerInHandler)
           {
             // if bad archive was detected, we don't need additional open attempts
             #ifndef _SFX
             if (!IsPreArcFormat(ai) /* || !mode.SkipSfxStub */)
             #endif
               return S_FALSE;
           }
         }
       }
       
       /*
       #ifndef _SFX
       if (IsExeExt(extension) || ai.Flags_PreArc())
       {
       // openOnlyFullArc = false;
       // canReturnTailArc = true;
       // limitSignatureSearch = true;
       }
       #endif
       */
       
       continue;
     }
     
     RINOK(result);
     
     #ifndef _SFX

     bool isMainFormat = isMainFormatArr[(unsigned)FormatIndex];
     const COpenSpecFlags &specFlags = mode.GetSpec(isForced, isMainFormat, isUnknownExt);

     bool thereIsTail = ErrorInfo.ThereIsTail;
     if (thereIsTail && mode.ZerosTailIsAllowed)
     {
       RINOK(CheckZerosTail(op, Offset + PhySize));
       if (ErrorInfo.IgnoreTail)
         thereIsTail = false;
     }

     if (Offset > 0)
     {
       if (exactOnly
           || !searchMarkerInHandler
           || !specFlags.CanReturn_NonStart()
           || (mode.MaxStartOffset_Defined && (UInt64)Offset > mode.MaxStartOffset))
         continue;
     }
     if (thereIsTail)
     {
       if (Offset > 0)
       {
         if (!specFlags.CanReturnMid)
           continue;
       }
       else if (!specFlags.CanReturnFrontal)
         continue;
     }

     if (Offset > 0 || thereIsTail)
     {
       if (formatIndex < 0)
       {
         if (IsPreArcFormat(ai))
         {
           // openOnlyFullArc = false;
           // canReturnTailArc = true;
           /*
           if (mode.SkipSfxStub)
           limitSignatureSearch = true;
           */
           // if (mode.SkipSfxStub)
           {
             // skipFrontalFormat[FormatIndex] = true;
             continue;
           }
         }
       }
     }
    
     #endif

     Archive = archive;
     return S_OK;
   }
 }

 

 #ifndef _SFX

 if (!op.stream)
   return S_FALSE;

 if (formatIndex >= 0 && !mode.CanReturnParser)
 {
   if (mode.MaxStartOffset_Defined)
   {
     if (mode.MaxStartOffset == 0)
       return S_FALSE;
   }
   else
   {
     const CArcInfoEx &ai = op.codecs->Formats[formatIndex];
     if (ai.FindExtension(extension) >= 0)
     {
       if (ai.Flags_FindSignature() && searchMarkerInHandler)
         return S_FALSE;
     }
   }
 }

 NArchive::NParser::CHandler *handlerSpec = new NArchive::NParser::CHandler;
 CMyComPtr<IInArchive> handler = handlerSpec;

 CExtractCallback_To_OpenCallback *extractCallback_To_OpenCallback_Spec = new CExtractCallback_To_OpenCallback;
 CMyComPtr<IArchiveExtractCallback> extractCallback_To_OpenCallback = extractCallback_To_OpenCallback_Spec;
 extractCallback_To_OpenCallback_Spec->Init(op.callback);

 {
   // ---------- Check all possible START archives ----------
   // this code is better for full file archives than Parser's code.

   CByteBuffer byteBuffer;
   bool endOfFile = false;
   size_t processedSize;
   {
     size_t bufSize = 1 << 20; // it must be larger than max signature offset or IsArcFunc offset ((1 << 19) + x for UDF)
     if (bufSize > fileSize)
     {
       bufSize = (size_t)fileSize;
       endOfFile = true;
     }
     byteBuffer.Alloc(bufSize);
     RINOK(op.stream->Seek(0, STREAM_SEEK_SET, NULL));
     processedSize = bufSize;
     RINOK(ReadStream(op.stream, byteBuffer, &processedSize));
     if (processedSize == 0)
       return S_FALSE;
     if (processedSize < bufSize)
       endOfFile = true;
   }
   CUIntVector sortedFormats;

   unsigned i;

   int splitIndex = -1;

   for (i = 0; i < orderIndices.Size(); i++)
   {
     unsigned form = orderIndices[i];
     if (skipFrontalFormat[form])
       continue;
     const CArcInfoEx &ai = op.codecs->Formats[form];
     if (ai.IsSplit())
     {
       splitIndex = form;
       continue;
     }

     if (ai.IsArcFunc)
     {
       UInt32 isArcRes = ai.IsArcFunc(byteBuffer, processedSize);
       if (isArcRes == k_IsArc_Res_NO)
         continue;
       if (isArcRes == k_IsArc_Res_NEED_MORE && endOfFile)
         continue;
       // if (isArcRes == k_IsArc_Res_YES_LOW_PROB) continue;
       sortedFormats.Insert(0, form);
       continue;
     }

     bool isNewStyleSignature = IsNewStyleSignature(ai);
     bool needCheck = !isNewStyleSignature
         || ai.Signatures.IsEmpty()
         || ai.Flags_PureStartOpen()
         || ai.Flags_StartOpen()
         || ai.Flags_BackwardOpen();
   
     if (isNewStyleSignature && !ai.Signatures.IsEmpty())
     {
       unsigned k;
       for (k = 0; k < ai.Signatures.Size(); k++)
       {
         const CByteBuffer &sig = ai.Signatures[k];
         UInt32 signatureEnd = ai.SignatureOffset + (UInt32)sig.Size();
         if (processedSize < signatureEnd)
         {
           if (!endOfFile)
             needCheck = true;
         }
         else if (memcmp(sig, byteBuffer + ai.SignatureOffset, sig.Size()) == 0)
           break;
       }
       if (k != ai.Signatures.Size())
       {
         sortedFormats.Insert(0, form);
         continue;
       }
     }
     if (needCheck)
       sortedFormats.Add(form);
   }

   if (splitIndex >= 0)
     sortedFormats.Insert(0, splitIndex);

   for (i = 0; i < sortedFormats.Size(); i++)
   {
     FormatIndex = sortedFormats[i];
     const CArcInfoEx &ai = op.codecs->Formats[FormatIndex];

     if (op.callback)
       RINOK(op.callback->SetTotal(NULL, &fileSize));

     RINOK(op.stream->Seek(0, STREAM_SEEK_SET, NULL));

     CMyComPtr<IInArchive> archive;
     RINOK(PrepareToOpen(op, FormatIndex, archive));
     if (!archive)
       continue;
     
     PRF(printf("\nSorted Open %S", (const wchar_t *)ai.Name));
     HRESULT result;
     {
       UInt64 searchLimit = 0;
       /*
       if (mode.CanReturnArc)
         result = archive->Open(op.stream, &searchLimit, op.callback);
       else
       */
       result = OpenArchiveSpec(archive, !mode.CanReturnArc, op.stream, &searchLimit, op.callback, extractCallback_To_OpenCallback);
     }
     
     if (result == S_FALSE)
     {
       skipFrontalFormat[(unsigned)FormatIndex] = true;
       // FIXME: maybe we must use LenIsUnknown.
       // printf("  OpenForSize Error");
       continue;
     }
     RINOK(result);

     RINOK(ReadBasicProps(archive, 0, result));

     if (Offset > 0)
     {
       continue; // good handler doesn't return such Offset > 0
       // but there are some cases like false prefixed PK00 archive, when
       // we can support it?
     }

     NArchive::NParser::CParseItem pi;
     pi.Offset = Offset;
     pi.Size = AvailPhySize;
     
     // bool needScan = false;

     if (!PhySizeDefined)
     {
       // it's for Z format
       pi.LenIsUnknown = true;
       // needScan = true;
       // phySize = arcRem;
       // nextNeedCheckStartOpen = false;
     }

     /*
     if (OkPhySize_Defined)
       pi.OkSize = pi.OkPhySize;
     else
       pi.OkSize = pi.Size;
     */

     pi.NormalizeOffset();
     // printf("  phySize = %8d", (unsigned)phySize);


     if (mode.CanReturnArc)
     {
       bool isMainFormat = isMainFormatArr[(unsigned)FormatIndex];
       const COpenSpecFlags &specFlags = mode.GetSpec(isForced, isMainFormat, isUnknownExt);
       bool openCur = false;

       if (!ErrorInfo.ThereIsTail)
         openCur = true;
       else
       {
         if (mode.ZerosTailIsAllowed)
         {
           RINOK(CheckZerosTail(op, Offset + PhySize));
           if (ErrorInfo.IgnoreTail)
             openCur = true;
         }
         if (!openCur)
         {
           openCur = specFlags.CanReturnFrontal;
           if (formatIndex < 0) // format is not forced
           {
             if (IsPreArcFormat(ai))
             {
               // if (mode.SkipSfxStub)
               {
                 openCur = false;
               }
             }
           }
         }
       }
       
       if (openCur)
       {
         InStream = op.stream;
         Archive = archive;
         return S_OK;
       }
     }
       
     skipFrontalFormat[(unsigned)FormatIndex] = true;


     // if (!mode.CanReturnArc)
     /*
     if (!ErrorInfo.ThereIsTail)
         continue;
     */
     if (pi.Offset == 0 && !pi.LenIsUnknown && pi.Size >= FileSize)
       continue;

     // printf("\nAdd offset = %d", (int)pi.Offset);
     RINOK(ReadParseItemProps(archive, ai, pi));
     handlerSpec->AddItem(pi);
   }
 }

 

 
 
 // ---------- PARSER ----------

 CUIntVector arc2sig; // formatIndex to signatureIndex
 CUIntVector sig2arc; // signatureIndex to formatIndex;
 {
   unsigned sum = 0;
   FOR_VECTOR (i, op.codecs->Formats)
   {
     arc2sig.Add(sum);
     const CObjectVector<CByteBuffer> &sigs = op.codecs->Formats[i].Signatures;
     sum += sigs.Size();
     FOR_VECTOR (k, sigs)
       sig2arc.Add(i);
   }
 }
 
 {
   const size_t kBeforeSize = 1 << 16;
   const size_t kAfterSize  = 1 << 20;
   const size_t kBufSize = 1 << 22; // it must be more than kBeforeSize + kAfterSize

   const UInt32 kNumVals = (UInt32)1 << (kNumHashBytes * 8);
   CByteArr hashBuffer(kNumVals);
   Byte *hash = hashBuffer;
   memset(hash, 0xFF, kNumVals);
   Byte prevs[256];
   memset(prevs, 0xFF, sizeof(prevs));
   if (sig2arc.Size() >= 0xFF)
     return S_FALSE;

   CUIntVector difficultFormats;
   CBoolArr difficultBools(256);
   {
     for (unsigned i = 0; i < 256; i++)
       difficultBools[i] = false;
   }

   bool thereAreHandlersForSearch = false;

   // UInt32 maxSignatureEnd = 0;
   
   FOR_VECTOR (i, orderIndices)
   {
     int index = orderIndices[i];
     if (index < 0)
       continue;
     const CArcInfoEx &ai = op.codecs->Formats[(unsigned)index];
     bool isDifficult = false;
     // if (ai.Version < 0x91F) // we don't use parser with old DLL (before 9.31)
     if (!ai.NewInterface)
       isDifficult = true;
     else
     {
       if (ai.Flags_StartOpen())
         isDifficult = true;
       FOR_VECTOR (k, ai.Signatures)
       {
         const CByteBuffer &sig = ai.Signatures[k];
         /*
         UInt32 signatureEnd = ai.SignatureOffset + (UInt32)sig.Size();
         if (maxSignatureEnd < signatureEnd)
           maxSignatureEnd = signatureEnd;
         */
         if (sig.Size() < kNumHashBytes)
         {
           isDifficult = true;
           continue;
         }
         thereAreHandlersForSearch = true;
         UInt32 v = HASH_VAL(sig);
         unsigned sigIndex = arc2sig[(unsigned)index] + k;
         prevs[sigIndex] = hash[v];
         hash[v] = (Byte)sigIndex;
       }
     }
     if (isDifficult)
     {
       difficultFormats.Add(index);
       difficultBools[(unsigned)index] = true;
     }
   }
   
   if (!thereAreHandlersForSearch)
   {
     // openOnlyFullArc = true;
     // canReturnTailArc = true;
   }
   
   RINOK(op.stream->Seek(0, STREAM_SEEK_SET, NULL));

   CLimitedCachedInStream *limitedStreamSpec = new CLimitedCachedInStream;
   CMyComPtr<IInStream> limitedStream = limitedStreamSpec;
   limitedStreamSpec->SetStream(op.stream);

   CArchiveOpenCallback_Offset *openCallback_Offset_Spec = NULL;
   CMyComPtr<IArchiveOpenCallback> openCallback_Offset;
   if (op.callback)
   {
     openCallback_Offset_Spec = new CArchiveOpenCallback_Offset;
     openCallback_Offset = openCallback_Offset_Spec;
     openCallback_Offset_Spec->Callback = op.callback;
     openCallback_Offset_Spec->Callback.QueryInterface(IID_IArchiveOpenVolumeCallback, &openCallback_Offset_Spec->OpenVolumeCallback);
     #ifndef _NO_CRYPTO
     openCallback_Offset_Spec->Callback.QueryInterface(IID_ICryptoGetTextPassword, &openCallback_Offset_Spec->GetTextPassword);
     #endif
   }

   if (op.callback)
     RINOK(op.callback->SetTotal(NULL, &fileSize));
 
   CByteBuffer &byteBuffer = limitedStreamSpec->Buffer;
   byteBuffer.Alloc(kBufSize);

   UInt64 callbackPrev = 0;
   bool needCheckStartOpen = true; // = true, if we need to test all archives types for current pos.

   bool endOfFile = false;
   UInt64 bufPhyPos = 0;
   size_t bytesInBuf = 0;
   // UInt64 prevPos = 0;
   
   // ---------- Main Scan Loop ----------

   UInt64 pos = 0;

   if (!mode.EachPos && handlerSpec->_items.Size() == 1)
   {
     NArchive::NParser::CParseItem &pi = handlerSpec->_items[0];
     if (!pi.LenIsUnknown && pi.Offset == 0)
       pos = pi.Size;
   }

   for (;;)
   {
     // printf("\nPos = %d", (int)pos);
     UInt64 posInBuf = pos - bufPhyPos;
     
     // if (pos > ((UInt64)1 << 35)) break;
     
     if (!endOfFile)
     {
       if (bytesInBuf < kBufSize)
       {
         size_t processedSize = kBufSize - bytesInBuf;
         // printf("\nRead ask = %d", (unsigned)processedSize);
         UInt64 seekPos = bufPhyPos + bytesInBuf;
         RINOK(op.stream->Seek(bufPhyPos + bytesInBuf, STREAM_SEEK_SET, NULL));
         RINOK(ReadStream(op.stream, byteBuffer + bytesInBuf, &processedSize));
         // printf("   processed = %d", (unsigned)processedSize);
         if (processedSize == 0)
         {
           fileSize = seekPos;
           endOfFile = true;
         }
         else
         {
           bytesInBuf += processedSize;
           limitedStreamSpec->SetCache(processedSize, (size_t)bufPhyPos);
         }
         continue;
       }
       
       if (bytesInBuf < posInBuf)
       {
         UInt64 skipSize = posInBuf - bytesInBuf;
         if (skipSize <= kBeforeSize)
         {
           size_t keepSize = (size_t)(kBeforeSize - skipSize);
           // printf("\nmemmove skip = %d", (int)keepSize);
           memmove(byteBuffer, byteBuffer + bytesInBuf - keepSize, keepSize);
           bytesInBuf = keepSize;
           bufPhyPos = pos - keepSize;
           continue;
         }
         // printf("\nSkip %d", (int)(skipSize - kBeforeSize));
         // RINOK(op.stream->Seek(skipSize - kBeforeSize, STREAM_SEEK_CUR, NULL));
         bytesInBuf = 0;
         bufPhyPos = pos - kBeforeSize;
         continue;
       }
       
       if (bytesInBuf - posInBuf < kAfterSize)
       {
         size_t beg = (size_t)posInBuf - kBeforeSize;
         // printf("\nmemmove for after beg = %d", (int)beg);
         memmove(byteBuffer, byteBuffer + beg, bytesInBuf - beg);
         bufPhyPos += beg;
         bytesInBuf -= beg;
         continue;
       }
     }

     if (bytesInBuf <= (size_t)posInBuf)
       break;

     bool useOffsetCallback = false;
     if (openCallback_Offset)
     {
       openCallback_Offset_Spec->Files = handlerSpec->_items.Size();
       openCallback_Offset_Spec->Offset = pos;

       useOffsetCallback = (!op.openType.CanReturnArc || handlerSpec->_items.Size() > 1);

       if (pos >= callbackPrev + (1 << 23))
       {
         RINOK(openCallback_Offset_Spec->SetCompleted(NULL, NULL));
         callbackPrev = pos;
       }
     }

     {
       UInt64 endPos = bufPhyPos + bytesInBuf;
       if (fileSize < endPos)
       {
         FileSize = fileSize; // why ????
         fileSize = endPos;
       }
     }

     size_t availSize = bytesInBuf - (size_t)posInBuf;
     if (availSize < kNumHashBytes)
       break;
     size_t scanSize = availSize -
         ((availSize >= kAfterSize) ? kAfterSize : kNumHashBytes);
 
     {
       /*
       UInt64 scanLimit = openOnlyFullArc ?
           maxSignatureEnd :
           op.openType.ScanSize + maxSignatureEnd;
       */
       if (!mode.CanReturnParser)
       {
         if (pos > maxStartOffset)
           break;
         UInt64 remScan = maxStartOffset - pos;
         if (scanSize > remScan)
           scanSize = (size_t)remScan;
       }
     }

     scanSize++;

     const Byte *buf = byteBuffer + (size_t)posInBuf;
     const Byte *bufLimit = buf + scanSize;
     size_t ppp = 0;
     
     if (!needCheckStartOpen)
     {
       for (; buf < bufLimit && hash[HASH_VAL(buf)] == 0xFF; buf++);
       ppp = buf - (byteBuffer + (size_t)posInBuf);
       pos += ppp;
       if (buf == bufLimit)
         continue;
     }
     
     UInt32 v = HASH_VAL(buf);
     bool nextNeedCheckStartOpen = true;
     unsigned i = hash[v];
     unsigned indexOfDifficult = 0;

     // ---------- Open Loop for Current Pos ----------
     bool wasOpen = false;
     
     for (;;)
     {
       unsigned index;
       bool isDifficult;
       if (needCheckStartOpen && indexOfDifficult < difficultFormats.Size())
       {
         index = difficultFormats[indexOfDifficult++];
         isDifficult = true;
       }
       else
       {
         if (i == 0xFF)
           break;
         index = sig2arc[i];
         unsigned sigIndex = i - arc2sig[index];
         i = prevs[i];
         if (needCheckStartOpen && difficultBools[index])
           continue;
         const CArcInfoEx &ai = op.codecs->Formats[index];

         if (pos < ai.SignatureOffset)
           continue;

         /*
         if (openOnlyFullArc)
           if (pos != ai.SignatureOffset)
             continue;
         */
 
         const CByteBuffer &sig = ai.Signatures[sigIndex];

         if (ppp + sig.Size() > availSize
             || !TestSignature(buf, sig, sig.Size()))
           continue;
         // printf("\nSignature OK: %10S %8x %5d", (const wchar_t *)ai.Name, (int)pos, (int)(pos - prevPos));
         // prevPos = pos;
         isDifficult = false;
       }

       const CArcInfoEx &ai = op.codecs->Formats[index];


       if ((isDifficult && pos == 0) || ai.SignatureOffset == pos)
       {
         // we don't check same archive second time */
         if (skipFrontalFormat[index])
           continue;
       }

       UInt64 startArcPos = pos;
       if (!isDifficult)
       {
         if (pos < ai.SignatureOffset)
           continue;
         startArcPos = pos - ai.SignatureOffset;
         /*
         // we don't need the check for Z files
         if (startArcPos < handlerSpec->GetLastEnd())
           continue;
         */
       }
       
       if (ai.IsArcFunc && startArcPos >= bufPhyPos)
       {
         size_t offsetInBuf = (size_t)(startArcPos - bufPhyPos);
         if (offsetInBuf < bytesInBuf)
         {
           UInt32 isArcRes = ai.IsArcFunc(byteBuffer + offsetInBuf, bytesInBuf - offsetInBuf);
           if (isArcRes == k_IsArc_Res_NO)
             continue;
           if (isArcRes == k_IsArc_Res_NEED_MORE && endOfFile)
             continue;
           /*
           if (isArcRes == k_IsArc_Res_YES_LOW_PROB)
           {
             // if (pos != ai.SignatureOffset)
             continue;
           }
           */
         }
         // printf("\nIsArc OK: %S", (const wchar_t *)ai.Name);
       }
       
       /*
       if (pos == 67109888)
         pos = pos;
       */
       PRF(printf("\npos = %9I64d : %S", pos, (const wchar_t *)ai.Name));

       bool isMainFormat = isMainFormatArr[index];
       const COpenSpecFlags &specFlags = mode.GetSpec(isForced, isMainFormat, isUnknownExt);
       
       CMyComPtr<IInArchive> archive;
       RINOK(PrepareToOpen(op, index, archive));
       if (!archive)
         return E_FAIL;
       
       // OutputDebugStringW(ai.Name);
       
       UInt64 rem = fileSize - startArcPos;
       
       UInt64 arcStreamOffset = 0;

       if (ai.Flags_UseGlobalOffset())
       {
         limitedStreamSpec->InitAndSeek(0, fileSize);
         limitedStream->Seek(startArcPos, STREAM_SEEK_SET, NULL);
       }
       else
       {
         limitedStreamSpec->InitAndSeek(startArcPos, rem);
         arcStreamOffset = startArcPos;
       }
       
       UInt64 maxCheckStartPosition = 0;
       
       if (openCallback_Offset)
       {
         openCallback_Offset_Spec->Files = handlerSpec->_items.Size();
         openCallback_Offset_Spec->Offset = startArcPos;
       }

       // HRESULT result = archive->Open(limitedStream, &maxCheckStartPosition, openCallback_Offset);
       extractCallback_To_OpenCallback_Spec->Files = 0;
       extractCallback_To_OpenCallback_Spec->Offset = startArcPos;

       HRESULT result = OpenArchiveSpec(archive, true, limitedStream, &maxCheckStartPosition,
           useOffsetCallback ? (IArchiveOpenCallback *)openCallback_Offset : (IArchiveOpenCallback *)op.callback,
           extractCallback_To_OpenCallback);

       RINOK(ReadBasicProps(archive, ai.Flags_UseGlobalOffset() ? 0 : startArcPos, result));

       bool isOpen = false;
       if (result == S_FALSE)
       {
         if (!mode.CanReturnParser)
         {
           if (formatIndex < 0 && ErrorInfo.IsArc_After_NonOpen())
           {
             ErrorInfo.ErrorFormatIndex = index;
             NonOpen_ErrorInfo = ErrorInfo;
             // if archive was detected, we don't need additional open attempts
             return S_FALSE;
           }
           continue;
         }
         if (!ErrorInfo.IsArc_After_NonOpen() || !PhySizeDefined || PhySize == 0)
           continue;
       }
       else
       {
         isOpen = true;
         RINOK(result);
         PRF(printf("  OK "));
       }

       // fprintf(stderr, "\n %8X  %S", startArcPos, Path);
       // printf("\nOpen OK: %S", ai.Name);
       
       
       NArchive::NParser::CParseItem pi;
       pi.Offset = startArcPos;

       if (ai.Flags_UseGlobalOffset())
         pi.Offset = Offset;
       else if (Offset != 0)
         return E_FAIL;
       UInt64 arcRem = FileSize - pi.Offset;
       UInt64 phySize = arcRem;
       bool phySizeDefined = PhySizeDefined;
       if (phySizeDefined)
       {
         if (pi.Offset + PhySize > FileSize)
         {
           // ErrorInfo.ThereIsTail = true;
           PhySize = FileSize - pi.Offset;
         }
         phySize = PhySize;
       }
       if (phySize == 0 || (UInt64)phySize > ((UInt64)1 << 63))
         return E_FAIL;

       /*
       if (!ai.UseGlobalOffset)
       {
         if (phySize > arcRem)
         {
           ThereIsTail = true;
           phySize = arcRem;
         }
       }
       */
       
       bool needScan = false;


       if (isOpen && !phySizeDefined)
       {
         // it's for Z format
         pi.LenIsUnknown = true;
         needScan = true;
         phySize = arcRem;
         nextNeedCheckStartOpen = false;
       }

       pi.Size = phySize;
       /*
       if (OkPhySize_Defined)
         pi.OkSize = OkPhySize;
       */
       pi.NormalizeOffset();
       // printf("  phySize = %8d", (unsigned)phySize);

       /*
       if (needSkipFullArc)
         if (pi.Offset == 0 && phySizeDefined && pi.Size >= fileSize)
           continue;
       */
       if (pi.Offset == 0 && !pi.LenIsUnknown && pi.Size >= FileSize)
       {
         // it's possible for dmg archives
         if (!mode.CanReturnArc)
           continue;
       }

       if (mode.EachPos)
         pos++;
       else if (needScan)
       {
         pos++;
         /*
         if (!OkPhySize_Defined)
           pos++;
         else
           pos = pi.Offset + pi.OkSize;
         */
       }
       else
         pos = pi.Offset + pi.Size;

      
       RINOK(ReadParseItemProps(archive, ai, pi));

       if (pi.Offset < startArcPos && !mode.EachPos /* && phySizeDefined */)
       {
         /* It's for DMG format.
         This code deletes all previous items that are included to current item */
           
         while (!handlerSpec->_items.IsEmpty())
         {
           {
             const NArchive::NParser::CParseItem &back = handlerSpec->_items.Back();
             if (back.Offset < pi.Offset)
               break;
             if (back.Offset + back.Size > pi.Offset + pi.Size)
               break;
           }
           handlerSpec->_items.DeleteBack();
         }
       }
       

       if (isOpen && mode.CanReturnArc && phySizeDefined)
       {
         // if (pi.Offset + pi.Size >= fileSize)
         bool openCur = false;

         bool thereIsTail = ErrorInfo.ThereIsTail;
         if (thereIsTail && mode.ZerosTailIsAllowed)
         {
           RINOK(CheckZerosTail(op, arcStreamOffset + Offset + PhySize));
           if (ErrorInfo.IgnoreTail)
             thereIsTail = false;
         }

         if (pi.Offset != 0)
         {
           if (!pi.IsNotArcType)
             if (thereIsTail)
               openCur = specFlags.CanReturnMid;
             else
               openCur = specFlags.CanReturnTail;
         }
         else
         {
           if (!thereIsTail)
             openCur = true;
           else
             openCur = specFlags.CanReturnFrontal;
             

           if (formatIndex >= -2)
             openCur = true;
         }
         if (formatIndex < 0 && pi.IsSelfExe /* && mode.SkipSfxStub */)
           openCur = false;

         // We open file as SFX, if there is front archive or first archive is "Self Executable"
         if (!openCur && !pi.IsSelfExe && !thereIsTail &&
             (!pi.IsNotArcType || pi.Offset == 0))
         {
           if (handlerSpec->_items.IsEmpty())
           {
             if (specFlags.CanReturnTail)
               openCur = true;
           }
           else if (handlerSpec->_items.Size() == 1)
           {
             if (handlerSpec->_items[0].IsSelfExe)
             {
               if (mode.SpecUnknownExt.CanReturnTail)
                 openCur = true;
             }
           }
         }

         if (openCur)
         {
           InStream = op.stream;
           Archive = archive;
           FormatIndex = index;
           ArcStreamOffset = arcStreamOffset;
           return S_OK;
         }
       }

       /*
       if (openOnlyFullArc)
       {
         ErrorInfo.ClearErrors();
         return S_FALSE;
       }
       */

       pi.FormatIndex = index;

       // printf("\nAdd offset = %d", (int)pi.Offset);
       handlerSpec->AddItem(pi);
       wasOpen = true;
       break;
     }
     // ---------- End of Open Loop for Current Pos ----------
    
     if (!wasOpen)
       pos++;
     needCheckStartOpen = (nextNeedCheckStartOpen && wasOpen);
   }
   // ---------- End of Main Scan Loop ----------

   /*
   if (handlerSpec->_items.Size() == 1)
   {
     const NArchive::NParser::CParseItem &pi = handlerSpec->_items[0];
     if (pi.Size == fileSize && pi.Offset == 0)
     {
       Archive = archive;
       FormatIndex2 = pi.FormatIndex;
       return S_OK;
     }
   }
   */

   if (mode.CanReturnParser)
   {
     bool returnParser = (handlerSpec->_items.Size() == 1); // it's possible if fileSize was not correct at start of parsing
     handlerSpec->AddUnknownItem(fileSize);
     if (handlerSpec->_items.Size() == 0)
       return S_FALSE;
     if (returnParser || handlerSpec->_items.Size() != 1)
     {
       // return S_FALSE;
       handlerSpec->_stream = op.stream;
       Archive = handler;
       ErrorInfo.ClearErrors();
       IsParseArc = true;
       FormatIndex = -1; // It's parser
       Offset = 0;
       return S_OK;
     }
   }
 }

 #endif

 if (!Archive)
   return S_FALSE;
 return S_OK;
}

HRESULT CArc::OpenStream(const COpenOptions &op)
{
 RINOK(OpenStream2(op));
 // PrintNumber("op.formatIndex 3", op.formatIndex);

 if (Archive)
 {
   GetRawProps.Release();
   GetRootProps.Release();
   Archive->QueryInterface(IID_IArchiveGetRawProps, (void **)&GetRawProps);
   Archive->QueryInterface(IID_IArchiveGetRootProps, (void **)&GetRootProps);

   RINOK(Archive_GetArcBoolProp(Archive, kpidIsTree, IsTree));
   RINOK(Archive_GetArcBoolProp(Archive, kpidIsDeleted, Ask_Deleted));
   RINOK(Archive_GetArcBoolProp(Archive, kpidIsAltStream, Ask_AltStream));
   RINOK(Archive_GetArcBoolProp(Archive, kpidIsAux, Ask_Aux));
   RINOK(Archive_GetArcBoolProp(Archive, kpidINode, Ask_INode));
   RINOK(Archive_GetArcBoolProp(Archive, kpidReadOnly, IsReadOnly));

   const UString fileName = ExtractFileNameFromPath(Path);
   UString extension;
   {
     int dotPos = fileName.ReverseFind_Dot();
     if (dotPos >= 0)
       extension = fileName.Ptr(dotPos + 1);
   }
   
   DefaultName.Empty();
   if (FormatIndex >= 0)
   {
     const CArcInfoEx &ai = op.codecs->Formats[FormatIndex];
     if (ai.Exts.Size() == 0)
       DefaultName = GetDefaultName2(fileName, UString(), UString());
     else
     {
       int subExtIndex = ai.FindExtension(extension);
       if (subExtIndex < 0)
         subExtIndex = 0;
       const CArcExtInfo &extInfo = ai.Exts[subExtIndex];
       DefaultName = GetDefaultName2(fileName, extInfo.Ext, extInfo.AddExt);
     }
   }
 }

 return S_OK;
}

#ifdef _SFX

#ifdef _WIN32
 #define k_ExeExt ".exe"
 static const unsigned k_ExeExt_Len = 4;
#else
 #define k_ExeExt ""
 static const unsigned k_ExeExt_Len = 0;
#endif

#endif

HRESULT CArc::OpenStreamOrFile(COpenOptions &op)
{
 CMyComPtr<IInStream> fileStream;
 CMyComPtr<ISequentialInStream> seqStream;
 CInFileStream *fileStreamSpec = NULL;
 
 if (op.stdInMode)
 {
   seqStream = new CStdInFileStream;
   op.seqStream = seqStream;
 }
 else if (!op.stream)
 {
   fileStreamSpec = new CInFileStream;
   fileStream = fileStreamSpec;
   Path = filePath;
   if (!fileStreamSpec->Open(us2fs(Path)))
   {
     return GetLastError();
   }
   op.stream = fileStream;
   #ifdef _SFX
   IgnoreSplit = true;
   #endif
 }

 /*
 if (callback)
 {
   UInt64 fileSize;
   RINOK(op.stream->Seek(0, STREAM_SEEK_END, &fileSize));
   RINOK(op.callback->SetTotal(NULL, &fileSize))
 }
 */

 HRESULT res = OpenStream(op);
 IgnoreSplit = false;
 
 #ifdef _SFX
 
 if (res != S_FALSE
     || !fileStreamSpec
     || !op.callbackSpec
     || NonOpen_ErrorInfo.IsArc_After_NonOpen())
   return res;
 
 {
   if (filePath.Len() > k_ExeExt_Len
       && StringsAreEqualNoCase_Ascii(filePath.RightPtr(k_ExeExt_Len), k_ExeExt))
   {
     const UString path2 = filePath.Left(filePath.Len() - k_ExeExt_Len);
     FOR_VECTOR (i, op.codecs->Formats)
     {
       const CArcInfoEx &ai = op.codecs->Formats[i];
       if (ai.IsSplit())
         continue;
       UString path3 = path2;
       path3 += '.';
       path3 += ai.GetMainExt(); // "7z"  for SFX.
       Path = path3;
       Path += ".001";
       bool isOk = op.callbackSpec->SetSecondFileInfo(us2fs(Path));
       if (!isOk)
       {
         Path = path3;
         isOk = op.callbackSpec->SetSecondFileInfo(us2fs(Path));
       }
       if (isOk)
       {
         if (fileStreamSpec->Open(us2fs(Path)))
         {
           op.stream = fileStream;
           NonOpen_ErrorInfo.ClearErrors_Full();
           if (OpenStream(op) == S_OK)
             return S_OK;
         }
       }
     }
   }
 }
 
 #endif

 return res;
}

void CArchiveLink::KeepModeForNextOpen()
{
 for (unsigned i = Arcs.Size(); i != 0;)
 {
   i--;
   CMyComPtr<IArchiveKeepModeForNextOpen> keep;
   Arcs[i].Archive->QueryInterface(IID_IArchiveKeepModeForNextOpen, (void **)&keep);
   if (keep)
     keep->KeepModeForNextOpen();
 }
}

HRESULT CArchiveLink::Close()
{
 for (unsigned i = Arcs.Size(); i != 0;)
 {
   i--;
   RINOK(Arcs[i].Close());
 }
 IsOpen = false;
 // ErrorsText.Empty();
 return S_OK;
}

void CArchiveLink::Release()
{
 // NonOpenErrorFormatIndex = -1;
 NonOpen_ErrorInfo.ClearErrors();
 NonOpen_ArcPath.Empty();
 while (!Arcs.IsEmpty())
   Arcs.DeleteBack();
}

/*
void CArchiveLink::Set_ErrorsText()
{
 FOR_VECTOR(i, Arcs)
 {
   const CArc &arc = Arcs[i];
   if (!arc.ErrorFlagsText.IsEmpty())
   {
     if (!ErrorsText.IsEmpty())
       ErrorsText.Add_LF();
     ErrorsText += GetUnicodeString(arc.ErrorFlagsText);
   }
   if (!arc.ErrorMessage.IsEmpty())
   {
     if (!ErrorsText.IsEmpty())
       ErrorsText.Add_LF();
     ErrorsText += arc.ErrorMessage;
   }

   if (!arc.WarningMessage.IsEmpty())
   {
     if (!ErrorsText.IsEmpty())
       ErrorsText.Add_LF();
     ErrorsText += arc.WarningMessage;
   }
 }
}
*/

HRESULT CArchiveLink::Open(COpenOptions &op)
{
 Release();
 if (op.types->Size() >= 32)
   return E_NOTIMPL;
 
 HRESULT resSpec;

 for (;;)
 {
   resSpec = S_OK;

   op.openType = COpenType();
   if (op.types->Size() >= 1)
   {
     COpenType latest;
     if (Arcs.Size() < op.types->Size())
       latest = (*op.types)[op.types->Size() - Arcs.Size() - 1];
     else
     {
       latest = (*op.types)[0];
       if (!latest.Recursive)
         break;
     }
     op.openType = latest;
   }
   else if (Arcs.Size() >= 32)
     break;

   /*
   op.formatIndex = -1;
   if (op.types->Size() >= 1)
   {
     int latest;
     if (Arcs.Size() < op.types->Size())
       latest = (*op.types)[op.types->Size() - Arcs.Size() - 1];
     else
     {
       latest = (*op.types)[0];
       if (latest != -2 && latest != -3)
         break;
     }
     if (latest >= 0)
       op.formatIndex = latest;
     else if (latest == -1 || latest == -2)
     {
       // default
     }
     else if (latest == -3)
       op.formatIndex = -2;
     else
       op.formatIndex = latest + 2;
   }
   else if (Arcs.Size() >= 32)
     break;
   */

   if (Arcs.IsEmpty())
   {
     CArc arc;
     arc.filePath = op.filePath;
     arc.Path = op.filePath;
     arc.SubfileIndex = (UInt32)(Int32)-1;
     HRESULT result = arc.OpenStreamOrFile(op);
     if (result != S_OK)
     {
       if (result == S_FALSE)
       {
         NonOpen_ErrorInfo = arc.NonOpen_ErrorInfo;
         // NonOpenErrorFormatIndex = arc.ErrorFormatIndex;
         NonOpen_ArcPath = arc.Path;
       }
       return result;
     }
     Arcs.Add(arc);
     continue;
   }
   
   // PrintNumber("op.formatIndex 11", op.formatIndex);

   const CArc &arc = Arcs.Back();
   
   if (op.types->Size() > Arcs.Size())
     resSpec = E_NOTIMPL;
   
   UInt32 mainSubfile;
   {
     NCOM::CPropVariant prop;
     RINOK(arc.Archive->GetArchiveProperty(kpidMainSubfile, &prop));
     if (prop.vt == VT_UI4)
       mainSubfile = prop.ulVal;
     else
       break;
     UInt32 numItems;
     RINOK(arc.Archive->GetNumberOfItems(&numItems));
     if (mainSubfile >= numItems)
       break;
   }

 
   CMyComPtr<IInArchiveGetStream> getStream;
   if (arc.Archive->QueryInterface(IID_IInArchiveGetStream, (void **)&getStream) != S_OK || !getStream)
     break;
   
   CMyComPtr<ISequentialInStream> subSeqStream;
   if (getStream->GetStream(mainSubfile, &subSeqStream) != S_OK || !subSeqStream)
     break;
   
   CMyComPtr<IInStream> subStream;
   if (subSeqStream.QueryInterface(IID_IInStream, &subStream) != S_OK || !subStream)
     break;
   
   CArc arc2;
   RINOK(arc.GetItemPath(mainSubfile, arc2.Path));

   bool zerosTailIsAllowed;
   RINOK(Archive_GetItemBoolProp(arc.Archive, mainSubfile, kpidZerosTailIsAllowed, zerosTailIsAllowed));


   if (op.callback)
   {
     CMyComPtr<IArchiveOpenSetSubArchiveName> setSubArchiveName;
     op.callback->QueryInterface(IID_IArchiveOpenSetSubArchiveName, (void **)&setSubArchiveName);
     if (setSubArchiveName)
       setSubArchiveName->SetSubArchiveName(arc2.Path);
   }
   
   arc2.SubfileIndex = mainSubfile;

   // CIntVector incl;
   CIntVector excl;

   COpenOptions op2;
   #ifndef _SFX
   op2.props = op.props;
   #endif
   op2.codecs = op.codecs;
   // op2.types = &incl;
   op2.openType = op.openType;
   op2.openType.ZerosTailIsAllowed = zerosTailIsAllowed;
   op2.excludedFormats = &excl;
   op2.stdInMode = false;
   op2.stream = subStream;
   op2.filePath = arc2.Path;
   op2.callback = op.callback;
   op2.callbackSpec = op.callbackSpec;


   HRESULT result = arc2.OpenStream(op2);
   resSpec = (op.types->Size() == 0 ? S_OK : S_FALSE);
   if (result == S_FALSE)
   {
     NonOpen_ErrorInfo = arc2.ErrorInfo;
     NonOpen_ArcPath = arc2.Path;
     break;
   }
   RINOK(result);
   RINOK(arc.GetItemMTime(mainSubfile, arc2.MTime, arc2.MTimeDefined));
   Arcs.Add(arc2);
 }
 IsOpen = !Arcs.IsEmpty();
 return resSpec;
}

HRESULT CArchiveLink::Open2(COpenOptions &op, IOpenCallbackUI *callbackUI)
{
 VolumesSize = 0;
 COpenCallbackImp *openCallbackSpec = new COpenCallbackImp;
 CMyComPtr<IArchiveOpenCallback> callback = openCallbackSpec;
 openCallbackSpec->Callback = callbackUI;

 FString prefix, name;
 
 if (!op.stream && !op.stdInMode)
 {
   NFile::NDir::GetFullPathAndSplit(us2fs(op.filePath), prefix, name);
   openCallbackSpec->Init(prefix, name);
 }
 else
 {
   openCallbackSpec->SetSubArchiveName(op.filePath);
 }

 op.callback = callback;
 op.callbackSpec = openCallbackSpec;
 
 HRESULT res = Open(op);

 PasswordWasAsked = openCallbackSpec->PasswordWasAsked;
 // Password = openCallbackSpec->Password;

 RINOK(res);
 // VolumePaths.Add(fs2us(prefix + name));

 FOR_VECTOR (i, openCallbackSpec->FileNames_WasUsed)
 {
   if (openCallbackSpec->FileNames_WasUsed[i])
   {
     VolumePaths.Add(fs2us(prefix) + openCallbackSpec->FileNames[i]);
     VolumesSize += openCallbackSpec->FileSizes[i];
   }
 }
 // VolumesSize = openCallbackSpec->TotalSize;
 return S_OK;
}

HRESULT CArc::ReOpen(const COpenOptions &op)
{
 ErrorInfo.ClearErrors();
 ErrorInfo.ErrorFormatIndex = -1;

 UInt64 fileSize = 0;
 if (op.stream)
 {
   RINOK(op.stream->Seek(0, STREAM_SEEK_END, &fileSize));
   RINOK(op.stream->Seek(0, STREAM_SEEK_SET, NULL));
 }
 FileSize = fileSize;

 CMyComPtr<IInStream> stream2;
 Int64 globalOffset = GetGlobalOffset();
 if (globalOffset <= 0)
   stream2 = op.stream;
 else
 {
   CTailInStream *tailStreamSpec = new CTailInStream;
   stream2 = tailStreamSpec;
   tailStreamSpec->Stream = op.stream;
   tailStreamSpec->Offset = globalOffset;
   tailStreamSpec->Init();
   RINOK(tailStreamSpec->SeekToStart());
 }

 // There are archives with embedded STUBs (like ZIP), so we must support signature scanning
 // But for another archives we can use 0 here. So the code can be fixed !!!
 UInt64 maxStartPosition = kMaxCheckStartPosition;
 HRESULT res = Archive->Open(stream2, &maxStartPosition, op.callback);
 
 if (res == S_OK)
 {
   RINOK(ReadBasicProps(Archive, globalOffset, res));
   ArcStreamOffset = globalOffset;
   if (ArcStreamOffset != 0)
     InStream = op.stream;
 }
 return res;
}

HRESULT CArchiveLink::Open3(COpenOptions &op, IOpenCallbackUI *callbackUI)
{
 HRESULT res = Open2(op, callbackUI);
 if (callbackUI)
 {
   RINOK(callbackUI->Open_Finished());
 }
 return res;
}

HRESULT CArchiveLink::ReOpen(COpenOptions &op)
{
 if (Arcs.Size() > 1)
   return E_NOTIMPL;

 CObjectVector<COpenType> inc;
 CIntVector excl;

 op.types = &inc;
 op.excludedFormats = &excl;
 op.stdInMode = false;
 op.stream = NULL;
 if (Arcs.Size() == 0) // ???
   return Open2(op, NULL);

 COpenCallbackImp *openCallbackSpec = new COpenCallbackImp;
 CMyComPtr<IArchiveOpenCallback> openCallbackNew = openCallbackSpec;

 openCallbackSpec->Callback = NULL;
 openCallbackSpec->ReOpenCallback = op.callback;
 {
   FString dirPrefix, fileName;
   NFile::NDir::GetFullPathAndSplit(us2fs(op.filePath), dirPrefix, fileName);
   openCallbackSpec->Init(dirPrefix, fileName);
 }


 CInFileStream *fileStreamSpec = new CInFileStream;
 CMyComPtr<IInStream> stream(fileStreamSpec);
 if (!fileStreamSpec->Open(us2fs(op.filePath)))
   return GetLastError();
 op.stream = stream;

 CArc &arc = Arcs[0];
 HRESULT res = arc.ReOpen(op);
 
 PasswordWasAsked = openCallbackSpec->PasswordWasAsked;
 // Password = openCallbackSpec->Password;
 
 IsOpen = (res == S_OK);
 return res;
}

#ifndef _SFX

bool ParseComplexSize(const wchar_t *s, UInt64 &result)
{
 result = 0;
 const wchar_t *end;
 UInt64 number = ConvertStringToUInt64(s, &end);
 if (end == s)
   return false;
 if (*end == 0)
 {
   result = number;
   return true;
 }
 if (end[1] != 0)
   return false;
 unsigned numBits;
 switch (MyCharLower_Ascii(*end))
 {
   case 'b': result = number; return true;
   case 'k': numBits = 10; break;
   case 'm': numBits = 20; break;
   case 'g': numBits = 30; break;
   case 't': numBits = 40; break;
   default: return false;
 }
 if (number >= ((UInt64)1 << (64 - numBits)))
   return false;
 result = number << numBits;
 return true;
}

static bool ParseTypeParams(const UString &s, COpenType &type)
{
 if (s[0] == 0)
   return true;
 if (s[1] == 0)
 {
   switch ((unsigned)(Byte)s[0])
   {
     case 'e': type.EachPos = true; return true;
     case 'a': type.CanReturnArc = true; return true;
     case 'r': type.Recursive = true; return true;
   }
   return false;
 }
 if (s[0] == 's')
 {
   UInt64 result;
   if (!ParseComplexSize(s.Ptr(1), result))
     return false;
   type.MaxStartOffset = result;
   type.MaxStartOffset_Defined = true;
   return true;
 }

 return false;
}

bool ParseType(CCodecs &codecs, const UString &s, COpenType &type)
{
 int pos2 = s.Find(L':');

 {
 UString name;
 if (pos2 < 0)
 {
   name = s;
   pos2 = s.Len();
 }
 else
 {
   name = s.Left(pos2);
   pos2++;
 }

 int index = codecs.FindFormatForArchiveType(name);
 type.Recursive = false;

 if (index < 0)
 {
   if (name[0] == '*')
   {
     if (name[1] != 0)
       return false;
   }
   else if (name[0] == '#')
   {
     if (name[1] != 0)
       return false;
     type.CanReturnArc = false;
     type.CanReturnParser = true;
   }
   else
     return false;
 }
 
 type.FormatIndex = index;

 }

 for (unsigned i = pos2; i < s.Len();)
 {
   int next = s.Find(L':', i);
   if (next < 0)
     next = s.Len();
   const UString name = s.Mid(i, next - i);
   if (name.IsEmpty())
     return false;
   if (!ParseTypeParams(name, type))
     return false;
   i = next + 1;
 }
 
 return true;
}

bool ParseOpenTypes(CCodecs &codecs, const UString &s, CObjectVector<COpenType> &types)
{
 types.Clear();
 for (unsigned pos = 0; pos < s.Len();)
 {
   int pos2 = s.Find(L'.', pos);
   if (pos2 < 0)
     pos2 = s.Len();
   UString name = s.Mid(pos, pos2 - pos);
   if (name.IsEmpty())
     return false;
   COpenType type;
   if (!ParseType(codecs, name, type))
     return false;
   types.Add(type);
   pos = pos2 + 1;
 }
 return true;
}

#endif