seven-zip 1.4.2 → 1.7.0.rc1

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

@@ -4,12 +4,12 @@
 
 #include "../../../C/CpuArch.h"
 
-#include "Common/Buffer.h"
-#include "Common/ComTry.h"
-#include "Common/StringConvert.h"
+#include "../../Common/ComTry.h"
+#include "../../Common/MyBuffer.h"
+#include "../../Common/StringConvert.h"
 
-#include "Windows/PropVariant.h"
-#include "Windows/Time.h"
+#include "../../Windows/PropVariant.h"
+#include "../../Windows/TimeUtils.h"
 
 #include "../ICoder.h"
 
@@ -44,10 +44,11 @@ struct CExtension
 {
   Byte Type;
   CByteBuffer Data;
+  
   AString GetString() const
   {
     AString s;
-    for (size_t i = 0; i < Data.GetCapacity(); i++)
+    for (size_t i = 0; i < Data.Size(); i++)
     {
       char c = (char)Data[i];
       if (c == 0)
@@ -58,6 +59,22 @@ struct CExtension
   }
 };
 
+const UInt32 kBasicPartSize = 22;
+
+API_FUNC_static_IsArc IsArc_Lzh(const Byte *p, size_t size)
+{
+  if (size < 2 + kBasicPartSize)
+    return k_IsArc_Res_NEED_MORE;
+  if (p[2] != '-' || p[3] != 'l'  || p[4] != 'h' || p[6] != '-')
+    return k_IsArc_Res_NO;
+  Byte n = p[5];
+  if (n != 'd')
+    if (n < '0' || n > '7')
+      return k_IsArc_Res_NO;
+  return k_IsArc_Res_YES;
+}
+}
+
 struct CItem
 {
   AString Name;
@@ -85,7 +102,7 @@ struct CItem
   {
     if (!IsLhMethod())
       return false;
-    switch(Method[3])
+    switch (Method[3])
     {
       case '1':
         return true;
@@ -97,7 +114,7 @@ struct CItem
   {
     if (!IsLhMethod())
       return false;
-    switch(Method[3])
+    switch (Method[3])
     {
       case '4':
       case '5':
@@ -112,7 +129,7 @@ struct CItem
   {
     if (!IsLhMethod())
       return 0;
-    switch(Method[3])
+    switch (Method[3])
     {
       case '1': return 12;
       case '2': return 13;
@@ -127,13 +144,14 @@ struct CItem
 
   int FindExt(Byte type) const
   {
-    for (int i = 0; i < Extensions.Size(); i++)
+    FOR_VECTOR (i, Extensions)
       if (Extensions[i].Type == type)
         return i;
     return -1;
   }
   bool GetUnixTime(UInt32 &value) const
   {
+    value = 0;
     int index = FindExt(kExtIdUnixTime);
     if (index < 0)
     {
@@ -177,47 +195,6 @@ struct CItem
   }
 };
 
-struct CItemEx: public CItem
-{
-  UInt64 DataPosition;
-};
-
-class CInArchive
-{
-  CMyComPtr<IInStream> m_Stream;
-  UInt64 m_Position;
-  
-  HRESULT ReadBytes(void *data, UInt32 size, UInt32 &processedSize);
-  HRESULT CheckReadBytes(void *data, UInt32 size);
-public:
-  HRESULT Open(IInStream *inStream);
-  HRESULT GetNextItem(bool &filled, CItemEx &itemInfo);
-  HRESULT Skip(UInt64 numBytes);
-};
-
-HRESULT CInArchive::ReadBytes(void *data, UInt32 size, UInt32 &processedSize)
-{
-  size_t realProcessedSize = size;
-  RINOK(ReadStream(m_Stream, data, &realProcessedSize));
-  processedSize = (UInt32)realProcessedSize;
-  m_Position += processedSize;
-  return S_OK;
-}
-
-HRESULT CInArchive::CheckReadBytes(void *data, UInt32 size)
-{
-  UInt32 processedSize;
-  RINOK(ReadBytes(data, size, processedSize));
-  return (processedSize == size) ? S_OK: S_FALSE;
-}
-
-HRESULT CInArchive::Open(IInStream *inStream)
-{
-  RINOK(inStream->Seek(0, STREAM_SEEK_CUR, &m_Position));
-  m_Stream = inStream;
-  return S_OK;
-}
-
 static const Byte *ReadUInt16(const Byte *p, UInt16 &v)
 {
   v = Get16(p);
@@ -245,13 +222,13 @@ static Byte CalcSum(const Byte *data, size_t size)
   return sum;
 }
 
-HRESULT CInArchive::GetNextItem(bool &filled, CItemEx &item)
+static HRESULT GetNextItem(ISequentialInStream *stream, bool &filled, CItem &item)
 {
   filled = false;
 
-  UInt32 processedSize;
+  size_t processedSize = 2;
   Byte startHeader[2];
-  RINOK(ReadBytes(startHeader, 2, processedSize))
+  RINOK(ReadStream(stream, startHeader, &processedSize))
   if (processedSize == 0)
     return S_OK;
   if (processedSize == 1)
@@ -260,8 +237,8 @@ HRESULT CInArchive::GetNextItem(bool &filled, CItemEx &item)
     return S_OK;
 
   Byte header[256];
-  const UInt32 kBasicPartSize = 22;
-  RINOK(ReadBytes(header, kBasicPartSize, processedSize));
+  processedSize = kBasicPartSize;
+  RINOK(ReadStream(stream, header, &processedSize));
   if (processedSize != kBasicPartSize)
     return (startHeader[0] == 0) ? S_OK: S_FALSE;
 
@@ -284,8 +261,7 @@ HRESULT CInArchive::GetNextItem(bool &filled, CItemEx &item)
     headerSize = startHeader[0];
     if (headerSize < kBasicPartSize)
       return S_FALSE;
-    UInt32 remain = headerSize - kBasicPartSize;
-    RINOK(CheckReadBytes(header + kBasicPartSize, remain));
+    RINOK(ReadStream_FALSE(stream, header + kBasicPartSize, headerSize - kBasicPartSize));
     if (startHeader[1] != CalcSum(header, headerSize))
       return S_FALSE;
     size_t nameLength = *p++;
@@ -294,13 +270,13 @@ HRESULT CInArchive::GetNextItem(bool &filled, CItemEx &item)
     p = ReadString(p, nameLength, item.Name);
   }
   else
-   headerSize = startHeader[0] | ((UInt32)startHeader[1] << 8);
+    headerSize = startHeader[0] | ((UInt32)startHeader[1] << 8);
   p = ReadUInt16(p, item.CRC);
   if (item.Level != 0)
   {
     if (item.Level == 2)
     {
-      RINOK(CheckReadBytes(header + kBasicPartSize, 2));
+      RINOK(ReadStream_FALSE(stream, header + kBasicPartSize, 2));
     }
     if ((size_t)(p - header) + 3 > headerSize)
       return S_FALSE;
@@ -317,39 +293,30 @@ HRESULT CInArchive::GetNextItem(bool &filled, CItemEx &item)
           return S_FALSE;
         item.PackSize -= nextSize;
       }
+      if (item.Extensions.Size() >= (1 << 8))
+        return S_FALSE;
       CExtension ext;
-      RINOK(CheckReadBytes(&ext.Type, 1))
+      RINOK(ReadStream_FALSE(stream, &ext.Type, 1))
       nextSize -= 3;
-      ext.Data.SetCapacity(nextSize);
-      RINOK(CheckReadBytes((Byte *)ext.Data, nextSize))
+      ext.Data.Alloc(nextSize);
+      RINOK(ReadStream_FALSE(stream, (Byte *)ext.Data, nextSize))
       item.Extensions.Add(ext);
       Byte hdr2[2];
-      RINOK(CheckReadBytes(hdr2, 2));
+      RINOK(ReadStream_FALSE(stream, hdr2, 2));
       ReadUInt16(hdr2, nextSize);
     }
   }
-  item.DataPosition = m_Position;
   filled = true;
   return S_OK;
 }
 
-HRESULT CInArchive::Skip(UInt64 numBytes)
-{
-  UInt64 newPostion;
-  RINOK(m_Stream->Seek(numBytes, STREAM_SEEK_CUR, &newPostion));
-  m_Position += numBytes;
-  if (m_Position != newPostion)
-    return E_FAIL;
-  return S_OK;
-}
-
 struct COsPair
 {
   Byte Id;
   const char *Name;
 };
 
-static COsPair g_OsPairs[] =
+static const COsPair g_OsPairs[] =
 {
   {   0, "MS-DOS" },
   { 'M', "MS-DOS" },
@@ -374,23 +341,23 @@ static const char *kUnknownOS = "Unknown";
 
 static const char *GetOS(Byte osId)
 {
-  for (int i = 0; i < sizeof(g_OsPairs) / sizeof(g_OsPairs[0]); i++)
+  for (unsigned i = 0; i < ARRAY_SIZE(g_OsPairs); i++)
     if (g_OsPairs[i].Id == osId)
       return g_OsPairs[i].Name;
   return kUnknownOS;
 }
 
-static STATPROPSTG kProps[] =
+static const Byte kProps[] =
 {
-  { NULL, kpidPath, VT_BSTR},
-  { NULL, kpidIsDir, VT_BOOL},
-  { NULL, kpidSize, VT_UI8},
-  { NULL, kpidPackSize, VT_UI8},
-  { NULL, kpidMTime, VT_FILETIME},
-  // { NULL, kpidAttrib, VT_UI4},
-  { NULL, kpidCRC, VT_UI4},
-  { NULL, kpidMethod, VT_BSTR},
-  { NULL, kpidHostOS, VT_BSTR}
+  kpidPath,
+  kpidIsDir,
+  kpidSize,
+  kpidPackSize,
+  kpidMTime,
+  // kpidAttrib,
+  kpidCRC,
+  kpidMethod,
+  kpidHostOS
 };
 
 class CCRC
@@ -479,12 +446,20 @@ STDMETHODIMP COutStreamWithCRC::Write(const void *data, UInt32 size, UInt32 *pro
   return result;
 }
 
+struct CItemEx: public CItem
+{
+  UInt64 DataPosition;
+};
+
 class CHandler:
   public IInArchive,
   public CMyUnknownImp
 {
   CObjectVector<CItemEx> _items;
   CMyComPtr<IInStream> _stream;
+  UInt64 _phySize;
+  UInt32 _errorFlags;
+  bool _isArc;
 public:
   MY_UNKNOWN_IMP1(IInArchive)
   INTERFACE_IInArchive(;)
@@ -492,7 +467,7 @@ public:
 };
 
 IMP_IInArchive_Props
-IMP_IInArchive_ArcProps_NO
+IMP_IInArchive_ArcProps_NO_Table
 
 CHandler::CHandler() {}
 
@@ -502,20 +477,37 @@ STDMETHODIMP CHandler::GetNumberOfItems(UInt32 *numItems)
   return S_OK;
 }
 
-STDMETHODIMP CHandler::GetProperty(UInt32 index, PROPID propID,  PROPVARIANT *value)
+STDMETHODIMP CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value)
+{
+  NCOM::CPropVariant prop;
+  switch (propID)
+  {
+    case kpidPhySize: prop = _phySize; break;
+   
+    case kpidErrorFlags:
+      UInt32 v = _errorFlags;
+      if (!_isArc) v |= kpv_ErrorFlags_IsNotArc;
+      prop = v;
+      break;
+  }
+  prop.Detach(value);
+  return S_OK;
+}
+
+STDMETHODIMP CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value)
 {
   COM_TRY_BEGIN
-  NWindows::NCOM::CPropVariant prop;
+  NCOM::CPropVariant prop;
   const CItemEx &item = _items[index];
-  switch(propID)
+  switch (propID)
   {
     case kpidPath:
     {
       UString s = NItemName::WinNameToOSName(MultiByteToUnicodeString(item.GetName(), CP_OEMCP));
       if (!s.IsEmpty())
       {
-        if (s[s.Length() - 1] == WCHAR_PATH_SEPARATOR)
-           s.Delete(s.Length() - 1);
+        if (s.Back() == WCHAR_PATH_SEPARATOR)
+          s.DeleteBack();
         prop = s;
       }
       break;
@@ -564,35 +556,48 @@ STDMETHODIMP CHandler::Open(IInStream *stream,
     const UInt64 * /* maxCheckStartPosition */, IArchiveOpenCallback *callback)
 {
   COM_TRY_BEGIN
+  Close();
   try
   {
     _items.Clear();
-    CInArchive archive;
 
     UInt64 endPos = 0;
     bool needSetTotal = true;
 
-    if (callback != NULL)
-    {
-      RINOK(stream->Seek(0, STREAM_SEEK_END, &endPos));
-      RINOK(stream->Seek(0, STREAM_SEEK_SET, NULL));
-    }
+    RINOK(stream->Seek(0, STREAM_SEEK_END, &endPos));
+    RINOK(stream->Seek(0, STREAM_SEEK_SET, NULL));
 
-    RINOK(archive.Open(stream));
     for (;;)
     {
       CItemEx item;
       bool filled;
-      HRESULT result = archive.GetNextItem(filled, item);
+      HRESULT result = GetNextItem(stream, filled, item);
+      RINOK(stream->Seek(0, STREAM_SEEK_CUR, &item.DataPosition));
       if (result == S_FALSE)
-        return S_FALSE;
+      {
+        _errorFlags = kpv_ErrorFlags_HeadersError;
+        break;
+      }
+
       if (result != S_OK)
         return S_FALSE;
+      _phySize = item.DataPosition;
       if (!filled)
         break;
       _items.Add(item);
-      archive.Skip(item.PackSize);
-      if (callback != NULL)
+
+      _isArc = true;
+
+      UInt64 newPostion;
+      RINOK(stream->Seek(item.PackSize, STREAM_SEEK_CUR, &newPostion));
+      if (newPostion > endPos)
+      {
+        _phySize = endPos;
+        _errorFlags = kpv_ErrorFlags_UnexpectedEnd;
+        break;
+      }
+      _phySize = newPostion;
+      if (callback)
       {
         if (needSetTotal)
         {
@@ -622,6 +627,9 @@ STDMETHODIMP CHandler::Open(IInStream *stream,
 
 STDMETHODIMP CHandler::Close()
 {
+  _isArc = false;
+  _phySize = 0;
+  _errorFlags = 0;
   _items.Clear();
   _stream.Release();
   return S_OK;
@@ -633,7 +641,7 @@ STDMETHODIMP CHandler::Extract(const UInt32 *indices, UInt32 numItems,
   COM_TRY_BEGIN
   bool testMode = (testModeSpec != 0);
   UInt64 totalUnPacked = 0, totalPacked = 0;
-  bool allFilesMode = (numItems == (UInt32)-1);
+  bool allFilesMode = (numItems == (UInt32)(Int32)-1);
   if (allFilesMode)
     numItems = _items.Size();
   if (numItems == 0)
@@ -652,8 +660,8 @@ STDMETHODIMP CHandler::Extract(const UInt32 *indices, UInt32 numItems,
   
   NCompress::NLzh::NDecoder::CCoder *lzhDecoderSpec = 0;
   CMyComPtr<ICompressCoder> lzhDecoder;
-  CMyComPtr<ICompressCoder> lzh1Decoder;
-  CMyComPtr<ICompressCoder> arj2Decoder;
+  // CMyComPtr<ICompressCoder> lzh1Decoder;
+  // CMyComPtr<ICompressCoder> arj2Decoder;
 
   NCompress::CCopyCoder *copyCoderSpec = new NCompress::CCopyCoder();
   CMyComPtr<ICompressCoder> copyCoder = copyCoderSpec;
@@ -728,8 +736,11 @@ STDMETHODIMP CHandler::Extract(const UInt32 *indices, UInt32 numItems,
           lzhDecoderSpec = new NCompress::NLzh::NDecoder::CCoder;
           lzhDecoder = lzhDecoderSpec;
         }
-        lzhDecoderSpec->SetDictionary(item.GetNumDictBits());
+        lzhDecoderSpec->FinishMode = true;
+        lzhDecoderSpec->SetDictSize(1 << item.GetNumDictBits());
         result = lzhDecoder->Code(inStream, outStream, NULL, &currentItemUnPacked, progress);
+        if (result == S_OK && lzhDecoderSpec->GetInputProcessedSize() != item.PackSize)
+          result = S_FALSE;
       }
       /*
       else if (item.IsLh1GroupMethod())
@@ -744,7 +755,7 @@ STDMETHODIMP CHandler::Extract(const UInt32 *indices, UInt32 numItems,
       }
       */
       else
-        opRes = NExtract::NOperationResult::kUnSupportedMethod;
+        opRes = NExtract::NOperationResult::kUnsupportedMethod;
 
       if (opRes == NExtract::NOperationResult::kOK)
       {
@@ -765,11 +776,13 @@ STDMETHODIMP CHandler::Extract(const UInt32 *indices, UInt32 numItems,
   COM_TRY_END
 }
 
-static IInArchive *CreateArc() { return new CHandler; }
-
-static CArcInfo g_ArcInfo =
-  { L"Lzh", L"lzh lha", 0, 6, { '-', 'l' }, 2, false, CreateArc, 0 };
+static const Byte k_Signature[] = { '-', 'l', 'h' };
 
-REGISTER_ARC(Lzh)
+REGISTER_ARC_I(
+  "Lzh", "lzh lha", 0, 6,
+  k_Signature,
+  2,
+  0,
+  IsArc_Lzh)
 
 }}