react-native-update 10.34.3 → 10.34.5

package/harmony/pushy/src/main/cpp/lzma/CPP/7zip/UI/Common/Update.cpp

@@ -2,8 +2,6 @@
 
 #include "StdAfx.h"
 
-// #include  <stdio.h>
-
 #include "Update.h"
 
 #include "../../../Common/StringConvert.h"
@@ -18,8 +16,6 @@
 
 #include "../../Common/FileStreams.h"
 #include "../../Common/LimitedStreams.h"
-#include "../../Common/MultiOutStream.h"
-#include "../../Common/StreamUtils.h"
 
 #include "../../Compress/CopyCoder.h"
 
@@ -36,7 +32,7 @@
 static const char * const kUpdateIsNotSupoorted =
   "update operations are not supported for this archive";
 
-static const char * const kUpdateIsNotSupported_MultiVol =
+static const char * const kUpdateIsNotSupoorted_MultiVol =
   "Updating for multivolume archives is not implemented";
 
 using namespace NWindows;
@@ -45,9 +41,8 @@ using namespace NFile;
 using namespace NDir;
 using namespace NName;
 
-#ifdef _WIN32
 static CFSTR const kTempFolderPrefix = FTEXT("7zE");
-#endif
+
 
 void CUpdateErrorInfo::SetFromLastError(const char *message)
 {
@@ -62,55 +57,228 @@ HRESULT CUpdateErrorInfo::SetFromLastError(const char *message, const FString &f
   return Get_HRESULT_Error();
 }
 
-HRESULT CUpdateErrorInfo::SetFromError_DWORD(const char *message, const FString &fileName, DWORD error)
+static bool DeleteEmptyFolderAndEmptySubFolders(const FString &path)
 {
-  Message = message;
-  FileNames.Add(fileName);
-  SystemError = error;
-  return Get_HRESULT_Error();
+  NFind::CFileInfo fileInfo;
+  FString pathPrefix = path + FCHAR_PATH_SEPARATOR;
+  {
+    NFind::CEnumerator enumerator;
+    enumerator.SetDirPrefix(pathPrefix);
+    while (enumerator.Next(fileInfo))
+    {
+      if (fileInfo.IsDir())
+        if (!DeleteEmptyFolderAndEmptySubFolders(pathPrefix + fileInfo.Name))
+          return false;
+    }
+  }
+  /*
+  // we don't need clear read-only for folders
+  if (!MySetFileAttributes(path, 0))
+    return false;
+  */
+  return RemoveDir(path);
 }
 
 
 using namespace NUpdateArchive;
 
-struct CMultiOutStream_Rec
+class COutMultiVolStream:
+  public IOutStream,
+  public CMyUnknownImp
 {
-  CMultiOutStream *Spec;
-  CMyComPtr<IOutStream> Ref;
+  unsigned _streamIndex; // required stream
+  UInt64 _offsetPos; // offset from start of _streamIndex index
+  UInt64 _absPos;
+  UInt64 _length;
+
+  struct CAltStreamInfo
+  {
+    COutFileStream *StreamSpec;
+    CMyComPtr<IOutStream> Stream;
+    FString Name;
+    UInt64 Pos;
+    UInt64 RealSize;
+  };
+  CObjectVector<CAltStreamInfo> Streams;
+public:
+  // CMyComPtr<IArchiveUpdateCallback2> VolumeCallback;
+  CRecordVector<UInt64> Sizes;
+  FString Prefix;
+  CTempFiles *TempFiles;
+
+  void Init()
+  {
+    _streamIndex = 0;
+    _offsetPos = 0;
+    _absPos = 0;
+    _length = 0;
+  }
+
+  bool SetMTime(const FILETIME *mTime);
+  HRESULT Close();
+
+  UInt64 GetSize() const { return _length; }
+
+  MY_UNKNOWN_IMP1(IOutStream)
+
+  STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize);
+  STDMETHOD(Seek)(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition);
+  STDMETHOD(SetSize)(UInt64 newSize);
 };
 
-struct CMultiOutStream_Bunch
+// static NSynchronization::CCriticalSection g_TempPathsCS;
+
+HRESULT COutMultiVolStream::Close()
 {
-  CObjectVector<CMultiOutStream_Rec> Items;
-  
-  HRESULT Destruct()
+  HRESULT res = S_OK;
+  FOR_VECTOR (i, Streams)
+  {
+    COutFileStream *s = Streams[i].StreamSpec;
+    if (s)
+    {
+      HRESULT res2 = s->Close();
+      if (res2 != S_OK)
+        res = res2;
+    }
+  }
+  return res;
+}
+
+bool COutMultiVolStream::SetMTime(const FILETIME *mTime)
+{
+  bool res = true;
+  FOR_VECTOR (i, Streams)
+  {
+    COutFileStream *s = Streams[i].StreamSpec;
+    if (s)
+      if (!s->SetMTime(mTime))
+        res = false;
+  }
+  return res;
+}
+
+STDMETHODIMP COutMultiVolStream::Write(const void *data, UInt32 size, UInt32 *processedSize)
+{
+  if (processedSize)
+    *processedSize = 0;
+  while (size > 0)
   {
-    HRESULT hres = S_OK;
-    FOR_VECTOR (i, Items)
+    if (_streamIndex >= Streams.Size())
     {
-      CMultiOutStream_Rec &rec = Items[i];
-      if (rec.Ref)
+      CAltStreamInfo altStream;
+
+      FString name;
+      name.Add_UInt32(_streamIndex + 1);
+      while (name.Len() < 3)
+        name.InsertAtFront(FTEXT('0'));
+      name.Insert(0, Prefix);
+      altStream.StreamSpec = new COutFileStream;
+      altStream.Stream = altStream.StreamSpec;
+      if (!altStream.StreamSpec->Create(name, false))
+        return ::GetLastError();
       {
-        const HRESULT hres2 = rec.Spec->Destruct();
-        if (hres == S_OK)
-          hres = hres2;
+        // NSynchronization::CCriticalSectionLock lock(g_TempPathsCS);
+        TempFiles->Paths.Add(name);
       }
+
+      altStream.Pos = 0;
+      altStream.RealSize = 0;
+      altStream.Name = name;
+      Streams.Add(altStream);
+      continue;
+    }
+    CAltStreamInfo &altStream = Streams[_streamIndex];
+
+    unsigned index = _streamIndex;
+    if (index >= Sizes.Size())
+      index = Sizes.Size() - 1;
+    UInt64 volSize = Sizes[index];
+
+    if (_offsetPos >= volSize)
+    {
+      _offsetPos -= volSize;
+      _streamIndex++;
+      continue;
     }
-    Items.Clear();
-    return hres;
+    if (_offsetPos != altStream.Pos)
+    {
+      // CMyComPtr<IOutStream> outStream;
+      // RINOK(altStream.Stream.QueryInterface(IID_IOutStream, &outStream));
+      RINOK(altStream.Stream->Seek(_offsetPos, STREAM_SEEK_SET, NULL));
+      altStream.Pos = _offsetPos;
+    }
+
+    UInt32 curSize = (UInt32)MyMin((UInt64)size, volSize - altStream.Pos);
+    UInt32 realProcessed;
+    RINOK(altStream.Stream->Write(data, curSize, &realProcessed));
+    data = (void *)((Byte *)data + realProcessed);
+    size -= realProcessed;
+    altStream.Pos += realProcessed;
+    _offsetPos += realProcessed;
+    _absPos += realProcessed;
+    if (_absPos > _length)
+      _length = _absPos;
+    if (_offsetPos > altStream.RealSize)
+      altStream.RealSize = _offsetPos;
+    if (processedSize)
+      *processedSize += realProcessed;
+    if (altStream.Pos == volSize)
+    {
+      _streamIndex++;
+      _offsetPos = 0;
+    }
+    if (realProcessed == 0 && curSize != 0)
+      return E_FAIL;
+    break;
   }
+  return S_OK;
+}
 
