seven-zip 1.4.2 → 1.7.0.rc1

data/ext/p7zip/CPP/7zip/Archive/Iso/IsoHandler.cpp

@@ -2,12 +2,12 @@
 
 #include "StdAfx.h"
 
-#include "Common/ComTry.h"
-#include "Common/IntToString.h"
-#include "Common/StringConvert.h"
+#include "../../../Common/ComTry.h"
+#include "../../../Common/IntToString.h"
+#include "../../../Common/StringConvert.h"
 
-#include "Windows/PropVariant.h"
-#include "Windows/Time.h"
+#include "../../../Windows/PropVariant.h"
+#include "../../../Windows/TimeUtils.h"
 
 #include "../../Common/LimitedStreams.h"
 #include "../../Common/ProgressUtils.h"
@@ -24,22 +24,21 @@ using namespace NTime;
 namespace NArchive {
 namespace NIso {
 
-static const 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}
+  kpidPath,
+  kpidIsDir,
+  kpidSize,
+  kpidPackSize,
+  kpidMTime
 };
 
-static const STATPROPSTG kArcProps[] =
+static const Byte kArcProps[] =
 {
-  { NULL, kpidComment, VT_BSTR},
-  { NULL, kpidCTime, VT_FILETIME},
-  { NULL, kpidMTime, VT_FILETIME}
-  // { NULL, kpidPhySize, VT_UI8},
-  // { NULL, kpidHeadersSize, VT_UI8}
+  kpidComment,
+  kpidCTime,
+  kpidMTime,
+  // kpidHeadersSize
 };
 
 IMP_IInArchive_Props
@@ -51,13 +50,10 @@ STDMETHODIMP CHandler::Open(IInStream *stream,
 {
   COM_TRY_BEGIN
   Close();
-  // try
   {
-    if (_archive.Open(stream) != S_OK)
-      return S_FALSE;
+    RINOK(_archive.Open(stream));
     _stream = stream;
   }
-  // catch(...) { return S_FALSE; }
   return S_OK;
   COM_TRY_END
 }
@@ -75,16 +71,15 @@ STDMETHODIMP CHandler::GetNumberOfItems(UInt32 *numItems)
   return S_OK;
 }
 
-static void AddString(AString &s, const char *name, const Byte *p, int size)
+static void AddString(AString &s, const char *name, const Byte *p, unsigned size)
 {
-  int i;
+  unsigned i;
   for (i = 0; i < size && p[i]; i++);
   for (; i > 0 && p[i - 1] == ' '; i--);
   if (i != 0)
   {
     AString d;
-    memcpy(d.GetBuffer(i), p, i);
-    d.ReleaseBuffer(i);
+    d.SetFrom((const char *)p, i);
     s += '\n';
     s += name;
     s += ": ";
@@ -92,14 +87,23 @@ static void AddString(AString &s, const char *name, const Byte *p, int size)
   }
 }
 
-#define ADD_STRING(n, V) AddString(s, n, vol. V, sizeof(vol. V))
+#define ADD_STRING(n, v) AddString(s, n, vol. v, sizeof(vol. v))
+
+static void AddErrorMessage(AString &s, const char *message)
+{
+  if (!s.IsEmpty())
+    s += ". ";
+  s += message;
+}
 
 STDMETHODIMP CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value)
 {
   COM_TRY_BEGIN
-  NWindows::NCOM::CPropVariant prop;
+  NCOM::CPropVariant prop;
+  if (_stream)
+  {
   const CVolumeDescriptor &vol = _archive.VolDescs[_archive.MainVolDescIndex];
-  switch(propID)
+  switch (propID)
   {
     case kpidComment:
     {
@@ -118,9 +122,35 @@ STDMETHODIMP CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value)
     }
     case kpidCTime: { FILETIME utc; if (vol.CTime.GetFileTime(utc)) prop = utc; break; }
     case kpidMTime: { FILETIME utc; if (vol.MTime.GetFileTime(utc)) prop = utc; break; }
-    // case kpidPhySize: break;
-    // case kpidHeadersSize: break;
-    case kpidError: if (_archive.IncorrectBigEndian) prop = "Incorrect big-endian headers"; break;
+  }
+  }
+
+  switch (propID)
+  {
+    case kpidPhySize: prop = _archive.PhySize; break;
+    case kpidErrorFlags:
+    {
+      UInt32 v = 0;
+      if (!_archive.IsArc) v |= kpv_ErrorFlags_IsNotArc;
+      if (_archive.UnexpectedEnd) v |= kpv_ErrorFlags_UnexpectedEnd;
+      if (_archive.HeadersError) v |= kpv_ErrorFlags_HeadersError;
+      prop = v;
+      break;
+    }
+    
+    case kpidError:
+    {
+      AString s;
+      if (_archive.IncorrectBigEndian)
+        AddErrorMessage(s, "Incorrect big-endian headers");
+      if (_archive.SelfLinkedDirs)
+        AddErrorMessage(s, "Self-linked directory");
+      if (_archive.TooDeepDirs)
+        AddErrorMessage(s, "Too deep directory levels");
+      if (!s.IsEmpty())
+        prop = s;
+      break;
+    }
   }
   prop.Detach(value);
   return S_OK;
