seven-zip 1.4.2 → 1.7.0.rc1

data/ext/p7zip/CPP/7zip/Compress/XpressDecoder.cpp

@@ -0,0 +1,129 @@
+// XpressDecoder.cpp
+
+#include "StdAfx.h"
+
+// #include <stdio.h>
+
+#include "../../../C/CpuArch.h"
+
+#include "HuffmanDecoder.h"
+
+namespace NCompress {
+namespace NXpress {
+
+struct CBitStream
+{
+  UInt32 Value;
+  unsigned BitPos;
+
+  UInt32 GetValue(unsigned numBits) const
+  {
+    return (Value >> (BitPos - numBits)) & ((1 << numBits) - 1);
+  }
+  
+  void MovePos(unsigned numBits)
+  {
+    BitPos -= numBits;
+  }
+};
+
+#define BIT_STREAM_NORMALIZE \
+    if (bs.BitPos < 16) { \
+      if (in >= lim) return S_FALSE; \
+      bs.Value = (bs.Value << 16) | GetUi16(in); \
+      in += 2; bs.BitPos += 16; }
+ 
+const unsigned kNumHuffBits = 15;
+const unsigned kNumLenSlots = 16;
+const unsigned kNumPosSlots = 16;
+const unsigned kNumSyms = 256 + kNumPosSlots * kNumLenSlots;
+
+HRESULT Decode(const Byte *in, size_t inSize, Byte *out, size_t outSize)
+{
+  NCompress::NHuffman::CDecoder<kNumHuffBits, kNumSyms> huff;
+  
+  if (inSize < kNumSyms / 2 + 4)
+    return S_FALSE;
+  {
+    Byte levels[kNumSyms];
+    for (unsigned i = 0; i < kNumSyms / 2; i++)
+    {
+      Byte b = in[i];
+      levels[i * 2] = (Byte)(b & 0xF);
+      levels[i * 2 + 1] = (Byte)(b >> 4);
+    }
+    if (!huff.BuildFull(levels))
+      return S_FALSE;
+  }
+
+
+  CBitStream bs;
+
+  const Byte *lim = in + inSize - 1;
+
+  in += kNumSyms / 2;
+  bs.Value = (GetUi16(in) << 16) | GetUi16(in + 2);
+  in += 4;
+  bs.BitPos = 32;
+
+  size_t pos = 0;
+
+  for (;;)
+  {
+    // printf("\n%d", pos);
+    UInt32 sym = huff.DecodeFull(&bs);
+    // printf(" sym = %d", sym);
+    BIT_STREAM_NORMALIZE
+
+    if (pos >= outSize)
+      return (sym == 256 && in == lim + 1) ? S_OK : S_FALSE;
+
+    if (sym < 256)
+      out[pos++] = (Byte)sym;
+    else
+    {
+      sym -= 256;
+      UInt32 dist = sym / kNumLenSlots;
+      UInt32 len = sym & (kNumLenSlots - 1);
+      
+      if (len == kNumLenSlots - 1)
+      {
+        if (in > lim)
+          return S_FALSE;
+        len = *in++;
+        if (len == 0xFF)
+        {
+          if (in >= lim)
+            return S_FALSE;
+          len = GetUi16(in);
+          in += 2;
+        }
+        else
+          len += kNumLenSlots - 1;
+      }
+
+      bs.BitPos -= dist;
+      dist = (UInt32)1 << dist;
+      dist += ((bs.Value >> bs.BitPos) & (dist - 1));
+
+      BIT_STREAM_NORMALIZE
+      
+      if (len > outSize - pos)
+        return S_FALSE;
+      if (dist > pos)
+        return S_FALSE;
+
+      Byte *dest = out + pos;
+      const Byte *src = dest - dist;
+      pos += len + 3;
+      len += 1;
+      *dest++ = *src++;
+      *dest++ = *src++;
+      do
+        *dest++ = *src++;
+      while (--len);
+    }
+  }
+}
+
+}}

data/ext/p7zip/CPP/7zip/Compress/XpressDecoder.h

@@ -0,0 +1,13 @@
+// XpressDecoder.h
+
+#ifndef __XPRESS_DECODER_H
+#define __XPRESS_DECODER_H
+
+namespace NCompress {
+namespace NXpress {
+
+HRESULT Decode(const Byte *in, size_t inSize, Byte *out, size_t outSize);
+
+}}
+
+#endif

data/ext/p7zip/CPP/7zip/Compress/ZDecoder.cpp

@@ -2,6 +2,8 @@
 
 #include "StdAfx.h"
 
