seven-zip 1.4.2 → 1.7.0.rc1

data/ext/p7zip/CPP/7zip/Common/FileStreams.cpp

@@ -8,6 +8,11 @@
 #include <errno.h>
 #endif
 
+#ifdef SUPPORT_DEVICE_FILE
+#include "../../../C/Alloc.h"
+#include "../../Common/Defs.h"
+#endif
+
 #include "FileStreams.h"
 
 static inline HRESULT ConvertBoolToHRESULT(bool result)
@@ -24,78 +29,190 @@ static inline HRESULT ConvertBoolToHRESULT(bool result)
   #endif
 }
 
-bool CInFileStream::Open(LPCTSTR fileName)
-{
-#ifdef ENV_UNIX
-  return File.Open(fileName,_ignoreSymbolicLink);
-#else
-  return File.Open(fileName);
-#endif
-}
 
-#ifdef USE_WIN_FILE
-#ifndef _UNICODE
-bool CInFileStream::Open(LPCWSTR fileName)
+static const UInt32 kClusterSize = 1 << 18;
+CInFileStream::CInFileStream(bool b):
+  #ifdef SUPPORT_DEVICE_FILE
+  VirtPos(0),
+  PhyPos(0),
+  Buf(0),
+  BufSize(0),
+  #endif
+  SupportHardLinks(false),
+  Callback(NULL),
+  CallbackRef(0)
 {
-#ifdef ENV_UNIX
-  return File.Open(fileName,_ignoreSymbolicLink);
-#else
-  return File.Open(fileName);
-#endif
+  _ignoreSymbolicLink = b;
 }
-#endif
-#endif
 
-bool CInFileStream::OpenShared(LPCTSTR fileName, bool shareForWrite)
+CInFileStream::~CInFileStream()
 {
-#ifdef ENV_UNIX
-  return File.Open(fileName,_ignoreSymbolicLink);
-#else
-  return File.OpenShared(fileName, shareForWrite);
-#endif
-}
+  #ifdef SUPPORT_DEVICE_FILE
+  MidFree(Buf);
+  #endif
 
-#ifdef USE_WIN_FILE
-#ifndef _UNICODE
-bool CInFileStream::OpenShared(LPCWSTR fileName, bool shareForWrite)
-{
-  return File.OpenShared(fileName, shareForWrite);
+  if (Callback)
+    Callback->InFileStream_On_Destroy(CallbackRef);
 }
