seven-zip 1.4.2 → 1.7.0.rc1

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

@@ -2,24 +2,105 @@
 
 #include "StdAfx.h"
 
-#include "IsoIn.h"
+#include "../../../../C/CpuArch.h"
+
+#include "../../../Common/MyException.h"
 
 #include "../../Common/StreamUtils.h"
 
+#include "../HandlerCont.h"
+
+#include "IsoIn.h"
+
 namespace NArchive {
 namespace NIso {
- 
+
+struct CUnexpectedEndException {};
+struct CHeaderErrorException {};
+struct CEndianErrorException {};
+
+static const char * const kMediaTypes[] =
+{
+    "NoEmul"
+  , "1.2M"
+  , "1.44M"
+  , "2.88M"
+  , "HardDisk"
+};
+
+bool CBootInitialEntry::Parse(const Byte *p)
+{
+  Bootable = (p[0] == NBootEntryId::kInitialEntryBootable);
+  BootMediaType = p[1];
+  LoadSegment = GetUi16(p + 2);
+  SystemType = p[4];
+  SectorCount = GetUi16(p + 6);
+  LoadRBA = GetUi32(p + 8);
+  memcpy(VendorSpec, p + 12, 20);
+  if (p[5] != 0)
+    return false;
+  if (p[0] != NBootEntryId::kInitialEntryBootable
+      && p[0] != NBootEntryId::kInitialEntryNotBootable)
+    return false;
+  return true;
+}
+
+AString CBootInitialEntry::GetName() const
+{
+  AString s = (Bootable ? "Boot" : "NotBoot");
+  s += '-';
+  
+  if (BootMediaType < ARRAY_SIZE(kMediaTypes))
+    s += kMediaTypes[BootMediaType];
+  else
+  {
+    char name[16];
+    ConvertUInt32ToString(BootMediaType, name);
+    s += name;
+  }
+  
+  if (VendorSpec[0] == 1)
+  {
+    // "Language and Version Information (IBM)"
+
+    unsigned i;
+    for (i = 1; i < sizeof(VendorSpec); i++)
+      if (VendorSpec[i] > 0x7F)
+        break;
+    if (i == sizeof(VendorSpec))
+    {
+      s += '-';
+      for (i = 1; i < sizeof(VendorSpec); i++)
+      {
+        char c = VendorSpec[i];
+        if (c == 0)
+          break;
+        if (c == '\\' || c == '/')
+          c = '_';
+        s += c;
+      }
+    }
+  }
+
+  s += ".img";
+  return s;
+}
+
 Byte CInArchive::ReadByte()
 {
-  if (m_BufferPos >= BlockSize)
+  if (m_BufferPos >= kBlockSize)
     m_BufferPos = 0;
   if (m_BufferPos == 0)
   {
-    size_t processedSize = BlockSize;
-    if (ReadStream(_stream, m_Buffer, &processedSize) != S_OK)
-      throw 1;
-    if (processedSize != BlockSize)
-      throw 1;
+    size_t processed = kBlockSize;
+    HRESULT res = ReadStream(_stream, m_Buffer, &processed);
+    if (res != S_OK)
+      throw CSystemException(res);
+    if (processed != kBlockSize)
+      throw CUnexpectedEndException();
+    UInt64 end = _position + processed;
+    if (PhySize < end)
+      PhySize = end;
   }
   Byte b = m_Buffer[m_BufferPos++];
   _position++;
@@ -44,64 +125,55 @@ void CInArchive::SkipZeros(size_t size)
   {
     Byte b = ReadByte();
     if (b != 0)
-      throw 1;
+      throw CHeaderErrorException();
   }
 }
 
-UInt16 CInArchive::ReadUInt16Spec()
-{
-  UInt16 value = 0;
-  for (int i = 0; i < 2; i++)
-    value |= ((UInt16)(ReadByte()) << (8 * i));
-  return value;
-}
-
-
 UInt16 CInArchive::ReadUInt16()
 {
   Byte b[4];
   ReadBytes(b, 4);
-  UInt32 value = 0;
+  UInt32 val = 0;
   for (int i = 0; i < 2; i++)
   {
     if (b[i] != b[3 - i])
       IncorrectBigEndian = true;
-    value |= ((UInt16)(b[i]) << (8 * i));
+    val |= ((UInt16)(b[i]) << (8 * i));
   }
-  return (UInt16)value;
+  return (UInt16)val;
 }
 
 UInt32 CInArchive::ReadUInt32Le()
 {
-  UInt32 value = 0;
+  UInt32 val = 0;
   for (int i = 0; i < 4; i++)
-    value |= ((UInt32)(ReadByte()) << (8 * i));
-  return value;
+    val |= ((UInt32)(ReadByte()) << (8 * i));
+  return val;
 }
 
 UInt32 CInArchive::ReadUInt32Be()
 {
-  UInt32 value = 0;
+  UInt32 val = 0;
   for (int i = 0; i < 4; i++)
   {
-    value <<= 8;
-    value |= ReadByte();
+    val <<= 8;
+    val |= ReadByte();
   }
-  return value;
+  return val;
 }
 
 UInt32 CInArchive::ReadUInt32()
 {
   Byte b[8];
   ReadBytes(b, 8);
-  UInt32 value = 0;
+  UInt32 val = 0;
   for (int i = 0; i < 4; i++)
   {
     if (b[i] != b[7 - i])
-      throw 1;
-    value |= ((UInt32)(b[i]) << (8 * i));
+      throw CEndianErrorException();
+    val |= ((UInt32)(b[i]) << (8 * i));
   }
-  return value;
+  return val;
 }
 
 UInt32 CInArchive::ReadDigits(int numDigits)
@@ -115,7 +187,7 @@ UInt32 CInArchive::ReadDigits(int numDigits)
       if (b == 0) // it's bug in some CD's
         b = '0';
       else
-        throw 1;
+        throw CHeaderErrorException();
     }
     UInt32 d = (UInt32)(b - '0');
     res *= 10;
@@ -158,27 +230,27 @@ void CInArchive::ReadDirRecord2(CDirRecord &r, Byte len)
 {
   r.ExtendedAttributeRecordLen = ReadByte();
   if (r.ExtendedAttributeRecordLen != 0)
-    throw 1;
+    throw CHeaderErrorException();
   r.ExtentLocation = ReadUInt32();
-  r.DataLength = ReadUInt32();
+  r.Size = ReadUInt32();
   ReadRecordingDateTime(r.DateTime);
   r.FileFlags = ReadByte();
   r.FileUnitSize = ReadByte();
   r.InterleaveGapSize = ReadByte();
   r.VolSequenceNumber = ReadUInt16();
   Byte idLen = ReadByte();
-  r.FileId.SetCapacity(idLen);
+  r.FileId.Alloc(idLen);
   ReadBytes((Byte *)r.FileId, idLen);
-  int padSize = 1 - (idLen & 1);
+  unsigned padSize = 1 - (idLen & 1);
   
-  // SkipZeros(1 - (idLen & 1));
-  Skip(1 - (idLen & 1)); // it's bug in some cd's. Must be zeros
+  // SkipZeros(padSize);
+  Skip(padSize); // it's bug in some cd's. Must be zeros
 
-  int curPos = 33 + idLen + padSize;
+  unsigned curPos = 33 + idLen + padSize;
   if (curPos > len)
-    throw 1;
-  int rem = len - curPos;
-  r.SystemUse.SetCapacity(rem);
+    throw CHeaderErrorException();
+  unsigned rem = len - curPos;
+  r.SystemUse.Alloc(rem);
   ReadBytes((Byte *)r.SystemUse, rem);
 }
 
@@ -222,7 +294,11 @@ void CInArchive::ReadVolumeDescriptor(CVolumeDescriptor &d)
   d.FileStructureVersion = ReadByte(); // = 1
   SkipZeros(1);
   ReadBytes(d.ApplicationUse, sizeof(d.ApplicationUse));
-  SkipZeros(653);
+
+  // Most ISO contains zeros in the following field (reserved for future standardization).
+  // But some ISO programs write some data to that area.
+  // So we disable check for zeros.
+  Skip(653); // SkipZeros(653);
 }
 
 static const Byte kSig_CD001[5] = { 'C', 'D', '0', '0', '1' };