+// #include <stdio.h>
+
 #include "../../../C/Alloc.h"
 
 #include "../Common/InBuffer.h"
@@ -15,8 +17,8 @@ namespace NZ {
 static const UInt32 kBufferSize = (1 << 20);
 static const Byte kNumBitsMask = 0x1F;
 static const Byte kBlockModeMask = 0x80;
-static const int kNumMinBits = 9;
-static const int kNumMaxBits = 16;
+static const unsigned kNumMinBits = 9;
+static const unsigned kNumMaxBits = 16;
 
 void CDecoder::Free()
 {
@@ -33,6 +35,8 @@ HRESULT CDecoder::CodeReal(ISequentialInStream *inStream, ISequentialOutStream *
   CInBuffer inBuffer;
   COutBuffer outBuffer;
 
+  PackSize = 0;
+  
   if (!inBuffer.Create(kBufferSize))
     return E_OUTOFMEMORY;
   inBuffer.SetStream(inStream);
@@ -43,11 +47,22 @@ HRESULT CDecoder::CodeReal(ISequentialInStream *inStream, ISequentialOutStream *
   outBuffer.SetStream(outStream);
   outBuffer.Init();
 
-  int maxbits = _properties & kNumBitsMask;
+  Byte buf[kNumMaxBits + 4];
+  {
+    if (inBuffer.ReadBytes(buf, 3) < 3)
+      return S_FALSE;
+    if (buf[0] != 0x1F || buf[1] != 0x9D)
+      return S_FALSE;;
+  }
+  Byte prop = buf[2];
+
+  if ((prop & 0x60) != 0)
+    return S_FALSE;
+  unsigned maxbits = prop & kNumBitsMask;
   if (maxbits < kNumMinBits || maxbits > kNumMaxBits)
     return S_FALSE;
   UInt32 numItems = 1 << maxbits;
-  bool blockMode = ((_properties & kBlockModeMask) != 0);
+  // Speed optimization: blockSymbol can contain unused velue.
 
   if (maxbits != _numMaxBits || _parents == 0 || _suffixes == 0 || _stack == 0)
   {
@@ -59,18 +74,16 @@ HRESULT CDecoder::CodeReal(ISequentialInStream *inStream, ISequentialOutStream *
   }
 
   UInt64 prevPos = 0;
-  int numBits = kNumMinBits;
-  UInt32 head = blockMode ? 257 : 256;
-
+  UInt32 blockSymbol = ((prop & kBlockModeMask) != 0) ? 256 : ((UInt32)1 << kNumMaxBits);
+  unsigned numBits = kNumMinBits;
+  UInt32 head = (blockSymbol == 256) ? 257 : 256;
   bool needPrev = false;
-
   unsigned bitPos = 0;
   unsigned numBufBits = 0;
 
-  Byte buf[kNumMaxBits + 4];
-
   _parents[256] = 0; // virus protection
   _suffixes[256] = 0;
+  HRESULT res = S_OK;
 
   for (;;)
   {
@@ -79,7 +92,7 @@ HRESULT CDecoder::CodeReal(ISequentialInStream *inStream, ISequentialOutStream *
       numBufBits = (unsigned)inBuffer.ReadBytes(buf, numBits) * 8;
       bitPos = 0;
       UInt64 nowPos = outBuffer.GetProcessedSize();
-      if (progress != NULL && nowPos - prevPos >= (1 << 18))
+      if (progress && nowPos - prevPos >= (1 << 13))
       {
         prevPos = nowPos;
         UInt64 packSize = inBuffer.GetProcessedSize();
@@ -94,8 +107,11 @@ HRESULT CDecoder::CodeReal(ISequentialInStream *inStream, ISequentialOutStream *
     if (bitPos > numBufBits)
       break;
     if (symbol >= head)
-      return S_FALSE;
-    if (blockMode && symbol == 256)
+    {
+      res = S_FALSE;
+      break;
+    }
+    if (symbol == blockSymbol)
     {
       numBufBits = bitPos = 0;
       numBits = kNumMinBits;
@@ -104,7 +120,7 @@ HRESULT CDecoder::CodeReal(ISequentialInStream *inStream, ISequentialOutStream *
       continue;
     }
     UInt32 cur = symbol;
-    int i = 0;
+    unsigned i = 0;
     while (cur >= 256)
     {
       _stack[i++] = _suffixes[cur];
@@ -136,7 +152,9 @@ HRESULT CDecoder::CodeReal(ISequentialInStream *inStream, ISequentialOutStream *
     else
       needPrev = false;
   }
-  return outBuffer.Flush();
+  PackSize = inBuffer.GetProcessedSize();
+  HRESULT res2 = outBuffer.Flush();
+  return (res == S_OK) ? res2 : res;
 }
 
 STDMETHODIMP CDecoder::Code(ISequentialInStream *inStream, ISequentialOutStream *outStream,
@@ -148,12 +166,72 @@ STDMETHODIMP CDecoder::Code(ISequentialInStream *inStream, ISequentialOutStream
   catch(...) { return S_FALSE; }
 }
 
-STDMETHODIMP CDecoder::SetDecoderProperties2(const Byte *data, UInt32 size)
+bool CheckStream(const Byte *data, size_t size)
 {
-  if (size < 1)
-    return E_INVALIDARG;
-  _properties = data[0];
-  return S_OK;
+  if (size < 3)
+    return false;
+  if (data[0] != 0x1F || data[1] != 0x9D)
+    return false;
+  Byte prop = data[2];
+  if ((prop & 0x60) != 0)
+    return false;
+  unsigned maxbits = prop & kNumBitsMask;
+  if (maxbits < kNumMinBits || maxbits > kNumMaxBits)
+    return false;
+  UInt32 numItems = 1 << maxbits;
+  UInt32 blockSymbol = ((prop & kBlockModeMask) != 0) ? 256 : ((UInt32)1 << kNumMaxBits);
+  unsigned numBits = kNumMinBits;
+  UInt32 head = (blockSymbol == 256) ? 257 : 256;
+  unsigned bitPos = 0;
+  unsigned numBufBits = 0;
+  Byte buf[kNumMaxBits + 4];
+  data += 3;
+  size -= 3;
+  // printf("\n\n");
+  for (;;)
+  {
+    if (numBufBits == bitPos)
+    {
+      unsigned num = (numBits < size) ? numBits : (unsigned)size;
+      memcpy(buf, data, num);
+      data += num;
+      size -= num;
+      numBufBits = num * 8;
+      bitPos = 0;
+    }
+    unsigned bytePos = bitPos >> 3;
+    UInt32 symbol = buf[bytePos] | ((UInt32)buf[bytePos + 1] << 8) | ((UInt32)buf[bytePos + 2] << 16);
+    symbol >>= (bitPos & 7);
+    symbol &= (1 << numBits) - 1;
+    bitPos += numBits;
+    if (bitPos > numBufBits)
+    {
+      // printf("  OK", symbol);
+      return true;
+    }
+    // printf("%3X ", symbol);
+    if (symbol >= head)
+      return false;
+    if (symbol == blockSymbol)
+    {
+      numBufBits = bitPos = 0;
+      numBits = kNumMinBits;
+      head = 257;
+      continue;
+    }
+    if (head < numItems)
+    {
+      head++;
+      if (head > ((UInt32)1 << numBits))
+      {
+        if (numBits < maxbits)
+        {
+          numBufBits = bitPos = 0;
+          numBits++;
+        }
+      }
+    }
+  }
 }
 
 }}

data/ext/p7zip/CPP/7zip/Compress/ZDecoder.h

@@ -10,33 +10,45 @@
 namespace NCompress {
 namespace NZ {
 
+// Z decoder decodes Z data stream, including 3 bytes of header.
+  
 class CDecoder:
   public ICompressCoder,
-  public ICompressSetDecoderProperties2,
   public CMyUnknownImp
 {
   UInt16 *_parents;
   Byte *_suffixes;
   Byte *_stack;
-  Byte _properties;
-  int _numMaxBits;
+  unsigned _numMaxBits;
 
 public:
-  CDecoder(): _parents(0), _suffixes(0), _stack(0), _properties(0), _numMaxBits(0) {};
+  CDecoder(): _parents(0), _suffixes(0), _stack(0), /* _prop(0), */ _numMaxBits(0) {};
   ~CDecoder();
   void Free();
+  UInt64 PackSize;
 
-  MY_UNKNOWN_IMP1(ICompressSetDecoderProperties2)
+  MY_UNKNOWN_IMP1(ICompressCoder)
 
   HRESULT CodeReal(ISequentialInStream *inStream, ISequentialOutStream *outStream,
       const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress);
 
   STDMETHOD(Code)(ISequentialInStream *inStream, ISequentialOutStream *outStream,
       const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress);
-
-  STDMETHOD(SetDecoderProperties2)(const Byte *data, UInt32 size);
 };
 
+/*
+  There is no end_of_payload_marker in Z stream.
+  Z decoder stops decoding, if it reaches end of input stream.
+   
+  CheckStream function:
+    (size) must be at least 3 bytes (size of Z header).
+    if (size) is larger than size of real Z stream in (data), CheckStream can return false.
+*/
+
+const unsigned kRecommendedCheckSize = 64;
+
+bool CheckStream(const Byte *data, size_t size);
+
 }}
 
 #endif

data/ext/p7zip/CPP/7zip/Compress/ZlibDecoder.cpp

@@ -38,9 +38,12 @@ UInt32 Adler32_Update(UInt32 adler, const Byte *buf, size_t size)
 
 STDMETHODIMP COutStreamWithAdler::Write(const void *data, UInt32 size, UInt32 *processedSize)
 {
-  HRESULT result = _stream->Write(data, size, &size);
+  HRESULT result = S_OK;
+  if (_stream)
+    result = _stream->Write(data, size, &size);
   _adler = Adler32_Update(_adler, (const Byte *)data, size);
-  if (processedSize != NULL)
+  _size += size;
+  if (processedSize)
     *processedSize = size;
   return result;
 }
@@ -58,21 +61,21 @@ STDMETHODIMP CDecoder::Code(ISequentialInStream *inStream, ISequentialOutStream
     DeflateDecoder = DeflateDecoderSpec;
   }
 
+  if (inSize && *inSize < 2)
+    return S_FALSE;
   Byte buf[2];
   RINOK(ReadStream_FALSE(inStream, buf, 2));
-  int method = buf[0] & 0xF;
-  if (method != 8)
-    return S_FALSE;
-  // int dicSize = buf[0] >> 4;
-  if ((((UInt32)buf[0] << 8) + buf[1]) % 31 != 0)
+  if (!IsZlib(buf))
     return S_FALSE;
-  if ((buf[1] & 0x20) != 0) // dictPresent
-    return S_FALSE;
-  // int level = (buf[1] >> 6);
 
   AdlerSpec->SetStream(outStream);
   AdlerSpec->Init();
-  HRESULT res = DeflateDecoder->Code(inStream, AdlerStream, inSize, outSize, progress);
+  
+  UInt64 inSize2 = 0;
+  if (inSize)
+    inSize2 = *inSize - 2;
+
+  HRESULT res = DeflateDecoder->Code(inStream, AdlerStream, inSize ? &inSize2 : NULL, outSize, progress);
   AdlerSpec->ReleaseStream();
 
   if (res == S_OK)

data/ext/p7zip/CPP/7zip/Compress/ZlibDecoder.h

@@ -16,13 +16,15 @@ class COutStreamWithAdler:
 {
   CMyComPtr<ISequentialOutStream> _stream;
   UInt32 _adler;
+  UInt64 _size;
 public:
   MY_UNKNOWN_IMP
   STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize);
   void SetStream(ISequentialOutStream *stream) { _stream = stream; }
   void ReleaseStream() { _stream.Release(); }
-  void Init() { _adler = ADLER_INIT_VAL; }
+  void Init() { _adler = ADLER_INIT_VAL; _size = 0; }
   UInt32 GetAdler() const { return _adler; }
+  UInt64 GetSize() const { return _size; }
 };
 
 class CDecoder:
@@ -39,10 +41,39 @@ public:
       const UInt64 *inSize, const UInt64 *outSize, ICompressProgressInfo *progress);
 
   UInt64 GetInputProcessedSize() const { return DeflateDecoderSpec->GetInputProcessedSize() + 2; }
+  UInt64 GetOutputProcessedSize() const { return AdlerSpec->GetSize(); }
 
   MY_UNKNOWN_IMP
 };
 
+static bool inline IsZlib(const Byte *p)
+{
+  if ((p[0] & 0xF) != 8) // method
+    return false;
+  if (((unsigned)p[0] >> 4) > 7) // logar_window_size minus 8.
+    return false;
+  if ((p[1] & 0x20) != 0) // dictPresent
+    return false;
+  if ((((UInt32)p[0] << 8) + p[1]) % 31 != 0)
+    return false;
+  return true;
+}
+
+// IsZlib_3bytes checks 2 bytes of zlib header and starting byte of Deflate stream
+
+static bool inline IsZlib_3bytes(const Byte *p)
+{
+  if (!IsZlib(p))
+    return false;
+  unsigned val = p[2];
+  unsigned blockType = (val >> 1) & 0x3;
+  if (blockType == 3) // unsupported block type for deflate
+    return false;
+  if (blockType == NCompress::NDeflate::NBlockType::kStored && (val >> 3) != 0)
+    return false;
+  return true;
+}
+
 }}
 
 #endif