-#endif
-#endif
 
 STDMETHODIMP CInFileStream::Read(void *data, UInt32 size, UInt32 *processedSize)
 {
   #ifdef USE_WIN_FILE
   
+  #ifdef SUPPORT_DEVICE_FILE
+  if (processedSize)
+    *processedSize = 0;
+  if (size == 0)
+    return S_OK;
+  if (File.IsDeviceFile)
+  {
+    if (File.SizeDefined)
+    {
+      if (VirtPos >= File.Size)
+        return VirtPos == File.Size ? S_OK : E_FAIL;
+      UInt64 rem = File.Size - VirtPos;
+      if (size > rem)
+        size = (UInt32)rem;
+    }
+    for (;;)
+    {
+      const UInt32 mask = kClusterSize - 1;
+      const UInt64 mask2 = ~(UInt64)mask;
+      UInt64 alignedPos = VirtPos & mask2;
+      if (BufSize > 0 && BufStartPos == alignedPos)
+      {
+        UInt32 pos = (UInt32)VirtPos & mask;
+        if (pos >= BufSize)
+          return S_OK;
+        UInt32 rem = MyMin(BufSize - pos, size);
+        memcpy(data, Buf + pos, rem);
+        VirtPos += rem;
+        if (processedSize)
+          *processedSize += rem;
+        return S_OK;
+      }
+      
+      bool useBuf = false;
+      if ((VirtPos & mask) != 0 || ((ptrdiff_t)data & mask) != 0 )
+        useBuf = true;
+      else
+      {
+        UInt64 end = VirtPos + size;
+        if ((end & mask) != 0)
+        {
+          end &= mask2;
+          if (end <= VirtPos)
+            useBuf = true;
+          else
+            size = (UInt32)(end - VirtPos);
+        }
+      }
+      if (!useBuf)
+        break;
+      if (alignedPos != PhyPos)
+      {
+        UInt64 realNewPosition;
+        bool result = File.Seek(alignedPos, FILE_BEGIN, realNewPosition);
+        if (!result)
+          return ConvertBoolToHRESULT(result);
+        PhyPos = realNewPosition;
+      }
+
+      BufStartPos = alignedPos;
+      UInt32 readSize = kClusterSize;
+      if (File.SizeDefined)
+        readSize = (UInt32)MyMin(File.Size - PhyPos, (UInt64)kClusterSize);
+
+      if (!Buf)
+      {
+        Buf = (Byte *)MidAlloc(kClusterSize);
+        if (!Buf)
+          return E_OUTOFMEMORY;
+      }
+      bool result = File.Read1(Buf, readSize, BufSize);
+      if (!result)
+        return ConvertBoolToHRESULT(result);
+
+      if (BufSize == 0)
+        return S_OK;
+      PhyPos += BufSize;
+    }
+
+    if (VirtPos != PhyPos)
+    {
+      UInt64 realNewPosition;
+      bool result = File.Seek(VirtPos, FILE_BEGIN, realNewPosition);
+      if (!result)
+        return ConvertBoolToHRESULT(result);
+      PhyPos = VirtPos = realNewPosition;
+    }
+  }
+  #endif
+
   UInt32 realProcessedSize;
   bool result = File.ReadPart(data, size, realProcessedSize);
-  if(processedSize != NULL)
+  if (processedSize)
     *processedSize = realProcessedSize;
-  return ConvertBoolToHRESULT(result);
-  
+
+  #ifdef SUPPORT_DEVICE_FILE
+  VirtPos += realProcessedSize;
+  PhyPos += realProcessedSize;
+  #endif
+
+  if (result)
+    return S_OK;
+
+  {
+    DWORD error = ::GetLastError();
+
+    if (Callback)
+      return Callback->InFileStream_On_Error(CallbackRef, error);
+    if (error == 0)
+      return E_FAIL;
+
+    return HRESULT_FROM_WIN32(error);
+  }
+
   #else
   
-  if(processedSize != NULL)
+  if (processedSize)
     *processedSize = 0;
   ssize_t res = File.Read(data, (size_t)size);
   if (res == -1)
+  {
+    if (Callback)
+      return Callback->InFileStream_On_Error(CallbackRef, E_FAIL);
     return E_FAIL;
-  if(processedSize != NULL)
+  }
+  if (processedSize)
     *processedSize = (UInt32)res;
   return S_OK;
 
   #endif
 }
 