-  void DisableDeletion()
+STDMETHODIMP COutMultiVolStream::Seek(Int64 offset, UInt32 seekOrigin, UInt64 *newPosition)
+{
+  if (seekOrigin >= 3)
+    return STG_E_INVALIDFUNCTION;
+  switch (seekOrigin)
+  {
+    case STREAM_SEEK_SET: _absPos = offset; break;
+    case STREAM_SEEK_CUR: _absPos += offset; break;
+    case STREAM_SEEK_END: _absPos = _length + offset; break;
+  }
+  _offsetPos = _absPos;
+  if (newPosition)
+    *newPosition = _absPos;
+  _streamIndex = 0;
+  return S_OK;
+}
+
+STDMETHODIMP COutMultiVolStream::SetSize(UInt64 newSize)
+{
+  unsigned i = 0;
+  while (i < Streams.Size())
   {
-    FOR_VECTOR (i, Items)
+    CAltStreamInfo &altStream = Streams[i++];
+    if ((UInt64)newSize < altStream.RealSize)
     {
-      CMultiOutStream_Rec &rec = Items[i];
-      if (rec.Ref)
-        rec.Spec->NeedDelete = false;
+      RINOK(altStream.Stream->SetSize(newSize));
+      altStream.RealSize = newSize;
+      break;
     }
+    newSize -= altStream.RealSize;
   }
-};
-
+  while (i < Streams.Size())
+  {
+    {
+      CAltStreamInfo &altStream = Streams.Back();
+      altStream.Stream.Release();
+      DeleteFileAlways(altStream.Name);
+    }
+    Streams.DeleteBack();
+  }
+  _offsetPos = _absPos;
+  _streamIndex = 0;
+  _length = newSize;
+  return S_OK;
+}
 
 void CArchivePath::ParseFromPath(const UString &path, EArcNameMode mode)
 {
@@ -130,11 +298,11 @@ void CArchivePath::ParseFromPath(const UString &path, EArcNameMode mode)
       Name.DeleteBack();
     else
     {
-      const UString ext = Name.Ptr((unsigned)(dotPos + 1));
+      const UString ext = Name.Ptr(dotPos + 1);
       if (BaseExtension.IsEqualTo_NoCase(ext))
       {
         BaseExtension = ext;
-        Name.DeleteFrom((unsigned)dotPos);
+        Name.DeleteFrom(dotPos);
         return;
       }
     }
@@ -148,7 +316,7 @@ UString CArchivePath::GetFinalPath() const
   UString path = GetPathWithoutExt();
   if (!BaseExtension.IsEmpty())
   {
-    path.Add_Dot();
+    path += '.';
     path += BaseExtension;
   }
   return path;
@@ -160,7 +328,7 @@ UString CArchivePath::GetFinalVolPath() const
   // if BaseExtension is empty, we must ignore VolExtension also.
   if (!BaseExtension.IsEmpty())
   {
-    path.Add_Dot();
+    path += '.';
     path += VolExtension;
   }
   return path;
@@ -172,7 +340,7 @@ FString CArchivePath::GetTempPath() const
   path += us2fs(Name);
   if (!BaseExtension.IsEmpty())
   {
-    path.Add_Dot();
+    path += '.';
     path += us2fs(BaseExtension);
   }
   path += ".tmp";
@@ -224,7 +392,7 @@ bool CUpdateOptions::SetArcPath(const CCodecs *codecs, const UString &arcPath)
   }
   else
   {
-    const CArcInfoEx &arcInfo = codecs->Formats[(unsigned)formatIndex];
+    const CArcInfoEx &arcInfo = codecs->Formats[formatIndex];
     if (!arcInfo.UpdateEnabled)
       return false;
     typeExt = arcInfo.GetMainExt();
@@ -246,11 +414,11 @@ bool CUpdateOptions::SetArcPath(const CCodecs *codecs, const UString &arcPath)
 }
 
 