@@ -130,22 +160,25 @@ STDMETHODIMP CHandler::GetArchiveProperty(PROPID propID, PROPVARIANT *value)
 STDMETHODIMP CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *value)
 {
   COM_TRY_BEGIN
-  NWindows::NCOM::CPropVariant prop;
+  NCOM::CPropVariant prop;
   if (index >= (UInt32)_archive.Refs.Size())
   {
     index -= _archive.Refs.Size();
     const CBootInitialEntry &be = _archive.BootEntries[index];
-    switch(propID)
+    switch (propID)
     {
       case kpidPath:
       {
-        // wchar_t name[32];
-        // ConvertUInt64ToString(index + 1, name);
-        UString s = L"[BOOT]" WSTRING_PATH_SEPARATOR;
-        // s += name;
-        // s += L"-";
+        AString s = "[BOOT]" STRING_PATH_SEPARATOR;
+        if (_archive.BootEntries.Size() != 1)
+        {
+          char temp[16];
+          ConvertUInt32ToString(index + 1, temp);
+          s += temp;
+          s += '-';
+        }
         s += be.GetName();
-        prop = (const wchar_t *)s;
+        prop = s;
         break;
       }
       case kpidIsDir: prop = false; break;
@@ -159,32 +192,32 @@ STDMETHODIMP CHandler::GetProperty(UInt32 index, PROPID propID, PROPVARIANT *val
   {
     const CRef &ref = _archive.Refs[index];
     const CDir &item = ref.Dir->_subItems[ref.Index];
-    switch(propID)
+    switch (propID)
     {
       case kpidPath:
         // if (item.FileId.GetCapacity() >= 0)
         {
           UString s;
           if (_archive.IsJoliet())
-            s = item.GetPathU();
+            item.GetPathU(s);
           else
             s = MultiByteToUnicodeString(item.GetPath(_archive.IsSusp, _archive.SuspSkipSize), CP_OEMCP);
 
-          int pos = s.ReverseFind(L';');
-          if (pos >= 0 && pos == s.Length() - 2)
-              if (s[s.Length() - 1] == L'1')
-                s = s.Left(pos);
-          if (!s.IsEmpty())
-            if (s[s.Length() - 1] == L'.')
-              s = s.Left(s.Length() - 1);
-          prop = (const wchar_t *)NItemName::GetOSName2(s);
+          if (s.Len() >= 2 && s[s.Len() - 2] == ';' && s.Back() == '1')
+            s.DeleteFrom(s.Len() - 2);
+          
+          if (!s.IsEmpty() && s.Back() == L'.')
+            s.DeleteBack();
+
+          NItemName::ConvertToOSName2(s);
+          prop = s;
         }
         break;
       case kpidIsDir: prop = item.IsDir(); break;
       case kpidSize:
       case kpidPackSize:
         if (!item.IsDir())
-          prop = (UInt64)item.DataLength;
+          prop = (UInt64)ref.TotalSize;
         break;
       case kpidMTime:
       {
@@ -204,26 +237,25 @@ STDMETHODIMP CHandler::Extract(const UInt32 *indices, UInt32 numItems,
     Int32 testMode, IArchiveExtractCallback *extractCallback)
 {
   COM_TRY_BEGIN
-  bool allFilesMode = (numItems == (UInt32)-1);
+  bool allFilesMode = (numItems == (UInt32)(Int32)-1);
   if (allFilesMode)
     numItems = _archive.Refs.Size();
   if (numItems == 0)
     return S_OK;
   UInt64 totalSize = 0;
   UInt32 i;
-  for(i = 0; i < numItems; i++)
+  for (i = 0; i < numItems; i++)
   {
     UInt32 index = (allFilesMode ? i : indices[i]);
     if (index < (UInt32)_archive.Refs.Size())
     {
       const CRef &ref = _archive.Refs[index];
       const CDir &item = ref.Dir->_subItems[ref.Index];
-      totalSize += item.DataLength;
+      if (!item.IsDir())
+        totalSize += ref.TotalSize;
     }
     else
-    {
       totalSize += _archive.GetBootItemSize(index - _archive.Refs.Size());
-    }
   }
   extractCallback->SetTotal(totalSize);
 
@@ -241,9 +273,6 @@ STDMETHODIMP CHandler::Extract(const UInt32 *indices, UInt32 numItems,
   CMyComPtr<ISequentialInStream> inStream(streamSpec);
   streamSpec->SetStream(_stream);
 
-  CLimitedSequentialOutStream *outStreamSpec = new CLimitedSequentialOutStream;
-  CMyComPtr<ISequentialOutStream> outStream(outStreamSpec);
-
   for (i = 0; i < numItems; i++, currentTotalSize += currentItemSize)
   {
     lps->InSize = lps->OutSize = currentTotalSize;
@@ -268,28 +297,53 @@ STDMETHODIMP CHandler::Extract(const UInt32 *indices, UInt32 numItems,
         RINOK(extractCallback->SetOperationResult(NExtract::NOperationResult::kOK));
         continue;
       }
-      currentItemSize = item.DataLength;
+      currentItemSize = ref.TotalSize;
       blockIndex = item.ExtentLocation;
     }
     else
     {
-      int bootIndex = index - _archive.Refs.Size();
+      unsigned bootIndex = index - _archive.Refs.Size();
       const CBootInitialEntry &be = _archive.BootEntries[bootIndex];
       currentItemSize = _archive.GetBootItemSize(bootIndex);
       blockIndex = be.LoadRBA;
     }
    
+
     if (!testMode && !realOutStream)
       continue;
+
     RINOK(extractCallback->PrepareOperation(askMode));
-    outStreamSpec->SetStream(realOutStream);
+
+    bool isOK = true;
+    if (index < (UInt32)_archive.Refs.Size())
+    {
+      const CRef &ref = _archive.Refs[index];
+      UInt64 offset = 0;
+      for (UInt32 e = 0; e < ref.NumExtents; e++)
+      {
+        lps->InSize = lps->OutSize = currentTotalSize + offset;
+        const CDir &item2 = ref.Dir->_subItems[ref.Index + e];
+        RINOK(_stream->Seek((UInt64)item2.ExtentLocation * kBlockSize, STREAM_SEEK_SET, NULL));
+        streamSpec->Init(item2.Size);
+        RINOK(copyCoder->Code(inStream, realOutStream, NULL, NULL, progress));
+        if (copyCoderSpec->TotalSize != item2.Size)
+        {
+          isOK = false;
+          break;
+        }
+        offset += item2.Size;
+      }
+    }
+    else
+    {
+      RINOK(_stream->Seek((UInt64)blockIndex * kBlockSize, STREAM_SEEK_SET, NULL));
+      streamSpec->Init(currentItemSize);
+      RINOK(copyCoder->Code(inStream, realOutStream, NULL, NULL, progress));
+      if (copyCoderSpec->TotalSize != currentItemSize)
+        isOK = false;
+    }
     realOutStream.Release();
-    outStreamSpec->Init(currentItemSize);
-    RINOK(_stream->Seek(blockIndex * _archive.BlockSize, STREAM_SEEK_SET, NULL));
-    streamSpec->Init(currentItemSize);
-    RINOK(copyCoder->Code(inStream, outStream, NULL, NULL, progress));
-    outStreamSpec->ReleaseStream();
-    RINOK(extractCallback->SetOperationResult(outStreamSpec->IsFinishedOK() ?
+    RINOK(extractCallback->SetOperationResult(isOK ?
         NExtract::NOperationResult::kOK:
         NExtract::NOperationResult::kDataError));
   }
@@ -303,23 +357,56 @@ STDMETHODIMP CHandler::GetStream(UInt32 index, ISequentialInStream **stream)
   *stream = 0;
   UInt64 blockIndex;
   UInt64 currentItemSize;
-  if (index < (UInt32)_archive.Refs.Size())
+  
+  if (index < _archive.Refs.Size())
   {
     const CRef &ref = _archive.Refs[index];
     const CDir &item = ref.Dir->_subItems[ref.Index];
     if (item.IsDir())
       return S_FALSE;
-    currentItemSize = item.DataLength;
+
+    if (ref.NumExtents > 1)
+    {
+      CExtentsStream *extentStreamSpec = new CExtentsStream();
+      CMyComPtr<ISequentialInStream> extentStream = extentStreamSpec;
+      
+      extentStreamSpec->Stream = _stream;
+      
+      UInt64 virtOffset = 0;
+      for (UInt32 i = 0; i < ref.NumExtents; i++)
+      {
+        const CDir &item2 = ref.Dir->_subItems[ref.Index + i];
+        if (item2.Size == 0)
+          continue;
+        CSeekExtent se;
+        se.Phy = (UInt64)item2.ExtentLocation * kBlockSize;
+        se.Virt = virtOffset;
+        extentStreamSpec->Extents.Add(se);
+        virtOffset += item2.Size;
+      }
+      if (virtOffset != ref.TotalSize)
+        return S_FALSE;
+      CSeekExtent se;
+      se.Phy = 0;
+      se.Virt = virtOffset;
+      extentStreamSpec->Extents.Add(se);
+      extentStreamSpec->Init();
+      *stream = extentStream.Detach();
+      return S_OK;
+    }
+    
+    currentItemSize = item.Size;
     blockIndex = item.ExtentLocation;
   }
   else
   {
-    int bootIndex = index - _archive.Refs.Size();
+    unsigned bootIndex = index - _archive.Refs.Size();
     const CBootInitialEntry &be = _archive.BootEntries[bootIndex];
     currentItemSize = _archive.GetBootItemSize(bootIndex);
     blockIndex = be.LoadRBA;
   }
-  return CreateLimitedInStream(_stream, blockIndex * _archive.BlockSize, currentItemSize, stream);
+  
+  return CreateLimitedInStream(_stream, (UInt64)blockIndex * kBlockSize, currentItemSize, stream);
   COM_TRY_END
 }
 

data/ext/p7zip/CPP/7zip/Archive/Iso/IsoHandler.h

@@ -3,7 +3,8 @@
 #ifndef __ISO_HANDLER_H
 #define __ISO_HANDLER_H
 
-#include "Common/MyCom.h"
+#include "../../../Common/MyCom.h"
+
 #include "../IArchive.h"
 
 #include "IsoIn.h"

data/ext/p7zip/CPP/7zip/Archive/Iso/IsoHeader.cpp

@@ -9,13 +9,4 @@ namespace NIso {
 
 const char *kElToritoSpec = "EL TORITO SPECIFICATION\0\0\0\0\0\0\0\0\0";
 
-const wchar_t *kMediaTypes[5] =
-{
-  L"NoEmulation",
-  L"1.2M",
-  L"1.44M",
-  L"2.88M",
-  L"HardDisk"
-};
-
 }}

data/ext/p7zip/CPP/7zip/Archive/Iso/IsoHeader.h

@@ -3,7 +3,7 @@
 #ifndef __ARCHIVE_ISO_HEADER_H
 #define __ARCHIVE_ISO_HEADER_H
 
-#include "Common/Types.h"
+#include "../../../Common/MyTypes.h"
 
 namespace NArchive {
 namespace NIso {
@@ -22,6 +22,7 @@ const Byte kVersion = 1;
 namespace NFileFlags
 {
   const Byte kDirectory = 1 << 1;
+  const Byte kNonFinalExtent = 1 << 7;
 }
 
 extern const char *kElToritoSpec;
@@ -33,6 +34,11 @@ namespace NBootEntryId
   const Byte kValidationEntry = 1;
   const Byte kInitialEntryNotBootable = 0;
   const Byte kInitialEntryBootable = 0x88;
+
+  const Byte kMoreHeaders = 0x90;
+  const Byte kFinalHeader = 0x91;
+  
+  const Byte kExtensionIndicator = 0x44;
 }
 
 namespace NBootPlatformId
@@ -42,7 +48,7 @@ namespace NBootPlatformId
   const Byte kMac = 2;
 }
 
-const BYTE kBootMediaTypeMask = 0xF;
+const Byte kBootMediaTypeMask = 0xF;
 
 namespace NBootMediaType
 {
@@ -53,9 +59,6 @@ namespace NBootMediaType
   const Byte kHardDisk = 4;
 }
 
-const int kNumBootMediaTypes = 5;
-extern const wchar_t *kMediaTypes[];
-
 }}
 
 #endif