-#ifndef _WIN32_WCE
+#ifdef UNDER_CE
+STDMETHODIMP CStdInFileStream::Read(void *data, UInt32 size, UInt32 *processedSize)
+{
+  size_t s2 = fread(data, 1, size, stdin);
+  int error = ferror(stdin);
+  if (processedSize)
+    *processedSize = s2;
+  if (s2 <= size && error == 0)
+    return S_OK;
+  return E_FAIL;
+}
+#else
 STDMETHODIMP CStdInFileStream::Read(void *data, UInt32 size, UInt32 *processedSize)
 {
   #ifdef _WIN32
-  UInt32 realProcessedSize;
-  BOOL res = ::ReadFile(GetStdHandle(STD_INPUT_HANDLE),
-      data, size, (DWORD *)&realProcessedSize, NULL);
-  if(processedSize != NULL)
+  
+  DWORD realProcessedSize;
+  UInt32 sizeTemp = (1 << 20);
+  if (sizeTemp > size)
+    sizeTemp = size;
+  BOOL res = ::ReadFile(GetStdHandle(STD_INPUT_HANDLE), data, sizeTemp, &realProcessedSize, NULL);
+  if (processedSize)
     *processedSize = realProcessedSize;
   if (res == FALSE && GetLastError() == ERROR_BROKEN_PIPE)
     return S_OK;
@@ -103,7 +220,7 @@ STDMETHODIMP CStdInFileStream::Read(void *data, UInt32 size, UInt32 *processedSi
   
   #else
 
-  if(processedSize != NULL)
+  if (processedSize)
     *processedSize = 0;
   ssize_t res;
   do
@@ -113,7 +230,7 @@ STDMETHODIMP CStdInFileStream::Read(void *data, UInt32 size, UInt32 *processedSi
   while (res < 0 && (errno == EINTR));
   if (res == -1)
     return E_FAIL;
-  if(processedSize != NULL)
+  if (processedSize)
     *processedSize = (UInt32)res;
   return S_OK;
   
@@ -122,26 +239,49 @@ STDMETHODIMP CStdInFileStream::Read(void *data, UInt32 size, UInt32 *processedSi
   
 #endif
 
-STDMETHODIMP CInFileStream::Seek(Int64 offset, UInt32 seekOrigin,
-    UInt64 *newPosition)
+STDMETHODIMP CInFileStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition)
 {
-  if(seekOrigin >= 3)
+  if (seekOrigin >= 3)
     return STG_E_INVALIDFUNCTION;
 
   #ifdef USE_WIN_FILE
 
+  #ifdef SUPPORT_DEVICE_FILE
+  if (File.IsDeviceFile && (File.SizeDefined || seekOrigin != STREAM_SEEK_END))
+  {
+    switch (seekOrigin)
+    {
+      case STREAM_SEEK_SET: break;
+      case STREAM_SEEK_CUR: offset += VirtPos; break;
+      case STREAM_SEEK_END: offset += File.Size; break;
+      default: return STG_E_INVALIDFUNCTION;
+    }
+    if (offset < 0)
+      return HRESULT_WIN32_ERROR_NEGATIVE_SEEK;
+    VirtPos = offset;
+    if (newPosition)
+      *newPosition = offset;
+    return S_OK;
+  }
+  #endif
+  
   UInt64 realNewPosition;
   bool result = File.Seek(offset, seekOrigin, realNewPosition);
-  if(newPosition != NULL)
+  
+  #ifdef SUPPORT_DEVICE_FILE
+  PhyPos = VirtPos = realNewPosition;
+  #endif
+
+  if (newPosition)
     *newPosition = realNewPosition;
   return ConvertBoolToHRESULT(result);
   
   #else
   
-  off_t res = File.Seek(offset, seekOrigin);
+  off_t res = File.Seek((off_t)offset, seekOrigin);
   if (res == -1)
     return E_FAIL;
-  if(newPosition != NULL)
+  if (newPosition)
     *newPosition = (UInt64)res;
   return S_OK;
   
@@ -153,6 +293,43 @@ STDMETHODIMP CInFileStream::GetSize(UInt64 *size)
   return ConvertBoolToHRESULT(File.GetLength(*size));
 }
 
+#if 0 // #ifdef USE_WIN_FILE
+
+STDMETHODIMP CInFileStream::GetProps(UInt64 *size, FILETIME *cTime, FILETIME *aTime, FILETIME *mTime, UInt32 *attrib)
+{
+  BY_HANDLE_FILE_INFORMATION info;
+  if (File.GetFileInformation(&info))
+  {
+    if (size) *size = (((UInt64)info.nFileSizeHigh) << 32) + info.nFileSizeLow;
+    if (cTime) *cTime = info.ftCreationTime;
+    if (aTime) *aTime = info.ftLastAccessTime;
+    if (mTime) *mTime = info.ftLastWriteTime;
+    if (attrib) *attrib = info.dwFileAttributes;
+    return S_OK;
+  }
+  return GetLastError();
+}
+
+STDMETHODIMP CInFileStream::GetProps2(CStreamFileProps *props)
+{
+  BY_HANDLE_FILE_INFORMATION info;
+  if (File.GetFileInformation(&info))
+  {
+    props->Size = (((UInt64)info.nFileSizeHigh) << 32) + info.nFileSizeLow;
+    props->VolID = info.dwVolumeSerialNumber;
+    props->FileID_Low = (((UInt64)info.nFileIndexHigh) << 32) + info.nFileIndexLow;
+    props->FileID_High = 0;
+    props->NumLinks = SupportHardLinks ? info.nNumberOfLinks : 1;
+    props->Attrib = info.dwFileAttributes;
+    props->CTime = info.ftCreationTime;
+    props->ATime = info.ftLastAccessTime;
+    props->MTime = info.ftLastWriteTime;
+    return S_OK;
+  }
+  return GetLastError();
+}
+
+#endif
 
 //////////////////////////
 // COutFileStream
@@ -167,20 +344,20 @@ STDMETHODIMP COutFileStream::Write(const void *data, UInt32 size, UInt32 *proces
   #ifdef USE_WIN_FILE
 
   UInt32 realProcessedSize;
-  bool result = File.WritePart(data, size, realProcessedSize);
+  bool result = File.Write(data, size, realProcessedSize);
   ProcessedSize += realProcessedSize;
-  if(processedSize != NULL)
+  if (processedSize)
     *processedSize = realProcessedSize;
   return ConvertBoolToHRESULT(result);
   
   #else
   
-  if(processedSize != NULL)
+  if (processedSize)
     *processedSize = 0;
   ssize_t res = File.Write(data, (size_t)size);
   if (res == -1)
     return E_FAIL;
-  if(processedSize != NULL)
+  if (processedSize)
     *processedSize = (UInt32)res;
   ProcessedSize += res;
   return S_OK;
@@ -190,22 +367,23 @@ STDMETHODIMP COutFileStream::Write(const void *data, UInt32 size, UInt32 *proces
   
 STDMETHODIMP COutFileStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition)
 {
-  if(seekOrigin >= 3)
+  if (seekOrigin >= 3)
     return STG_E_INVALIDFUNCTION;
+  
   #ifdef USE_WIN_FILE
 
   UInt64 realNewPosition;
   bool result = File.Seek(offset, seekOrigin, realNewPosition);
-  if(newPosition != NULL)
+  if (newPosition)
     *newPosition = realNewPosition;
   return ConvertBoolToHRESULT(result);
   
   #else
   
-  off_t res = File.Seek(offset, seekOrigin);
+  off_t res = File.Seek((off_t)offset, seekOrigin);
   if (res == -1)
     return E_FAIL;
-  if(newPosition != NULL)
+  if (newPosition)
     *newPosition = (UInt64)res;
   return S_OK;
   
@@ -215,25 +393,46 @@ STDMETHODIMP COutFileStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPo
 STDMETHODIMP COutFileStream::SetSize(UInt64 newSize)
 {
   #ifdef USE_WIN_FILE
+  
   UInt64 currentPos;
-  if(!File.Seek(0, FILE_CURRENT, currentPos))
+  if (!File.Seek(0, FILE_CURRENT, currentPos))
     return E_FAIL;
   bool result = File.SetLength(newSize);
   UInt64 currentPos2;
   result = result && File.Seek(currentPos, currentPos2);
   return result ? S_OK : E_FAIL;
+  
   #else
+  
   return E_FAIL;
+  
   #endif
 }
 
-#ifndef _WIN32_WCE
+HRESULT COutFileStream::GetSize(UInt64 *size)
+{
+  return ConvertBoolToHRESULT(File.GetLength(*size));
+}
+
+#ifdef UNDER_CE
+
+STDMETHODIMP CStdOutFileStream::Write(const void *data, UInt32 size, UInt32 *processedSize)
+{
+  size_t s2 = fwrite(data, 1, size, stdout);
+  if (processedSize)
+    *processedSize = s2;
+  return (s2 == size) ? S_OK : E_FAIL;
+}
+
+#else
+
 STDMETHODIMP CStdOutFileStream::Write(const void *data, UInt32 size, UInt32 *processedSize)
 {
-  if(processedSize != NULL)
+  if (processedSize)
     *processedSize = 0;
 
   #ifdef _WIN32
+
   UInt32 realProcessedSize;
   BOOL res = TRUE;
   if (size > 0)
@@ -245,9 +444,10 @@ STDMETHODIMP CStdOutFileStream::Write(const void *data, UInt32 size, UInt32 *pro
       sizeTemp = size;
     res = ::WriteFile(GetStdHandle(STD_OUTPUT_HANDLE),
         data, sizeTemp, (DWORD *)&realProcessedSize, NULL);
+    _size += realProcessedSize;
     size -= realProcessedSize;
     data = (const void *)((const Byte *)data + realProcessedSize);
-    if(processedSize != NULL)
+    if (processedSize)
       *processedSize += realProcessedSize;
   }
   return ConvertBoolToHRESULT(res != FALSE);
@@ -255,19 +455,22 @@ STDMETHODIMP CStdOutFileStream::Write(const void *data, UInt32 size, UInt32 *pro
   #else
   
   ssize_t res;
+
   do
   {
     res = write(1, data, (size_t)size);
   }
   while (res < 0 && (errno == EINTR));
+  
   if (res == -1)
     return E_FAIL;
-  if(processedSize != NULL)
+
+  _size += (size_t)res;
+  if (processedSize)
     *processedSize = (UInt32)res;
   return S_OK;
   
-  return S_OK;
   #endif
 }
-  
+
 #endif

data/ext/p7zip/CPP/7zip/Common/FileStreams.h

@@ -1,12 +1,14 @@
 // FileStreams.h
 
-#ifndef __FILESTREAMS_H
-#define __FILESTREAMS_H
+#ifndef __FILE_STREAMS_H
+#define __FILE_STREAMS_H
 
-#if defined(_WIN32) || defined(ENV_UNIX)
+#if defined(_WIN32) || defined(UNIX_USE_WIN_FILE)
 #define USE_WIN_FILE
 #endif
 
+#include "../../Common/MyString.h"
+
 #ifdef USE_WIN_FILE
 #include "../../Windows/FileIO.h"
 #else
@@ -14,43 +16,87 @@
 #endif
 
 #include "../../Common/MyCom.h"
+
 #include "../IStream.h"
 
+#if 1 // FIXME #ifdef _WIN32
+typedef UINT_PTR My_UINT_PTR;
+#else
+typedef UINT My_UINT_PTR;
+#endif
+
+struct IInFileStream_Callback
+{
+  virtual HRESULT InFileStream_On_Error(My_UINT_PTR val, DWORD error) = 0;
+  virtual void InFileStream_On_Destroy(My_UINT_PTR val) = 0;
+};
+
 class CInFileStream:
   public IInStream,
   public IStreamGetSize,
+  #if 0 // #ifdef USE_WIN_FILE
+  public IStreamGetProps,
+  public IStreamGetProps2,
+  #endif
   public CMyUnknownImp
 {
   bool _ignoreSymbolicLink;
 public:
   #ifdef USE_WIN_FILE
   NWindows::NFile::NIO::CInFile File;
+  
+  #ifdef SUPPORT_DEVICE_FILE
+  UInt64 VirtPos;
+  UInt64 PhyPos;
+  UInt64 BufStartPos;
+  Byte *Buf;
+  UInt32 BufSize;
+  #endif
+
   #else
   NC::NFile::NIO::CInFile File;
   #endif
-  CInFileStream(bool b=false) { _ignoreSymbolicLink = b; }
-  virtual ~CInFileStream() {}
 
-  bool Open(LPCTSTR fileName);
-  #ifdef USE_WIN_FILE
-  #ifndef _UNICODE
-  bool Open(LPCWSTR fileName);
-  #endif
-  #endif
+  bool SupportHardLinks;
+
+  IInFileStream_Callback *Callback;
+  My_UINT_PTR CallbackRef;
 
-  bool OpenShared(LPCTSTR fileName, bool shareForWrite);
+  virtual ~CInFileStream();
+
+  CInFileStream(bool b=false);
+  
+  bool Open(CFSTR fileName)
+  {
   #ifdef USE_WIN_FILE
-  #ifndef _UNICODE
-  bool OpenShared(LPCWSTR fileName, bool shareForWrite);
-  #endif
+    return File.Open(fileName,_ignoreSymbolicLink);
+  #else
+    return File.Open(fileName);
   #endif
+  }
+  
+  bool OpenShared(CFSTR fileName, bool shareForWrite)
+  {
+    return this->Open(fileName); // return File.OpenShared(fileName, shareForWrite);
+  }
 
-  MY_UNKNOWN_IMP2(IInStream, IStreamGetSize)
+  MY_QUERYINTERFACE_BEGIN2(IInStream)
+  MY_QUERYINTERFACE_ENTRY(IStreamGetSize)
+  #if 0 // #ifdef USE_WIN_FILE
+  MY_QUERYINTERFACE_ENTRY(IStreamGetProps)
+  MY_QUERYINTERFACE_ENTRY(IStreamGetProps2)
+  #endif
+  MY_QUERYINTERFACE_END
+  MY_ADDREF_RELEASE
 
   STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
   STDMETHOD(Seek)(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition);
 
   STDMETHOD(GetSize)(UInt64 *size);
+  #if 0 // #ifdef USE_WIN_FILE
+  STDMETHOD(GetProps)(UInt64 *size, FILETIME *cTime, FILETIME *aTime, FILETIME *mTime, UInt32 *attrib);
+  STDMETHOD(GetProps2)(CStreamFileProps *props);
+  #endif
 };
 
 class CStdInFileStream:
@@ -68,37 +114,23 @@ class COutFileStream:
   public IOutStream,
   public CMyUnknownImp
 {
+public:
   #ifdef USE_WIN_FILE
   NWindows::NFile::NIO::COutFile File;
   #else
   NC::NFile::NIO::COutFile File;
   #endif
-public:
   virtual ~COutFileStream() {}
-  bool Create(LPCTSTR fileName, bool createAlways)
-  {
-    ProcessedSize = 0;
-    return File.Create(fileName, createAlways);
-  }
-  bool Open(LPCTSTR fileName, DWORD creationDisposition)
-  {
-    ProcessedSize = 0;
-    return File.Open(fileName, creationDisposition);
-  }
-  #ifdef USE_WIN_FILE
-  #ifndef _UNICODE
-  bool Create(LPCWSTR fileName, bool createAlways)
+  bool Create(CFSTR fileName, bool createAlways)
   {
     ProcessedSize = 0;
     return File.Create(fileName, createAlways);
   }
-  bool Open(LPCWSTR fileName, DWORD creationDisposition)
+  bool Open(CFSTR fileName, DWORD creationDisposition)
   {
     ProcessedSize = 0;
     return File.Open(fileName, creationDisposition);
   }
-  #endif
-  #endif
 
   HRESULT Close();
   
@@ -118,15 +150,20 @@ public:
   STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize);
   STDMETHOD(Seek)(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition);
   STDMETHOD(SetSize)(UInt64 newSize);
+
+  HRESULT GetSize(UInt64 *size);
 };
 
 class CStdOutFileStream:
   public ISequentialOutStream,
   public CMyUnknownImp
 {
+  UInt64 _size;
 public:
   MY_UNKNOWN_IMP
 
+  UInt64 GetSize() const { return _size; }
+  CStdOutFileStream(): _size(0) {}
   virtual ~CStdOutFileStream() {}
   STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize);
 };