-struct CUpdateProduceCallbackImp Z7_final: public IUpdateProduceCallback
+struct CUpdateProduceCallbackImp: public IUpdateProduceCallback
 {
   const CObjectVector<CArcItem> *_arcItems;
-  CDirItemsStat *_stat;
   IUpdateCallbackUI *_callback;
+  CDirItemsStat *_stat;
   
   CUpdateProduceCallbackImp(
       const CObjectVector<CArcItem> *a,
@@ -260,7 +428,7 @@ struct CUpdateProduceCallbackImp Z7_final: public IUpdateProduceCallback
     _stat(stat),
     _callback(callback) {}
   
-  virtual HRESULT ShowDeleteFile(unsigned arcIndex) Z7_override;
+  virtual HRESULT ShowDeleteFile(unsigned arcIndex);
 };
 
 
@@ -342,8 +510,6 @@ bool CRenamePair::GetNewPath(bool isFolder, const UString &src, UString &dest) c
 int FindAltStreamColon_in_Path(const wchar_t *path);
 #endif
 
-
-
 static HRESULT Compress(
     const CUpdateOptions &options,
     bool isUpdatingItself,
@@ -356,7 +522,6 @@ static HRESULT Compress(
     const CDirItems &dirItems,
     const CDirItem *parentDirItem,
     CTempFiles &tempFiles,
-    CMultiOutStream_Bunch &multiStreams,
     CUpdateErrorInfo &errorInfo,
     IUpdateCallbackUI *callback,
     CFinishArchiveStat &st)
@@ -376,63 +541,28 @@ static HRESULT Compress(
   }
   else
   {
-    RINOK(codecs->CreateOutArchive((unsigned)formatIndex, outArchive))
+    RINOK(codecs->CreateOutArchive(formatIndex, outArchive));
 
-    #ifdef Z7_EXTERNAL_CODECS
+    #ifdef EXTERNAL_CODECS
     {
       CMyComPtr<ISetCompressCodecsInfo> setCompressCodecsInfo;
       outArchive.QueryInterface(IID_ISetCompressCodecsInfo, (void **)&setCompressCodecsInfo);
       if (setCompressCodecsInfo)
       {
-        RINOK(setCompressCodecsInfo->SetCompressCodecsInfo(codecs))
+        RINOK(setCompressCodecsInfo->SetCompressCodecsInfo(codecs));
       }
     }
     #endif
   }
   
-  if (!outArchive)
+  if (outArchive == 0)
     throw kUpdateIsNotSupoorted;
-
-  // we need to set properties to get fileTimeType.
-  RINOK(SetProperties(outArchive, options.MethodMode.Properties))
-
+  
   NFileTimeType::EEnum fileTimeType;
   {
-    /*
-    how we compare file_in_archive::MTime with dirItem.MTime
-    for GetUpdatePairInfoList():
-    
-    if (kpidMTime is not defined), external MTime of archive is used.
-    
-    before 22.00:
-      if (kpidTimeType is defined)
-      {
-        kpidTimeType is used as precision.
-        (kpidTimeType > kDOS) is not allowed.
-      }
-      else GetFileTimeType() value is used as precision.
-
-    22.00:
-      if (kpidMTime is defined)
-      {
-        if (kpidMTime::precision != 0), then kpidMTime::precision is used as precision.
-        else
-        {
-          if (kpidTimeType is defined), kpidTimeType is used as precision.
-          else GetFileTimeType() value is used as precision.
-        }
-      }
-      else external MTime of archive is used as precision.
-    */
-
     UInt32 value;
-    RINOK(outArchive->GetFileTimeType(&value))
-
-    // we support any future fileType here.
-    fileTimeType = (NFileTimeType::EEnum)value;
+    RINOK(outArchive->GetFileTimeType(&value));
     
-    /*
-    old 21.07 code:
     switch (value)
     {
       case NFileTimeType::kWindows:
@@ -443,28 +573,13 @@ static HRESULT Compress(
       default:
         return E_FAIL;
     }
-    */
   }
 
-  // bool noTimestampExpected = false;
   {
-    const CArcInfoEx &arcInfo = codecs->Formats[(unsigned)formatIndex];
-
-    // if (arcInfo.Flags_KeepName()) noTimestampExpected = true;
-    if (arcInfo.Is_Xz() ||
-        arcInfo.Is_BZip2())
-    {
-      /* 7-zip before 22.00 returns NFileTimeType::kUnix for xz and bzip2,
-         but we want to set timestamp without reduction to unix. */
-      // noTimestampExpected = true;
-      fileTimeType = NFileTimeType::kNotDefined; // it means not defined
-    }
-
+    const CArcInfoEx &arcInfo = codecs->Formats[formatIndex];
     if (options.AltStreams.Val && !arcInfo.Flags_AltStreams())
       return E_NOTIMPL;
-    if (options.NtSecurity.Val && !arcInfo.Flags_NtSecurity())
-      return E_NOTIMPL;
-    if (options.DeleteAfterCompressing && arcInfo.Flags_HashHandler())
+    if (options.NtSecurity.Val && !arcInfo.Flags_NtSecure())
       return E_NOTIMPL;
   }
 
@@ -474,7 +589,7 @@ static HRESULT Compress(
 
   CArcToDoStat stat2;
 
-  if (options.RenameMode || options.RenamePairs.Size() != 0)
+  if (options.RenamePairs.Size() != 0)
   {
     FOR_VECTOR (i, arcItems)
     {
@@ -499,7 +614,7 @@ static HRESULT Compress(
             int colonPos = FindAltStreamColon_in_Path(ai.Name);
             if (colonPos >= 0)
             {
-              UString mainName = ai.Name.Left((unsigned)colonPos);
+              UString mainName = ai.Name.Left(colonPos);
               /*
               actually we must improve that code to support cases
               with folder renaming like: rn arc dir1\ dir2\
@@ -507,8 +622,8 @@ static HRESULT Compress(
               if (rp.GetNewPath(false, mainName, dest))
               {
                 needRename = true;
-                dest.Add_Colon();
-                dest += ai.Name.Ptr((unsigned)(colonPos + 1));
+                dest += ':';
+                dest += ai.Name.Ptr(colonPos + 1);
                 break;
               }
             }
@@ -522,8 +637,8 @@ static HRESULT Compress(
       if (needRename)
       {
         up2.NewProps = true;
-        RINOK(arc->IsItem_Anti(i, up2.IsAnti))
-        up2.NewNameIndex = (int)newNames.Add(dest);
+        RINOK(arc->IsItemAnti(i, up2.IsAnti));
+        up2.NewNameIndex = newNames.Add(dest);
       }
       updatePairs2.Add(up2);
     }
@@ -549,7 +664,7 @@ static HRESULT Compress(
         if (up.ExistOnDisk())
         {
           CDirItemsStat2 &stat = stat2.NewData;
-          const CDirItem &di = dirItems.Items[(unsigned)up.DirIndex];
+          const CDirItem &di = dirItems.Items[up.DirIndex];
           if (di.IsDir())
           {
             if (up.IsAnti)
@@ -557,7 +672,6 @@ static HRESULT Compress(
             else
               stat.NumDirs++;
           }
-         #ifdef _WIN32
           else if (di.IsAltStream)
           {
             if (up.IsAnti)
@@ -568,7 +682,6 @@ static HRESULT Compress(
               stat.AltStreamsSize += di.Size;
             }
           }
-         #endif
           else
           {
             if (up.IsAnti)
@@ -584,7 +697,7 @@ static HRESULT Compress(
       else if (up.ArcIndex >= 0)
       {
         CDirItemsStat2 &stat = *(up.NewData ? &stat2.NewData : &stat2.OldData);
-        const CArcItem &ai = arcItems[(unsigned)up.ArcIndex];
+        const CArcItem &ai = arcItems[up.ArcIndex];
         if (ai.IsDir)
         {
           if (up.IsAnti)
@@ -614,13 +727,12 @@ static HRESULT Compress(
         }
       }
     }
-    RINOK(callback->SetNumItems(stat2))
+    RINOK(callback->SetNumItems(stat2));
   }
   
   CArchiveUpdateCallback *updateCallbackSpec = new CArchiveUpdateCallback;
   CMyComPtr<IArchiveUpdateCallback> updateCallback(updateCallbackSpec);
   
-  updateCallbackSpec->PreserveATime = options.PreserveATime;
   updateCallbackSpec->ShareForWrite = options.OpenShareForWrite;
   updateCallbackSpec->StopAfterOpenError = options.StopAfterOpenError;
   updateCallbackSpec->StdInMode = options.StdInMode;
@@ -638,8 +750,6 @@ static HRESULT Compress(
   updateCallbackSpec->StoreNtSecurity = options.NtSecurity.Val;
   updateCallbackSpec->StoreHardLinks = options.HardLinks.Val;
   updateCallbackSpec->StoreSymLinks = options.SymLinks.Val;
-  updateCallbackSpec->StoreOwnerName = options.StoreOwnerName.Val;
-  updateCallbackSpec->StoreOwnerId = options.StoreOwnerId.Val;
 
   updateCallbackSpec->Arc = arc;
   updateCallbackSpec->ArcItems = &arcItems;
@@ -647,20 +757,9 @@ static HRESULT Compress(
 
   updateCallbackSpec->ProcessedItemsStatuses = processedItemsStatuses;
 
-  {
-    const UString arcPath = archivePath.GetFinalPath();
-    updateCallbackSpec->ArcFileName = ExtractFileNameFromPath(arcPath);
-  }
-
   if (options.RenamePairs.Size() != 0)
     updateCallbackSpec->NewNames = &newNames;
 
-  if (options.SetArcMTime)
-  {
-    // updateCallbackSpec->Need_ArcMTime_Report = true;
-    updateCallbackSpec->Need_LatestMTime = true;
-  }
-
   CMyComPtr<IOutStream> outSeekStream;
   CMyComPtr<ISequentialOutStream> outStream;
 
@@ -674,7 +773,7 @@ static HRESULT Compress(
 
   COutFileStream *outStreamSpec = NULL;
   CStdOutFileStream *stdOutFileStreamSpec = NULL;
-  CMultiOutStream *volStreamSpec = NULL;
+  COutMultiVolStream *volStreamSpec = NULL;
 
   if (options.VolumesSizes.Size() == 0)
   {
@@ -704,7 +803,7 @@ static HRESULT Compress(
         }
         else
           realPath = us2fs(archivePath.GetFinalPath());
-        if (outStreamSpec->Create_NEW(realPath))
+        if (outStreamSpec->Create(realPath, false))
         {
           tempFiles.Paths.Add(realPath);
           isOK = true;
@@ -727,17 +826,14 @@ static HRESULT Compress(
     if (arc && arc->GetGlobalOffset() > 0)
       return E_NOTIMPL;
       
-    volStreamSpec = new CMultiOutStream();
+    volStreamSpec = new COutMultiVolStream;
     outSeekStream = volStreamSpec;
     outStream = outSeekStream;
+    volStreamSpec->Sizes = options.VolumesSizes;
     volStreamSpec->Prefix = us2fs(archivePath.GetFinalVolPath());
-    volStreamSpec->Prefix.Add_Dot();
-    volStreamSpec->Init(options.VolumesSizes);
-    {
-      CMultiOutStream_Rec &rec = multiStreams.Items.AddNew();
-      rec.Spec = volStreamSpec;
-      rec.Ref = rec.Spec;
-    }
+    volStreamSpec->Prefix += '.';
+    volStreamSpec->TempFiles = &tempFiles;
+    volStreamSpec->Init();
 
     /*
     updateCallbackSpec->VolumesSizes = volumesSizes;
@@ -747,6 +843,8 @@ static HRESULT Compress(
     */
   }
 
+  RINOK(SetProperties(outArchive, options.MethodMode.Properties));
+
   if (options.SfxMode)
   {
     CInFileStream *sfxStreamSpec = new CInFileStream;
@@ -762,22 +860,22 @@ static HRESULT Compress(
     {
       outStreamSpec2 = new COutFileStream;
       sfxOutStream = outStreamSpec2;
-      const FString realPath = us2fs(archivePath.GetFinalPath());
-      if (!outStreamSpec2->Create_NEW(realPath))
+      FString realPath = us2fs(archivePath.GetFinalPath());
+      if (!outStreamSpec2->Create(realPath, false))
         return errorInfo.SetFromLastError("cannot open file", realPath);
     }
 
     {
       UInt64 sfxSize;
-      RINOK(sfxStreamSpec->GetSize(&sfxSize))
-      RINOK(callback->WriteSfx(fs2us(options.SfxModule), sfxSize))
+      RINOK(sfxStreamSpec->GetSize(&sfxSize));
+      RINOK(callback->WriteSfx(fs2us(options.SfxModule), sfxSize));
     }
 
-    RINOK(NCompress::CopyStream(sfxStream, sfxOutStream, NULL))
+    RINOK(NCompress::CopyStream(sfxStream, sfxOutStream, NULL));
     
     if (outStreamSpec2)
     {
-      RINOK(outStreamSpec2->Close())
+      RINOK(outStreamSpec2->Close());
     }
   }
 
@@ -788,8 +886,8 @@ static HRESULT Compress(
   else
   {
     // Int64 globalOffset = arc->GetGlobalOffset();
-    RINOK(InStream_SeekToBegin(arc->InStream))
-    RINOK(NCompress::CopyStream_ExactSize(arc->InStream, outStream, arc->ArcStreamOffset, NULL))
+    RINOK(arc->InStream->Seek(0, STREAM_SEEK_SET, NULL));
+    RINOK(NCompress::CopyStream_ExactSize(arc->InStream, outStream, arc->ArcStreamOffset, NULL));
     if (options.StdOutMode)
       tailStream = outStream;
     else
@@ -802,104 +900,43 @@ static HRESULT Compress(
     }
   }
 
-  CFiTime ft;
-  FiTime_Clear(ft);
-  bool ft_Defined = false;
-  {
-    FOR_VECTOR (i, updatePairs2)
-    {
-      const CUpdatePair2 &pair2 = updatePairs2[i];
-      CFiTime ft2;
-      FiTime_Clear(ft2);
-      bool ft2_Defined = false;
-      /* we use full precision of dirItem, if dirItem is defined
-         and (dirItem will be used or dirItem is sameTime in dir and arc */
-      if (pair2.DirIndex >= 0 &&
-          (pair2.NewProps || pair2.IsSameTime))
-      {
-        ft2 = dirItems.Items[(unsigned)pair2.DirIndex].MTime;
-        ft2_Defined = true;
-      }
-      else if (pair2.UseArcProps && pair2.ArcIndex >= 0)
-      {
-        const CArcItem &arcItem = arcItems[(unsigned)pair2.ArcIndex];
-        if (arcItem.MTime.Def)
-        {
-          arcItem.MTime.Write_To_FiTime(ft2);
-          ft2_Defined = true;
-        }
-      }
-      if (ft2_Defined)
-      {
-        if (!ft_Defined || Compare_FiTime(&ft, &ft2) < 0)
-        {
-          ft = ft2;
-          ft_Defined = true;
-        }
-      }
-    }
-    /*
-    if (fileTimeType != NFileTimeType::kNotDefined)
-    FiTime_Normalize_With_Prec(ft, fileTimeType);
-    */
-  }
-
-  if (volStreamSpec && options.SetArcMTime && ft_Defined)
-  {
-    volStreamSpec->MTime = ft;
-    volStreamSpec->MTime_Defined = true;
-  }
 
   HRESULT result = outArchive->UpdateItems(tailStream, updatePairs2.Size(), updateCallback);
   // callback->Finalize();
-  RINOK(result)
+  RINOK(result);
 
   if (!updateCallbackSpec->AreAllFilesClosed())
   {
-    errorInfo.Message = "There are unclosed input files:";
+    errorInfo.Message = "There are unclosed input file:";
     errorInfo.FileNames = updateCallbackSpec->_openFiles_Paths;
     return E_FAIL;
   }
 
   if (options.SetArcMTime)
   {
-    // bool needNormalizeAfterStream;
-    // needParse;
-    /*
-    if (updateCallbackSpec->ArcMTime_WasReported)
-    {
-      isDefined = updateCallbackSpec->Reported_ArcMTime.Def;
-      if (isDefined)
-        updateCallbackSpec->Reported_ArcMTime.Write_To_FiTime(ft);
-      else
-        fileTimeType = NFileTimeType::kNotDefined;
-    }
-    if (!isDefined)
-    */
+    FILETIME ft;
+    ft.dwLowDateTime = 0;
+    ft.dwHighDateTime = 0;
+    FOR_VECTOR (i, updatePairs2)
     {
-      if (updateCallbackSpec->LatestMTime_Defined)
+      CUpdatePair2 &pair2 = updatePairs2[i];
+      const FILETIME *ft2 = NULL;
+      if (pair2.NewProps && pair2.DirIndex >= 0)
+        ft2 = &dirItems.Items[pair2.DirIndex].MTime;
+      else if (pair2.UseArcProps && pair2.ArcIndex >= 0)
+        ft2 = &arcItems[pair2.ArcIndex].MTime;
+      if (ft2)
       {
-        // CArcTime at = StreamCallback_ArcMTime;
-        // updateCallbackSpec->StreamCallback_ArcMTime.Write_To_FiTime(ft);
-        // we must normalize with precision from archive;
-        if (!ft_Defined || Compare_FiTime(&ft, &updateCallbackSpec->LatestMTime) < 0)
-          ft = updateCallbackSpec->LatestMTime;
-        ft_Defined = true;
+        if (::CompareFileTime(&ft, ft2) < 0)
+          ft = *ft2;
       }
-      /*
-      if (fileTimeType != NFileTimeType::kNotDefined)
-        FiTime_Normalize_With_Prec(ft, fileTimeType);
-      */
     }
-    // if (ft.dwLowDateTime != 0 || ft.dwHighDateTime != 0)
-    if (ft_Defined)
+    if (ft.dwLowDateTime != 0 || ft.dwHighDateTime != 0)
     {
-      // we ignore set time errors here.
-      // note that user could move some finished volumes to another folder.
       if (outStreamSpec)
         outStreamSpec->SetMTime(&ft);
       else if (volStreamSpec)
-        volStreamSpec->SetMTime_Final(ft);
+        volStreamSpec->SetMTime(&ft);;
     }
   }
 
@@ -919,43 +956,10 @@ static HRESULT Compress(
   if (outStreamSpec)
     result = outStreamSpec->Close();
   else if (volStreamSpec)
-  {
-    result = volStreamSpec->FinalFlush_and_CloseFiles(st.NumVolumes);
-    st.IsMultiVolMode = true;
-  }
-
-  RINOK(result)
-  
-  if (processedItemsStatuses)
-  {
-    FOR_VECTOR (i, updatePairs2)
-    {
-      const CUpdatePair2 &up = updatePairs2[i];
-      if (up.NewData && up.DirIndex >= 0)
-      {
-        const CDirItem &di = dirItems.Items[(unsigned)up.DirIndex];
-        if (di.AreReparseData() || (!di.IsDir() && di.Size == 0))
-          processedItemsStatuses[(unsigned)up.DirIndex] = 1;
-      }
-    }
-  }
-
+    result = volStreamSpec->Close();
   return result;
 }
 
-
-
-static bool Censor_AreAllAllowed(const NWildcard::CCensor &censor)
-{
-  if (censor.Pairs.Size() != 1)
-    return false;
-  const NWildcard::CPair &pair = censor.Pairs[0];
-  /* Censor_CheckPath() ignores (CPair::Prefix).
-     So we also ignore (CPair::Prefix) here */
-  // if (!pair.Prefix.IsEmpty()) return false;
-  return pair.Head.AreAllAllowed();
-}
-
 bool CensorNode_CheckPath2(const NWildcard::CCensorNode &node, const CReadArcItem &item, bool &include);
 
 static bool Censor_CheckPath(const NWildcard::CCensor &censor, const CReadArcItem &item)
@@ -963,13 +967,9 @@ static bool Censor_CheckPath(const NWildcard::CCensor &censor, const CReadArcIte
   bool finded = false;
   FOR_VECTOR (i, censor.Pairs)
   {
-    /* (CPair::Prefix) in not used for matching items in archive.
-       So we ignore (CPair::Prefix) here */
     bool include;
     if (CensorNode_CheckPath2(censor.Pairs[i].Head, item, include))
     {
-      // Check it and FIXME !!!!
-      // here we can exclude item via some Pair, that is still allowed by another Pair
       if (!include)
         return false;
       finded = true;
@@ -987,18 +987,16 @@ static HRESULT EnumerateInArchiveItems(
   arcItems.Clear();
   UInt32 numItems;
   IInArchive *archive = arc.Archive;
-  RINOK(archive->GetNumberOfItems(&numItems))
+  RINOK(archive->GetNumberOfItems(&numItems));
   arcItems.ClearAndReserve(numItems);
 
   CReadArcItem item;
 
-  const bool allFilesAreAllowed = Censor_AreAllAllowed(censor);
-
   for (UInt32 i = 0; i < numItems; i++)
   {
     CArcItem ai;
 
-    RINOK(arc.GetItem(i, item))
+    RINOK(arc.GetItem(i, item));
     ai.Name = item.Path;
     ai.IsDir = item.IsDir;
     ai.IsAltStream =
@@ -1012,14 +1010,28 @@ static HRESULT EnumerateInArchiveItems(
     if (!storeStreamsMode && ai.IsAltStream)
       continue;
     */
-    if (allFilesAreAllowed)
-      ai.Censored = true;
-    else
-      ai.Censored = Censor_CheckPath(censor, item);
+    ai.Censored = Censor_CheckPath(censor, item);
+
+    RINOK(arc.GetItemMTime(i, ai.MTime, ai.MTimeDefined));
+    RINOK(arc.GetItemSize(i, ai.Size, ai.SizeDefined));
 
-    // ai.MTime will be set to archive MTime, if not present in archive item
-    RINOK(arc.GetItem_MTime(i, ai.MTime))
-    RINOK(arc.GetItem_Size(i, ai.Size, ai.Size_Defined))
+    {
+      CPropVariant prop;
+      RINOK(archive->GetProperty(i, kpidTimeType, &prop));
+      if (prop.vt == VT_UI4)
+      {
+        ai.TimeType = (int)(NFileTimeType::EEnum)prop.ulVal;
+        switch (ai.TimeType)
+        {
+          case NFileTimeType::kWindows:
+          case NFileTimeType::kUnix:
+          case NFileTimeType::kDOS:
+            break;
+          default:
+            return E_FAIL;
+        }
+      }
+    }
 
     ai.IndexInServer = i;
     arcItems.AddInReserved(ai);
@@ -1029,96 +1041,9 @@ static HRESULT EnumerateInArchiveItems(
 
 #if defined(_WIN32) && !defined(UNDER_CE)
 
-#if defined(__MINGW32__) || defined(__MINGW64__)
 #include <mapi.h>
-#else
-#include <MAPI.h>
-#endif
-
-extern "C" {
-
-#ifdef MAPI_FORCE_UNICODE
-
-#define Z7_WIN_LPMAPISENDMAILW  LPMAPISENDMAILW
-#define Z7_WIN_MapiFileDescW    MapiFileDescW
-#define Z7_WIN_MapiMessageW     MapiMessageW
-#define Z7_WIN_MapiRecipDescW   MapiRecipDescW
-
-#else
-
-typedef struct
-{
-    ULONG ulReserved;
-    ULONG ulRecipClass;
-    PWSTR lpszName;
-    PWSTR lpszAddress;
-    ULONG ulEIDSize;
-    PVOID lpEntryID;
-} Z7_WIN_MapiRecipDescW, *Z7_WIN_lpMapiRecipDescW;
-
-typedef struct
-{
-    ULONG ulReserved;
-    ULONG flFlags;
-    ULONG nPosition;
-    PWSTR lpszPathName;
-    PWSTR lpszFileName;
-    PVOID lpFileType;
-} Z7_WIN_MapiFileDescW, *Z7_WIN_lpMapiFileDescW;
-
-typedef struct
-{
-  ULONG ulReserved;
-  PWSTR lpszSubject;
-  PWSTR lpszNoteText;
-  PWSTR lpszMessageType;
-  PWSTR lpszDateReceived;
-  PWSTR lpszConversationID;
-  FLAGS flFlags;
-  Z7_WIN_lpMapiRecipDescW lpOriginator;
-  ULONG nRecipCount;
-  Z7_WIN_lpMapiRecipDescW lpRecips;
-  ULONG nFileCount;
-  Z7_WIN_lpMapiFileDescW lpFiles;
-} Z7_WIN_MapiMessageW, *Z7_WIN_lpMapiMessageW;
-
-typedef ULONG (FAR PASCAL Z7_WIN_MAPISENDMAILW)(
-  LHANDLE lhSession,
-  ULONG_PTR ulUIParam,
-  Z7_WIN_lpMapiMessageW lpMessage,
-  FLAGS flFlags,
-  ULONG ulReserved
-);
-typedef Z7_WIN_MAPISENDMAILW FAR *Z7_WIN_LPMAPISENDMAILW;
-
-#endif // MAPI_FORCE_UNICODE
-}
-#endif // _WIN32
-
-
-struct C_CopyFileProgress_to_IUpdateCallbackUI2 Z7_final:
-  public ICopyFileProgress
-{
-  IUpdateCallbackUI2 *Callback;
-  HRESULT CallbackResult;
-  // bool Disable_Break;
-
-  virtual DWORD CopyFileProgress(UInt64 total, UInt64 current) Z7_override
-  {
-    const HRESULT res = Callback->MoveArc_Progress(total, current);
-    CallbackResult = res;
-    // if (Disable_Break && res == E_ABORT) res = S_OK;
-    return res == S_OK ? PROGRESS_CONTINUE : PROGRESS_CANCEL;
-  }
-
-  C_CopyFileProgress_to_IUpdateCallbackUI2(
-      IUpdateCallbackUI2 *callback) :
-    Callback(callback),
-    CallbackResult(S_OK)
-    // , Disable_Break(false)
-    {}
-};
 
+#endif
 
 HRESULT UpdateArchive(
     CCodecs *codecs,
@@ -1149,7 +1074,7 @@ HRESULT UpdateArchive(
     if (options.Commands.Size() != 1)
       return E_NOTIMPL;
     const CActionSet &as = options.Commands[0].ActionSet;
-    for (unsigned i = 2; i < NPairState::kNumValues; i++)
+    for (int i = 2; i < NPairState::kNumValues; i++)
       if (as.StateActions[i] != NPairAction::kCompress)
         return E_NOTIMPL;
   }
@@ -1178,7 +1103,7 @@ HRESULT UpdateArchive(
     if (options.SfxModule.Find(FCHAR_PATH_SEPARATOR) < 0)
     {
       const FString fullName = NDLL::GetModuleDirPrefix() + options.SfxModule;
-      if (NFind::DoesFileExist_FollowLink(fullName))
+      if (NFind::DoesFileExist(fullName))
       {
         options.SfxModule = fullName;
         found = true;
@@ -1186,7 +1111,7 @@ HRESULT UpdateArchive(
     }
     if (!found)
     {
-      if (!NFind::DoesFileExist_FollowLink(options.SfxModule))
+      if (!NFind::DoesFileExist(options.SfxModule))
         return errorInfo.SetFromLastError("cannot find specified SFX module", options.SfxModule);
     }
   }
@@ -1206,7 +1131,8 @@ HRESULT UpdateArchive(
   if (!options.VolumesSizes.IsEmpty())
   {
     arcPath = options.ArchivePath.GetFinalVolPath();
-    arcPath += ".001";
+    arcPath += '.';
+    arcPath += "001";
   }
 
   if (cmdArcPath2.IsEmpty())
@@ -1217,10 +1143,10 @@ HRESULT UpdateArchive(
   else
   {
     NFind::CFileInfo fi;
-    if (!fi.Find_FollowLink(us2fs(arcPath)))
+    if (!fi.Find(us2fs(arcPath)))
     {
       if (renameMode)
-        throw "can't find archive";
+        throw "can't find archive";;
       if (options.MethodMode.Type.FormatIndex < 0)
       {
         if (!options.SetArcPath(codecs, cmdArcPath2))
@@ -1230,37 +1156,24 @@ HRESULT UpdateArchive(
     else
     {
       if (fi.IsDir())
-        return errorInfo.SetFromError_DWORD("There is a folder with the name of archive",
-            us2fs(arcPath),
-            #ifdef _WIN32
-              ERROR_ACCESS_DENIED
-            #else
-              EISDIR
-            #endif
-            );
-     #ifdef _WIN32
+        throw "there is no such archive";
       if (fi.IsDevice)
         return E_NOTIMPL;
-     #endif
 
       if (!options.StdOutMode && options.UpdateArchiveItself)
         if (fi.IsReadOnly())
         {
-          return errorInfo.SetFromError_DWORD("The file is read-only",
-              us2fs(arcPath),
-              #ifdef _WIN32
-                ERROR_ACCESS_DENIED
-              #else
-                EACCES
-              #endif
-              );
+          errorInfo.SystemError = ERROR_ACCESS_DENIED;
+          errorInfo.Message = "The file is read-only";
+          errorInfo.FileNames.Add(us2fs(arcPath));
+          return errorInfo.Get_HRESULT_Error();
         }
 
       if (options.VolumesSizes.Size() > 0)
       {
         errorInfo.FileNames.Add(us2fs(arcPath));
-        // errorInfo.SystemError = (DWORD)E_NOTIMPL;
-        errorInfo.Message = kUpdateIsNotSupported_MultiVol;
+        errorInfo.SystemError = (DWORD)E_NOTIMPL;
+        errorInfo.Message = kUpdateIsNotSupoorted_MultiVol;
         return E_NOTIMPL;
       }
       CObjectVector<COpenType> types2;
@@ -1271,7 +1184,7 @@ HRESULT UpdateArchive(
 
       CIntVector excl;
       COpenOptions op;
-      #ifndef Z7_SFX
+      #ifndef _SFX
       op.props = &options.MethodMode.Properties;
       #endif
       op.codecs = codecs;
@@ -1281,7 +1194,7 @@ HRESULT UpdateArchive(
       op.stream = NULL;
       op.filePath = arcPath;
 
-      RINOK(callback->StartOpenArchive(arcPath))
+      RINOK(callback->StartOpenArchive(arcPath));
 
       HRESULT result = arcLink.Open_Strict(op, openCallback);
 
@@ -1293,29 +1206,23 @@ HRESULT UpdateArchive(
       if (result == S_FALSE)
         return E_FAIL;
       */
-      RINOK(res2)
-      RINOK(result)
+      RINOK(res2);
+      RINOK(result);
 
       if (arcLink.VolumePaths.Size() > 1)
       {
-        // errorInfo.SystemError = (DWORD)E_NOTIMPL;
-        errorInfo.Message = kUpdateIsNotSupported_MultiVol;
+        errorInfo.SystemError = (DWORD)E_NOTIMPL;
+        errorInfo.Message = kUpdateIsNotSupoorted_MultiVol;
         return E_NOTIMPL;
       }
       
       CArc &arc = arcLink.Arcs.Back();
-      arc.MTime.Def =
-        #ifdef _WIN32
-          !fi.IsDevice;
-        #else
-          true;
-        #endif
-      if (arc.MTime.Def)
-        arc.MTime.Set_From_FiTime(fi.MTime);
+      arc.MTimeDefined = !fi.IsDevice;
+      arc.MTime = fi.MTime;
 
       if (arc.ErrorInfo.ThereIsTail)
       {
-        // errorInfo.SystemError = (DWORD)E_NOTIMPL;
+        errorInfo.SystemError = (DWORD)E_NOTIMPL;
         errorInfo.Message = "There is some data block after the end of the archive";
         return E_NOTIMPL;
       }
@@ -1335,7 +1242,7 @@ HRESULT UpdateArchive(
       return E_NOTIMPL;
   }
 
-  const bool thereIsInArchive = arcLink.IsOpen;
+  bool thereIsInArchive = arcLink.IsOpen;
   if (!thereIsInArchive && renameMode)
     return E_FAIL;
   
@@ -1355,14 +1262,11 @@ HRESULT UpdateArchive(
   if (options.StdInMode)
   {
     CDirItem di;
-    // di.ClearBase();
-    // di.Size = (UInt64)(Int64)-1;
-    if (!di.SetAs_StdInFile())
-      return GetLastError_noZero_HRESULT();
     di.Name = options.StdInFileName;
-    // di.Attrib_IsDefined = false;
-    // NTime::GetCurUtc_FiTime(di.MTime);
-    // di.CTime = di.ATime = di.MTime;
+    di.Size = (UInt64)(Int64)-1;
+    di.Attrib = 0;
+    NTime::GetCurUtcFileTime(di.MTime);
+    di.CTime = di.ATime = di.MTime;
     dirItems.Items.Add(di);
   }
   else
@@ -1376,7 +1280,7 @@ HRESULT UpdateArchive(
 
     if (needScanning)
     {
-      RINOK(callback->StartScanning())
+      RINOK(callback->StartScanning());
 
       dirItems.SymLinks = options.SymLinks.Val;
 
@@ -1385,18 +1289,10 @@ HRESULT UpdateArchive(
       #endif
 
       dirItems.ScanAltStreams = options.AltStreams.Val;
-      dirItems.ExcludeDirItems = censor.ExcludeDirItems;
-      dirItems.ExcludeFileItems = censor.ExcludeFileItems;
-      
-      dirItems.ShareForWrite = options.OpenShareForWrite;
-
-     #ifndef _WIN32
-      dirItems.StoreOwnerName = options.StoreOwnerName.Val;
-     #endif
 
-      const HRESULT res = EnumerateItems(censor,
+      HRESULT res = EnumerateItems(censor,
           options.PathMode,
-          UString(), // options.AddPathPrefix,
+          options.AddPathPrefix,
           dirItems);
 
       if (res != S_OK)
@@ -1406,15 +1302,13 @@ HRESULT UpdateArchive(
         return res;
       }
       
-      RINOK(callback->FinishScanning(dirItems.Stat))
+      RINOK(callback->FinishScanning(dirItems.Stat));
 
-      // 22.00: we don't need parent folder, if absolute path mode
-      if (options.PathMode != NWildcard::k_AbsPath)
       if (censor.Pairs.Size() == 1)
       {
         NFind::CFileInfo fi;
         FString prefix = us2fs(censor.Pairs[0].Prefix);
-        prefix.Add_Dot();
+        prefix += '.';
         // UString prefix = censor.Pairs[0].Prefix;
         /*
         if (prefix.Back() == WCHAR_PATH_SEPARATOR)
@@ -1425,7 +1319,11 @@ HRESULT UpdateArchive(
         if (fi.Find(prefix))
           if (fi.IsDir())
           {
-            parentDirItem.Copy_From_FileInfoBase(fi);
+            parentDirItem.Size = fi.Size;
+            parentDirItem.CTime = fi.CTime;
+            parentDirItem.ATime = fi.ATime;
+            parentDirItem.MTime = fi.MTime;
+            parentDirItem.Attrib = fi.Attrib;
             parentDirItem_Ptr = &parentDirItem;
 
             int secureIndex = -1;
@@ -1434,6 +1332,8 @@ HRESULT UpdateArchive(
               dirItems.AddSecurityItem(prefix, secureIndex);
             #endif
             parentDirItem.SecureIndex = secureIndex;
+
+            parentDirItem_Ptr = &parentDirItem;
           }
       }
     }
@@ -1493,7 +1393,7 @@ HRESULT UpdateArchive(
           UString s;
           s = "It is not allowed to include archive to itself";
           s.Add_LF();
-          s += fs2us(path);
+          s += path;
           throw s;
         }
       }
@@ -1530,7 +1430,7 @@ HRESULT UpdateArchive(
   {
     RINOK(EnumerateInArchiveItems(
       // options.StoreAltStreams,
-      censor, arcLink.Arcs.Back(), arcItems))
+      censor, arcLink.Arcs.Back(), arcItems));
   }
 
   /*
@@ -1543,16 +1443,14 @@ HRESULT UpdateArchive(
   CByteBuffer processedItems;
   if (options.DeleteAfterCompressing)
   {
-    const unsigned num = dirItems.Items.Size();
+    unsigned num = dirItems.Items.Size();
     processedItems.Alloc(num);
     for (unsigned i = 0; i < num; i++)
       processedItems[i] = 0;
   }
 
-  CMultiOutStream_Bunch multiStreams;
-
   /*
-  #ifndef Z7_NO_CRYPTO
+  #ifndef _NO_CRYPTO
   if (arcLink.PasswordWasAsked)
   {
     // We set password, if open have requested password
@@ -1596,30 +1494,19 @@ HRESULT UpdateArchive(
         parentDirItem_Ptr,
 
         tempFiles,
-        multiStreams,
-        errorInfo, callback, st))
+        errorInfo, callback, st));
 
-    RINOK(callback->FinishArchive(st))
+    RINOK(callback->FinishArchive(st));
   }
 
 
   if (thereIsInArchive)
   {
-    RINOK(arcLink.Close())
+    RINOK(arcLink.Close());
     arcLink.Release();
   }
 
-  multiStreams.DisableDeletion();
-  RINOK(multiStreams.Destruct())
-
-  // here we disable deleting of temp archives.
-  // note: archive moving can fail, or it can be interrupted,
-  // if we move new temp update from another volume.
-  // And we still want to keep temp archive in that case,
-  // because we will have deleted original archive.
-  tempFiles.NeedDeleteFiles = false;
-  // tempFiles.Paths.Clear();
-
+  tempFiles.Paths.Clear();
   if (createTempFile)
   {
     try
@@ -1634,52 +1521,13 @@ HRESULT UpdateArchive(
         if (!DeleteFileAlways(us2fs(arcPath)))
           return errorInfo.SetFromLastError("cannot delete the file", us2fs(arcPath));
       }
-
-      UInt64 totalArcSize = 0;
-      {
-        NFind::CFileInfo fi;
-        if (fi.Find(tempPath))
-          totalArcSize = fi.Size;
-      }
-      RINOK(callback->MoveArc_Start(fs2us(tempPath), arcPath,
-          totalArcSize, BoolToInt(thereIsInArchive)))
-
-      C_CopyFileProgress_to_IUpdateCallbackUI2 prox(callback);
-      // if we update archive, we have removed original archive.
-      // So if we break archive moving, we will have only temporary archive.
-      // We can disable breaking here:
-      // prox.Disable_Break = thereIsInArchive;
-
-      if (!MyMoveFile_with_Progress(tempPath, us2fs(arcPath), &prox))
+      
+      if (!MyMoveFile(tempPath, us2fs(arcPath)))
       {
-        errorInfo.SystemError = ::GetLastError();
-        errorInfo.Message = "cannot move the file";
-        if (errorInfo.SystemError == ERROR_INVALID_PARAMETER)
-        {
-          if (totalArcSize > (UInt32)(Int32)-1)
-          {
-            // bool isFsDetected = false;
-            // if (NSystem::Is_File_LimitedBy_4GB(us2fs(arcPath), isFsDetected) || !isFsDetected)
-            {
-              errorInfo.Message.Add_LF();
-              errorInfo.Message += "Archive file size exceeds 4 GB";
-            }
-          }
-        }
-        // if there was no input archive, and we have operation breaking.
-        // then we can remove temporary archive, because we still have original uncompressed files.
-        if (!thereIsInArchive
-            && prox.CallbackResult == E_ABORT)
-          tempFiles.NeedDeleteFiles = true;
-        errorInfo.FileNames.Add(tempPath);
+        errorInfo.SetFromLastError("cannot move the file", tempPath);
         errorInfo.FileNames.Add(us2fs(arcPath));
-        RINOK(prox.CallbackResult)
         return errorInfo.Get_HRESULT_Error();
       }
-
-      // MoveArc_Finish() can return delayed user break (E_ABORT) status,
-      // if callback callee ignored interruption to finish archive creation operation.
-      RINOK(callback->MoveArc_Finish())
       
       /*
       if (attrib != INVALID_FILE_ATTRIBUTES && (attrib & FILE_ATTRIBUTE_READONLY))
@@ -1698,8 +1546,6 @@ HRESULT UpdateArchive(
 
 
   #if defined(_WIN32) && !defined(UNDER_CE)
-
-Z7_DIAGNOSTIC_IGNORE_CAST_FUNCTION
   
   if (options.EMailMode)
   {
@@ -1710,19 +1556,6 @@ Z7_DIAGNOSTIC_IGNORE_CAST_FUNCTION
       return errorInfo.Get_HRESULT_Error();
     }
 
-    FStringVector fullPaths;
-    unsigned i;
-    
-    for (i = 0; i < options.Commands.Size(); i++)
-    {
-      CArchivePath &ap = options.Commands[i].ArchivePath;
-      const FString finalPath = us2fs(ap.GetFinalPath());
-      FString arcPath2;
-      if (!MyGetFullPathName(finalPath, arcPath2))
-        return errorInfo.SetFromLastError("GetFullPathName error", finalPath);
-      fullPaths.Add(arcPath2);
-    }
-
     /*
     LPMAPISENDDOCUMENTS fnSend = (LPMAPISENDDOCUMENTS)mapiLib.GetProc("MAPISendDocuments");
     if (fnSend == 0)
@@ -1731,70 +1564,25 @@ Z7_DIAGNOSTIC_IGNORE_CAST_FUNCTION
       return errorInfo.Get_HRESULT_Error();
     }
     */
-    const
-    Z7_WIN_LPMAPISENDMAILW sendMailW = Z7_GET_PROC_ADDRESS(
-    Z7_WIN_LPMAPISENDMAILW, mapiLib.Get_HMODULE(),
-            "MAPISendMailW");
-   if (sendMailW)
-   {
-
-    CCurrentDirRestorer curDirRestorer;
-
-    UStringVector paths;
-    UStringVector names;
     
-    for (i = 0; i < fullPaths.Size(); i++)
+    LPMAPISENDMAIL sendMail = (LPMAPISENDMAIL)mapiLib.GetProc("MAPISendMail");
+    if (sendMail == 0)
     {
-      const UString arcPath2 = fs2us(fullPaths[i]);
-      const UString fileName = ExtractFileNameFromPath(arcPath2);
-      paths.Add(arcPath2);
-      names.Add(fileName);
-      // Warning!!! MAPISendDocuments function changes Current directory
-      // fnSend(0, ";", (LPSTR)(LPCSTR)path, (LPSTR)(LPCSTR)name, 0);
+      errorInfo.SetFromLastError("7-Zip cannot find MAPISendMail function");
+      return errorInfo.Get_HRESULT_Error();;
     }
 
-    CRecordVector<Z7_WIN_MapiFileDescW> files;
-    files.ClearAndSetSize(paths.Size());
+    FStringVector fullPaths;
+    unsigned i;
     
-    for (i = 0; i < paths.Size(); i++)
-    {
-      Z7_WIN_MapiFileDescW &f = files[i];
-      memset(&f, 0, sizeof(f));
-      f.nPosition = 0xFFFFFFFF;
-      f.lpszPathName = paths[i].Ptr_non_const();
-      f.lpszFileName = names[i].Ptr_non_const();
-    }
-
-    {
-      Z7_WIN_MapiMessageW m;
-      memset(&m, 0, sizeof(m));
-      m.nFileCount = files.Size();
-      m.lpFiles = files.NonConstData();
-      
-      const UString addr (options.EMailAddress);
-      Z7_WIN_MapiRecipDescW rec;
-      if (!addr.IsEmpty())
-      {
-        memset(&rec, 0, sizeof(rec));
-        rec.ulRecipClass = MAPI_TO;
-        rec.lpszAddress = addr.Ptr_non_const();
-        m.nRecipCount = 1;
-        m.lpRecips = &rec;
-      }
-      
-      sendMailW((LHANDLE)0, 0, &m, MAPI_DIALOG, 0);
-    }
-   }
-   else
-   {
-    const
-    LPMAPISENDMAIL sendMail = Z7_GET_PROC_ADDRESS(
-    LPMAPISENDMAIL, mapiLib.Get_HMODULE(),
-     "MAPISendMail");
-    if (!sendMail)
+    for (i = 0; i < options.Commands.Size(); i++)
     {
-      errorInfo.SetFromLastError("7-Zip cannot find MAPISendMail function");
-      return errorInfo.Get_HRESULT_Error();
+      CArchivePath &ap = options.Commands[i].ArchivePath;
+      FString finalPath = us2fs(ap.GetFinalPath());
+      FString arcPath2;
+      if (!MyGetFullPathName(finalPath, arcPath2))
+        return errorInfo.SetFromLastError("GetFullPathName error", finalPath);
+      fullPaths.Add(arcPath2);
     }
 
     CCurrentDirRestorer curDirRestorer;
@@ -1822,15 +1610,15 @@ Z7_DIAGNOSTIC_IGNORE_CAST_FUNCTION
       MapiFileDesc &f = files[i];
       memset(&f, 0, sizeof(f));
       f.nPosition = 0xFFFFFFFF;
-      f.lpszPathName = paths[i].Ptr_non_const();
-      f.lpszFileName = names[i].Ptr_non_const();
+      f.lpszPathName = (char *)(const char *)paths[i];
+      f.lpszFileName = (char *)(const char *)names[i];
     }
 
     {
       MapiMessage m;
       memset(&m, 0, sizeof(m));
       m.nFileCount = files.Size();
-      m.lpFiles = files.NonConstData();
+      m.lpFiles = &files.Front();
       
       const AString addr (GetAnsiString(options.EMailAddress));
       MapiRecipDesc rec;
@@ -1838,14 +1626,13 @@ Z7_DIAGNOSTIC_IGNORE_CAST_FUNCTION
       {
         memset(&rec, 0, sizeof(rec));
         rec.ulRecipClass = MAPI_TO;
-        rec.lpszAddress = addr.Ptr_non_const();
+        rec.lpszAddress = (char *)(const char *)addr;
         m.nRecipCount = 1;
         m.lpRecips = &rec;
       }
       
       sendMail((LHANDLE)0, 0, &m, MAPI_DIALOG, 0);
     }
-   }
   }
   
   #endif
@@ -1870,42 +1657,28 @@ Z7_DIAGNOSTIC_IGNORE_CAST_FUNCTION
       }
       else
       {
-        // 21.04: we have set processedItems[*] before for all required items
-        if (processedItems[i] != 0
-            // || dirItem.Size == 0
-            // || dirItem.AreReparseData()
-            )
+        if (processedItems[i] != 0 || dirItem.Size == 0)
         {
           NFind::CFileInfo fileInfo;
-          /* if (!SymLinks), we follow link here, similar to (dirItem) filling */
-          if (fileInfo.Find(phyPath, !options.SymLinks.Val))
+          if (fileInfo.Find(phyPath))
           {
-            bool is_SameSize = false;
-            if (options.SymLinks.Val && dirItem.AreReparseData())
-            {
-              /* (dirItem.Size = dirItem.ReparseData.Size()) was set before.
-                 So we don't compare sizes for that case here */
-              is_SameSize = fileInfo.IsOsSymLink();
-            }
-            else
-              is_SameSize = (fileInfo.Size == dirItem.Size);
-
-            if (is_SameSize
-                && Compare_FiTime(&fileInfo.MTime, &dirItem.MTime) == 0
-                && Compare_FiTime(&fileInfo.CTime, &dirItem.CTime) == 0)
+            // maybe we must exclude also files with archive name: "a a.7z * -sdel"
+            if (fileInfo.Size == dirItem.Size
+                && CompareFileTime(&fileInfo.MTime, &dirItem.MTime) == 0
+                && CompareFileTime(&fileInfo.CTime, &dirItem.CTime) == 0)
             {
-              RINOK(callback->DeletingAfterArchiving(phyPath, false))
+              RINOK(callback->DeletingAfterArchiving(phyPath, false));
               DeleteFileAlways(phyPath);
             }
           }
         }
         else
         {
-          // file was skipped by some reason. We can throw error for debug:
+          // file was skipped
           /*
           errorInfo.SystemError = 0;
           errorInfo.Message = "file was not processed";
-          errorInfo.FileNames.Add(phyPath);
+          errorInfo.FileName = phyPath;
           return E_FAIL;
           */
         }
@@ -1919,12 +1692,12 @@ Z7_DIAGNOSTIC_IGNORE_CAST_FUNCTION
       const FString phyPath = dirItems.GetPhyPath(pairs[i].Index);
       if (NFind::DoesDirExist(phyPath))
       {
-        RINOK(callback->DeletingAfterArchiving(phyPath, true))
-        RemoveDirAlways_if_Empty(phyPath);
+        RINOK(callback->DeletingAfterArchiving(phyPath, true));
+        RemoveDir(phyPath);
       }
     }
 
-    RINOK(callback->FinishDeletingAfterArchiving())
+    RINOK(callback->FinishDeletingAfterArchiving());
   }
 
   return S_OK;