@@ -242,15 +318,34 @@ static inline bool CheckSignature(const Byte *sig, const Byte *data)
 
 void CInArchive::SeekToBlock(UInt32 blockIndex)
 {
-  if (_stream->Seek((UInt64)blockIndex * VolDescs[MainVolDescIndex].LogicalBlockSize, STREAM_SEEK_SET, &_position) != S_OK)
-    throw 1;
+  HRESULT res = _stream->Seek((UInt64)blockIndex * VolDescs[MainVolDescIndex].LogicalBlockSize, STREAM_SEEK_SET, &_position);
+  if (res != S_OK)
+    throw CSystemException(res);
   m_BufferPos = 0;
 }
 
+static const int kNumLevelsMax = 256;
+
 void CInArchive::ReadDir(CDir &d, int level)
 {
   if (!d.IsDir())
     return;
+  if (level > kNumLevelsMax)
+  {
+    TooDeepDirs = true;
+    return;
+  }
+
+  {
+    FOR_VECTOR (i, UniqStartLocations)
+      if (UniqStartLocations[i] == d.ExtentLocation)
+      {
+        SelfLinkedDirs = true;
+        return;
+      }
+    UniqStartLocations.Add(d.ExtentLocation);
+  }
+
   SeekToBlock(d.ExtentLocation);
   UInt64 startPos = _position;
 
@@ -258,7 +353,7 @@ void CInArchive::ReadDir(CDir &d, int level)
   for (;;)
   {
     UInt64 offset = _position - startPos;
-    if (offset >= d.DataLength)
+    if (offset >= d.Size)
       break;
     Byte len = ReadByte();
     if (len == 0)
@@ -273,21 +368,44 @@ void CInArchive::ReadDir(CDir &d, int level)
 
     firstItem = false;
   }
-  for (int i = 0; i < d._subItems.Size(); i++)
+  FOR_VECTOR (i, d._subItems)
     ReadDir(d._subItems[i], level + 1);
+
+  UniqStartLocations.DeleteBack();
 }
 
 void CInArchive::CreateRefs(CDir &d)
 {
   if (!d.IsDir())
     return;
-  for (int i = 0; i < d._subItems.Size(); i++)
+  for (unsigned i = 0; i < d._subItems.Size();)
   {
     CRef ref;
     CDir &subItem = d._subItems[i];
     subItem.Parent = &d;
     ref.Dir = &d;
-    ref.Index = i;
+    ref.Index = i++;
+    ref.NumExtents = 1;
+    ref.TotalSize = subItem.Size;
+    if (subItem.IsNonFinalExtent())
+    {
+      for (;;)
+      {
+        if (i == d._subItems.Size())
+        {
+          HeadersError = true;
+          break;
+        }
+        const CDir &next = d._subItems[i];
+        if (!subItem.AreMultiPartEqualWith(next))
+          break;
+        i++;
+        ref.NumExtents++;
+        ref.TotalSize += next.Size;
+        if (!next.IsNonFinalExtent())
+          break;
+      }
+    }
     Refs.Add(ref);
     CreateRefs(subItem);
   }
@@ -297,59 +415,114 @@ void CInArchive::ReadBootInfo()
 {
   if (!_bootIsDefined)
     return;
+  HeadersError = true;
+
   if (memcmp(_bootDesc.BootSystemId, kElToritoSpec, sizeof(_bootDesc.BootSystemId)) != 0)
     return;
   
-  const Byte *p = (const Byte *)_bootDesc.BootSystemUse;
-  UInt32 blockIndex = p[0] | ((UInt32)p[1] << 8) | ((UInt32)p[2] << 16) | ((UInt32)p[3] << 24);
+  UInt32 blockIndex = GetUi32(_bootDesc.BootSystemUse);
   SeekToBlock(blockIndex);
-  Byte b = ReadByte();
-  if (b != NBootEntryId::kValidationEntry)
+  
+  Byte buf[32];
+  ReadBytes(buf, 32);
+
+  if (buf[0] != NBootEntryId::kValidationEntry
+      || buf[2] != 0
+      || buf[3] != 0
+      || buf[30] != 0x55
+      || buf[31] != 0xAA)
     return;
+
   {
+    UInt32 sum = 0;
+    for (unsigned i = 0; i < 32; i += 2)
+      sum += GetUi16(buf + i);
+    if ((sum & 0xFFFF) != 0)
+      return;
+    /*
     CBootValidationEntry e;
-    e.PlatformId = ReadByte();
-    if (ReadUInt16Spec() != 0)
-      throw 1;
-    ReadBytes(e.Id, sizeof(e.Id));
-    /* UInt16 checkSum = */ ReadUInt16Spec();
-    if (ReadByte() != 0x55)
-      throw 1;
-    if (ReadByte() != 0xAA)
-      throw 1;
+    e.PlatformId = buf[1];
+    memcpy(e.Id, buf + 4, sizeof(e.Id));
+    // UInt16 checkSum = GetUi16(p + 28);
+    */
   }
-  b = ReadByte();
-  if (b == NBootEntryId::kInitialEntryBootable || b == NBootEntryId::kInitialEntryNotBootable)
+
+  ReadBytes(buf, 32);
   {
     CBootInitialEntry e;
-    e.Bootable = (b == NBootEntryId::kInitialEntryBootable);
-    e.BootMediaType = ReadByte();
-    e.LoadSegment = ReadUInt16Spec();
-    e.SystemType = ReadByte();
-    if (ReadByte() != 0)
-      throw 1;
-    e.SectorCount = ReadUInt16Spec();
-    e.LoadRBA = ReadUInt32Le();
-    if (ReadByte() != 0)
-      throw 1;
+    if (!e.Parse(buf))
+      return;
     BootEntries.Add(e);
   }
-  else
-    return;
+
+  bool error = false;
+  
+  for (;;)
+  {
+    ReadBytes(buf, 32);
+    Byte headerIndicator = buf[0];
+    if (headerIndicator != NBootEntryId::kMoreHeaders
+        && headerIndicator != NBootEntryId::kFinalHeader)
+      break;
+
+    // Section Header
+    // Byte platform = p[1];
+    unsigned numEntries = GetUi16(buf + 2);
+    // id[28]
+      
+    for (unsigned i = 0; i < numEntries; i++)
+    {
+      ReadBytes(buf, 32);
+      CBootInitialEntry e;
+      if (!e.Parse(buf))
+      {
+        error = true;
+        break;
+      }
+      if (e.BootMediaType & (1 << 5))
+      {
+        // Section entry extension
+        for (unsigned j = 0;; j++)
+        {
+          ReadBytes(buf, 32);
+          if (j > 32 || buf[0] != NBootEntryId::kExtensionIndicator)
+          {
+            error = true;
+            break;
+          }
+          if ((buf[1] & (1 << 5)) == 0)
+            break;
+          // info += (buf + 2, 30)
+        }
+      }
+      BootEntries.Add(e);
+    }
+  
+    if (headerIndicator != NBootEntryId::kMoreHeaders)
+      break;
+  }
+    
+  HeadersError = error;
 }
 
 HRESULT CInArchive::Open2()
 {
-  Clear();
-  RINOK(_stream->Seek(kStartPos, STREAM_SEEK_CUR, &_position));
+  _position = 0;
+  RINOK(_stream->Seek(0, STREAM_SEEK_END, &_fileSize));
+  if (_fileSize < kStartPos)
+    return S_FALSE;
+  RINOK(_stream->Seek(kStartPos, STREAM_SEEK_SET, &_position));
 
+  PhySize = _position;
   m_BufferPos = 0;
-  BlockSize = kBlockSize;
+  // BlockSize = kBlockSize;
+  
   for (;;)
   {
     Byte sig[7];
     ReadBytes(sig, 7);
     Byte ver = sig[6];
+    
     if (!CheckSignature(kSig_CD001, sig + 1))
     {
       return S_FALSE;
@@ -372,9 +545,10 @@ HRESULT CInArchive::Open2()
       continue;
       */
     }
+    
     // version = 2 for ISO 9660:1999?
     if (ver > 2)
-      throw S_FALSE;
+      return S_FALSE;
 
     if (sig[0] == NVolDescType::kTerminator)
     {
@@ -382,7 +556,8 @@ HRESULT CInArchive::Open2()
       // Skip(0x800 - 7);
       // continue;
     }
-    switch(sig[0])
+    
+    switch (sig[0])
     {
       case NVolDescType::kBootRecord:
       {
@@ -408,6 +583,7 @@ HRESULT CInArchive::Open2()
         break;
     }
   }
+  
   if (VolDescs.IsEmpty())
     return S_FALSE;
   for (MainVolDescIndex = VolDescs.Size() - 1; MainVolDescIndex > 0; MainVolDescIndex--)
@@ -417,30 +593,74 @@ HRESULT CInArchive::Open2()
   const CVolumeDescriptor &vd = VolDescs[MainVolDescIndex];
   if (vd.LogicalBlockSize != kBlockSize)
     return S_FALSE;
+  
+  IsArc = true;
+
   (CDirRecord &)_rootDir = vd.RootDirRecord;
   ReadDir(_rootDir, 0);
   CreateRefs(_rootDir);
   ReadBootInfo();
+
+  {
+    FOR_VECTOR (i, Refs)
+    {
+      const CRef &ref = Refs[i];
+      for (UInt32 j = 0; j < ref.NumExtents; j++)
+      {
+        const CDir &item = ref.Dir->_subItems[ref.Index + j];
+        if (!item.IsDir())
+          UpdatePhySize(item.ExtentLocation, item.Size);
+      }
+    }
+  }
+  {
+    FOR_VECTOR (i, BootEntries)
+    {
+      const CBootInitialEntry &be = BootEntries[i];
+      UpdatePhySize(be.LoadRBA, GetBootItemSize(i));
+    }
+  }
+
+  if (PhySize < _fileSize)
+  {
+    UInt64 rem = _fileSize - PhySize;
+    const UInt64 kRemMax = 1 << 21;
+    if (rem <= kRemMax)
+    {
+      RINOK(_stream->Seek(PhySize, STREAM_SEEK_SET, NULL));
+      bool areThereNonZeros = false;
+      UInt64 numZeros = 0;
+      RINOK(ReadZeroTail(_stream, areThereNonZeros, numZeros, kRemMax));
+      if (!areThereNonZeros)
+        PhySize += numZeros;
+    }
+  }
+
   return S_OK;
 }
 
 HRESULT CInArchive::Open(IInStream *inStream)
 {
+  Clear();
   _stream = inStream;
-  UInt64 pos;
-  RINOK(_stream->Seek(0, STREAM_SEEK_CUR, &pos));
-  RINOK(_stream->Seek(0, STREAM_SEEK_END, &_archiveSize));
-  RINOK(_stream->Seek(pos, STREAM_SEEK_SET, &_position));
-  HRESULT res = S_FALSE;
-  try { res = Open2(); }
-  catch(...) { Clear(); res = S_FALSE; }
-  _stream.Release();
-  return res;
+  try { return Open2(); }
+  catch(const CSystemException &e) { return e.ErrorCode; }
+  catch(CUnexpectedEndException &) { UnexpectedEnd = true; return S_FALSE; }
+  catch(CHeaderErrorException &) { HeadersError = true; return S_FALSE; }
+  catch(CEndianErrorException &) { IncorrectBigEndian = true; return S_FALSE; }
 }
 
 void CInArchive::Clear()
 {
+  IsArc = false;
+  UnexpectedEnd = false;
+  HeadersError = false;
   IncorrectBigEndian = false;
+  TooDeepDirs = false;
+  SelfLinkedDirs = false;
+
+  UniqStartLocations.Clear();
+
   Refs.Clear();
   _rootDir.Clear();
   VolDescs.Clear();