seven-zip 1.4.2 → 1.7.0.rc1

data/ext/p7zip/CPP/7zip/Archive/Tar/TarOut.cpp

@@ -2,8 +2,6 @@
 
 #include "StdAfx.h"
 
-#include "Common/IntToString.h"
-
 #include "../../Common/StreamUtils.h"
 
 #include "TarOut.h"
@@ -11,26 +9,15 @@
 namespace NArchive {
 namespace NTar {
 
-HRESULT COutArchive::WriteBytes(const void *buffer, UInt32 size)
-{
-  return WriteStream(m_Stream, buffer, size);
-}
-
-void COutArchive::Create(ISequentialOutStream *outStream)
+HRESULT COutArchive::WriteBytes(const void *data, unsigned size)
 {
-  m_Stream = outStream;
+  Pos += size;
+  return WriteStream(m_Stream, data, size);
 }
 
-static AString MakeOctalString(UInt64 value)
+static void MyStrNCpy(char *dest, const char *src, unsigned size)
 {
-  char s[32];
-  ConvertUInt64ToString(value, s, 8);
-  return AString(s) + ' ';
-}
-
-static void MyStrNCpy(char *dest, const char *src, int size)
-{
-  for (int i = 0; i < size; i++)
+  for (unsigned i = 0; i < size; i++)
   {
     char c = src[i];
     dest[i] = c;
@@ -39,42 +26,53 @@ static void MyStrNCpy(char *dest, const char *src, int size)
   }
 }
 
-static bool MakeOctalString8(char *s, UInt32 value)
+static bool WriteOctal_8(char *s, UInt32 val)
 {
-  AString tempString = MakeOctalString(value);
-
-  const int kMaxSize = 8;
-  if (tempString.Length() >= kMaxSize)
+  const unsigned kNumDigits = 8 - 1;
+  if (val >= ((UInt32)1 << (kNumDigits * 3)))
     return false;
-  int numSpaces = kMaxSize - (tempString.Length() + 1);
-  for(int i = 0; i < numSpaces; i++)
-    s[i] = ' ';
-  MyStringCopy(s + numSpaces, (const char *)tempString);
+  for (unsigned i = 0; i < kNumDigits; i++)
+  {
+    s[kNumDigits - 1 - i] = (char)('0' + (val & 7));
+    val >>= 3;
+  }
   return true;
 }
 
-static void MakeOctalString12(char *s, UInt64 value)
+static void WriteOctal_12(char *s, UInt64 val)
 {
-  AString tempString  = MakeOctalString(value);
-  const int kMaxSize = 12;
-  if (tempString.Length() > kMaxSize)
+  const unsigned kNumDigits = 12 - 1;
+  if (val >= ((UInt64)1 << (kNumDigits * 3)))
   {
     // GNU extension;
     s[0] = (char)(Byte)0x80;
     s[1] = s[2] = s[3] = 0;
-    for (int i = 0; i < 8; i++, value <<= 8)
-      s[4 + i] = (char)(value >> 56);
+    for (unsigned i = 0; i < 8; i++, val <<= 8)
+      s[4 + i] = (char)(val >> 56);
+    return;
+  }
+  for (unsigned i = 0; i < kNumDigits; i++)
+  {
+    s[kNumDigits - 1 - i] = (char)('0' + (val & 7));
+    val >>= 3;
+  }
+}
+
+static void WriteOctal_12_Signed(char *s, Int64 val)
+{
+  if (val >= 0)
+  {
+    WriteOctal_12(s, val);
     return;
   }
-  int numSpaces = kMaxSize - tempString.Length();
-  for(int i = 0; i < numSpaces; i++)
-    s[i] = ' ';
-  memmove(s + numSpaces, (const char *)tempString, tempString.Length());
+  s[0] = s[1] = s[2] = s[3] = (char)(Byte)0xFF;
+  for (unsigned i = 0; i < 8; i++, val <<= 8)
+    s[4 + i] = (char)(val >> 56);
 }
 
-static bool CopyString(char *dest, const AString &src, int maxSize)
+static bool CopyString(char *dest, const AString &src, unsigned maxSize)
 {
-  if (src.Length() >= maxSize)
+  if (src.Len() >= maxSize)
     return false;
   MyStringCopy(dest, (const char *)src);
   return true;
@@ -85,25 +83,22 @@ static bool CopyString(char *dest, const AString &src, int maxSize)
 HRESULT COutArchive::WriteHeaderReal(const CItem &item)
 {
   char record[NFileHeader::kRecordSize];
+  memset(record, 0, NFileHeader::kRecordSize);
   char *cur = record;
-  int i;
-  for (i = 0; i < NFileHeader::kRecordSize; i++)
-    record[i] = 0;
 
-  // RETURN_IF_NOT_TRUE(CopyString(header.Name, item.Name, NFileHeader::kNameSize));
-  if (item.Name.Length() > NFileHeader::kNameSize)
+  if (item.Name.Len() > NFileHeader::kNameSize)
     return E_FAIL;
   MyStrNCpy(cur, item.Name, NFileHeader::kNameSize);
   cur += NFileHeader::kNameSize;
 
-  RETURN_IF_NOT_TRUE(MakeOctalString8(cur, item.Mode)); cur += 8;
-  RETURN_IF_NOT_TRUE(MakeOctalString8(cur, item.UID)); cur += 8;
-  RETURN_IF_NOT_TRUE(MakeOctalString8(cur, item.GID)); cur += 8;
+  RETURN_IF_NOT_TRUE(WriteOctal_8(cur, item.Mode)); cur += 8;
+  RETURN_IF_NOT_TRUE(WriteOctal_8(cur, item.UID)); cur += 8;
+  RETURN_IF_NOT_TRUE(WriteOctal_8(cur, item.GID)); cur += 8;
 
-  MakeOctalString12(cur, item.Size); cur += 12;
-  MakeOctalString12(cur, item.MTime); cur += 12;
+  WriteOctal_12(cur, item.PackSize); cur += 12;
+  WriteOctal_12_Signed(cur, item.MTime); cur += 12;
   
-  memmove(cur, NFileHeader::kCheckSumBlanks, 8);
+  memset(cur, ' ', 8);
   cur += 8;
 
   *cur++ = item.LinkFlag;
@@ -111,7 +106,7 @@ HRESULT COutArchive::WriteHeaderReal(const CItem &item)
   RETURN_IF_NOT_TRUE(CopyString(cur, item.LinkName, NFileHeader::kNameSize));
   cur += NFileHeader::kNameSize;
 
-  memmove(cur, item.Magic, 8);
+  memcpy(cur, item.Magic, 8);
   cur += 8;
 
   RETURN_IF_NOT_TRUE(CopyString(cur, item.User, NFileHeader::kUserNameSize));
@@ -120,64 +115,127 @@ HRESULT COutArchive::WriteHeaderReal(const CItem &item)
   cur += NFileHeader::kGroupNameSize;
 
 
-  if (item.DeviceMajorDefined)
-    RETURN_IF_NOT_TRUE(MakeOctalString8(cur, item.DeviceMajor));
-  cur += 8;
+  if (item.DeviceMajorDefined) RETURN_IF_NOT_TRUE(WriteOctal_8(cur, item.DeviceMajor)); cur += 8;
+  if (item.DeviceMinorDefined) RETURN_IF_NOT_TRUE(WriteOctal_8(cur, item.DeviceMinor)); cur += 8;
 
-  if (item.DeviceMinorDefined)
-    RETURN_IF_NOT_TRUE(MakeOctalString8(cur, item.DeviceMinor));
-  cur += 8;
+  if (item.IsSparse())
+  {
+    record[482] = (char)(item.SparseBlocks.Size() > 4 ? 1 : 0);
+    WriteOctal_12(record + 483, item.Size);
+    for (unsigned i = 0; i < item.SparseBlocks.Size() && i < 4; i++)
+    {
+      const CSparseBlock &sb = item.SparseBlocks[i];
+      char *p = record + 386 + 24 * i;
+      WriteOctal_12(p, sb.Offset);
+      WriteOctal_12(p + 12, sb.Size);
+    }
+  }
 
+  {
+    UInt32 checkSum = 0;
+    {
+      for (unsigned i = 0; i < NFileHeader::kRecordSize; i++)
+        checkSum += (Byte)record[i];
+    }
+    /* we use GNU TAR scheme:
+       checksum field is formatted differently from the
+       other fields: it has [6] digits, a null, then a space. */
+    // RETURN_IF_NOT_TRUE(WriteOctal_8(record + 148, checkSum));
+    const unsigned kNumDigits = 6;
+    for (unsigned i = 0; i < kNumDigits; i++)
+    {
+      record[148 + kNumDigits - 1 - i] = (char)('0' + (checkSum & 7));
+      checkSum >>= 3;
+    }
+    record[148 + 6] = 0;
+  }
 
-  UInt32 checkSumReal = 0;
-  for(i = 0; i < NFileHeader::kRecordSize; i++)
-    checkSumReal += Byte(record[i]);
+  RINOK(WriteBytes(record, NFileHeader::kRecordSize));
 
-  RETURN_IF_NOT_TRUE(MakeOctalString8(record + 148, checkSumReal));
+  if (item.IsSparse())
+  {
+    for (unsigned i = 4; i < item.SparseBlocks.Size();)
+    {
+      memset(record, 0, NFileHeader::kRecordSize);
+      for (unsigned t = 0; t < 21 && i < item.SparseBlocks.Size(); t++, i++)
+      {
+        const CSparseBlock &sb = item.SparseBlocks[i];
+        char *p = record + 24 * t;
+        WriteOctal_12(p, sb.Offset);
+        WriteOctal_12(p + 12, sb.Size);
+      }
+      record[21 * 24] = (char)(i < item.SparseBlocks.Size() ? 1 : 0);
+      RINOK(WriteBytes(record, NFileHeader::kRecordSize));
+    }
+  }
 
-  return WriteBytes(record, NFileHeader::kRecordSize);
+  return S_OK;
 }
 
 HRESULT COutArchive::WriteHeader(const CItem &item)
 {
-  int nameSize = item.Name.Length();
-  if (nameSize < NFileHeader::kNameSize)
+  unsigned nameSize = item.Name.Len();
+  unsigned linkSize = item.LinkName.Len();
+
+  /* There two versions of GNU tar:
+    OLDGNU_FORMAT: it writes short name and zero at the  end
+    GNU_FORMAT:    it writes only short name without zero at the end
+    we write it as OLDGNU_FORMAT with zero at the end */
+
+  if (nameSize < NFileHeader::kNameSize &&
+      linkSize < NFileHeader::kNameSize)
     return WriteHeaderReal(item);
 
-  CItem modifiedItem = item;
-  int nameStreamSize = nameSize + 1;
-  modifiedItem.Size = nameStreamSize;
-  modifiedItem.LinkFlag = 'L';
-  modifiedItem.Name = NFileHeader::kLongLink;
-  modifiedItem.LinkName.Empty();
-  RINOK(WriteHeaderReal(modifiedItem));
-  RINOK(WriteBytes(item.Name, nameStreamSize));
-  RINOK(FillDataResidual(nameStreamSize));
-
-  modifiedItem = item;
-  modifiedItem.Name = item.Name.Left(NFileHeader::kNameSize - 1);
-  return WriteHeaderReal(modifiedItem);
+  CItem mi = item;
+  mi.Name = NFileHeader::kLongLink;
+  mi.LinkName.Empty();
+  for (int i = 0; i < 2; i++)
+  {
+    const AString *name;
+    // We suppose that GNU tar also writes item for long link before item for LongName?
+    if (i == 0)
+    {
+      mi.LinkFlag = NFileHeader::NLinkFlag::kGnu_LongLink;
+      name = &item.LinkName;
+    }
+    else
+    {
+      mi.LinkFlag = NFileHeader::NLinkFlag::kGnu_LongName;
+      name = &item.Name;
+    }
+    if (name->Len() < NFileHeader::kNameSize)
+      continue;
+    unsigned nameStreamSize = name->Len() + 1;
+    mi.PackSize = nameStreamSize;
+    RINOK(WriteHeaderReal(mi));
+    RINOK(WriteBytes((const char *)*name, nameStreamSize));
+    RINOK(FillDataResidual(nameStreamSize));
+  }
+
+  mi = item;
+  if (mi.Name.Len() >= NFileHeader::kNameSize)
+    mi.Name.SetFrom(item.Name, NFileHeader::kNameSize - 1);
+  if (mi.LinkName.Len() >= NFileHeader::kNameSize)
+    mi.LinkName.SetFrom(item.LinkName, NFileHeader::kNameSize - 1);
+  return WriteHeaderReal(mi);
 }
 
 HRESULT COutArchive::FillDataResidual(UInt64 dataSize)
 {
-  UInt32 lastRecordSize = UInt32(dataSize & (NFileHeader::kRecordSize - 1));
+  unsigned lastRecordSize = ((unsigned)dataSize & (NFileHeader::kRecordSize - 1));
   if (lastRecordSize == 0)
     return S_OK;
-  UInt32 residualSize = NFileHeader::kRecordSize - lastRecordSize;
-  Byte residualBytes[NFileHeader::kRecordSize];
-  for (UInt32 i = 0; i < residualSize; i++)
-    residualBytes[i] = 0;
-  return WriteBytes(residualBytes, residualSize);
+  unsigned rem = NFileHeader::kRecordSize - lastRecordSize;
+  Byte buf[NFileHeader::kRecordSize];
+  memset(buf, 0, rem);
+  return WriteBytes(buf, rem);
 }
 
 HRESULT COutArchive::WriteFinishHeader()
 {
   Byte record[NFileHeader::kRecordSize];
-  int i;
-  for (i = 0; i < NFileHeader::kRecordSize; i++)
-    record[i] = 0;
-  for (i = 0; i < 2; i++)
+  memset(record, 0, NFileHeader::kRecordSize);
+  for (unsigned i = 0; i < 2; i++)
   {
     RINOK(WriteBytes(record, NFileHeader::kRecordSize));
   }

data/ext/p7zip/CPP/7zip/Archive/Tar/TarOut.h

@@ -3,21 +3,29 @@
 #ifndef __ARCHIVE_TAR_OUT_H
 #define __ARCHIVE_TAR_OUT_H
 
-#include "TarItem.h"
+#include "../../../Common/MyCom.h"
 
-#include "Common/MyCom.h"
 #include "../../IStream.h"
 
+#include "TarItem.h"
+
 namespace NArchive {
 namespace NTar {
 
 class COutArchive
 {
   CMyComPtr<ISequentialOutStream> m_Stream;
-  HRESULT WriteBytes(const void *buffer, UInt32 size);
-public:
-  void Create(ISequentialOutStream *outStream);
+
+  HRESULT WriteBytes(const void *data, unsigned size);
   HRESULT WriteHeaderReal(const CItem &item);
+public:
+  UInt64 Pos;
+  
+  void Create(ISequentialOutStream *outStream)
+  {
+    m_Stream = outStream;
+  }
+
   HRESULT WriteHeader(const CItem &item);
   HRESULT FillDataResidual(UInt64 dataSize);
   HRESULT WriteFinishHeader();

data/ext/p7zip/CPP/7zip/Archive/Tar/TarRegister.cpp

@@ -5,14 +5,19 @@
 #include "../../Common/RegisterArc.h"
 
 #include "TarHandler.h"
-static IInArchive *CreateArc() { return new NArchive::NTar::CHandler; }
-#ifndef EXTRACT_ONLY
-static IOutArchive *CreateArcOut() { return new NArchive::NTar::CHandler; }
-#else
-#define CreateArcOut 0
-#endif
 
-static CArcInfo g_ArcInfo =
-{ L"tar", L"tar", 0, 0xEE, { 'u', 's', 't', 'a', 'r' }, 5, false, CreateArc, CreateArcOut };
+namespace NArchive {
+namespace NTar {
 
-REGISTER_ARC(Tar)
+static const Byte k_Signature[] = { 'u', 's', 't', 'a', 'r' };
+
+REGISTER_ARC_IO(
+  "tar", "tar ova", 0, 0xEE,
+  k_Signature,
+  NFileHeader::kUstarMagic_Offset,
+  NArcInfoFlags::kStartOpen |
+  NArcInfoFlags::kSymLinks |
+  NArcInfoFlags::kHardLinks,
+  IsArc_Tar)
+ 
+}}

data/ext/p7zip/CPP/7zip/Archive/Tar/TarUpdate.cpp

@@ -2,6 +2,8 @@
 
 #include "StdAfx.h"
 
+#include "../../../Windows/TimeUtils.h"
+
 #include "../../Common/LimitedStreams.h"
 #include "../../Common/ProgressUtils.h"
 
@@ -13,24 +15,35 @@
 namespace NArchive {
 namespace NTar {
 
+HRESULT GetPropString(IArchiveUpdateCallback *callback, UInt32 index, PROPID propId,
+    AString &res, UINT codePage, bool convertSlash = false);
+
 HRESULT UpdateArchive(IInStream *inStream, ISequentialOutStream *outStream,
     const CObjectVector<NArchive::NTar::CItemEx> &inputItems,
     const CObjectVector<CUpdateItem> &updateItems,
+    UINT codePage,
     IArchiveUpdateCallback *updateCallback)
 {
   COutArchive outArchive;
   outArchive.Create(outStream);
+  outArchive.Pos = 0;
+
+  CMyComPtr<IOutStream> outSeekStream;
+  outStream->QueryInterface(IID_IOutStream, (void **)&outSeekStream);
+
+  CMyComPtr<IArchiveUpdateCallbackFile> opCallback;
+  updateCallback->QueryInterface(IID_IArchiveUpdateCallbackFile, (void **)&opCallback);
 
   UInt64 complexity = 0;
 
-  int i;
-  for(i = 0; i < updateItems.Size(); i++)
+  unsigned i;
+  for (i = 0; i < updateItems.Size(); i++)
   {
     const CUpdateItem &ui = updateItems[i];
     if (ui.NewData)
       complexity += ui.Size;
     else
-      complexity += inputItems[ui.IndexInArchive].GetFullSize();
+      complexity += inputItems[ui.IndexInArc].GetFullSize();
   }
 
   RINOK(updateCallback->SetTotal(complexity));
@@ -48,91 +61,205 @@ HRESULT UpdateArchive(IInStream *inStream, ISequentialOutStream *outStream,
 
   complexity = 0;
 
-  for(i = 0; i < updateItems.Size(); i++)
+  for (i = 0; i < updateItems.Size(); i++)
   {
     lps->InSize = lps->OutSize = complexity;
     RINOK(lps->SetCur());
 
     const CUpdateItem &ui = updateItems[i];
     CItem item;
+  
     if (ui.NewProps)
     {
       item.Mode = ui.Mode;
       item.Name = ui.Name;
       item.User = ui.User;
       item.Group = ui.Group;
+      
       if (ui.IsDir)
       {
         item.LinkFlag = NFileHeader::NLinkFlag::kDirectory;
-        item.Size = 0;
+        item.PackSize = 0;
       }
       else
       {
         item.LinkFlag = NFileHeader::NLinkFlag::kNormal;
-        item.Size = ui.Size;
+        item.PackSize = ui.Size;
       }
-      item.MTime = ui.Time;
+      
+      item.MTime = ui.MTime;
       item.DeviceMajorDefined = false;
       item.DeviceMinorDefined = false;
       item.UID = 0;
       item.GID = 0;
-      memmove(item.Magic, NFileHeader::NMagic::kEmpty, 8);
+      memcpy(item.Magic, NFileHeader::NMagic::kUsTar_00, 8);
     }
     else
-      item = inputItems[ui.IndexInArchive];
+      item = inputItems[ui.IndexInArc];
 
-    if (ui.NewData)
+    AString symLink;
+    if (ui.NewData || ui.NewProps)
     {
-      item.Size = ui.Size;
-      if (item.Size == (UInt64)(Int64)-1)
-        return E_INVALIDARG;
+      RINOK(GetPropString(updateCallback, ui.IndexInClient, kpidSymLink, symLink, codePage, true));
+      if (!symLink.IsEmpty())
+      {
+        item.LinkFlag = NFileHeader::NLinkFlag::kSymLink;
+        item.LinkName = symLink;
+      }
     }
-    else
-      item.Size = inputItems[ui.IndexInArchive].Size;
-  
+
     if (ui.NewData)
     {
+      item.SparseBlocks.Clear();
+      item.PackSize = ui.Size;
+      item.Size = ui.Size;
+      if (ui.Size == (UInt64)(Int64)-1)
+        return E_INVALIDARG;
+
       CMyComPtr<ISequentialInStream> fileInStream;
-      HRESULT res = updateCallback->GetStream(ui.IndexInClient, &fileInStream);
-      if (res != S_FALSE)
+
+      bool needWrite = true;
+      
+      if (!symLink.IsEmpty())
       {
-        RINOK(res);
+        item.PackSize = 0;
+        item.Size = 0;
+      }
+      else
+      {
+        HRESULT res = updateCallback->GetStream(ui.IndexInClient, &fileInStream);
+        
+        if (res == S_FALSE)
+          needWrite = false;
+        else
+        {
+          RINOK(res);
+          
+          if (fileInStream)
+          {
+            CMyComPtr<IStreamGetProps> getProps;
+            fileInStream->QueryInterface(IID_IStreamGetProps, (void **)&getProps);
+            if (getProps)
+            {
+              FILETIME mTime;
+              UInt64 size2;
+              if (getProps->GetProps(&size2, NULL, NULL, &mTime, NULL) == S_OK)
+              {
+                item.PackSize = size2;
+                item.Size = size2;
+                item.MTime = NWindows::NTime::FileTimeToUnixTime64(mTime);;
+              }
+            }
+          }
+          else
+          {
+            item.PackSize = 0;
+            item.Size = 0;
+          }
+
+          {
+            AString hardLink;
+            RINOK(GetPropString(updateCallback, ui.IndexInClient, kpidHardLink, hardLink, codePage, true));
+            if (!hardLink.IsEmpty())
+            {
+              item.LinkFlag = NFileHeader::NLinkFlag::kHardLink;
+              item.LinkName = hardLink;
+              item.PackSize = 0;
+              item.Size = 0;
+              fileInStream.Release();
+            }
+          }
+        }
+      }
+
+      if (needWrite)
+      {
+        UInt64 fileHeaderStartPos = outArchive.Pos;
         RINOK(outArchive.WriteHeader(item));
-        if (!ui.IsDir)
+        if (fileInStream)
         {
           RINOK(copyCoder->Code(fileInStream, outStream, NULL, NULL, progress));
-          if (copyCoderSpec->TotalSize != item.Size)
-            return E_FAIL;
-          RINOK(outArchive.FillDataResidual(item.Size));
+          outArchive.Pos += copyCoderSpec->TotalSize;
+          if (copyCoderSpec->TotalSize != item.PackSize)
+          {
+            if (!outSeekStream)
+              return E_FAIL;
+            UInt64 backOffset = outArchive.Pos - fileHeaderStartPos;
+            RINOK(outSeekStream->Seek(-(Int64)backOffset, STREAM_SEEK_CUR, NULL));
+            outArchive.Pos = fileHeaderStartPos;
+            item.PackSize = copyCoderSpec->TotalSize;
+            RINOK(outArchive.WriteHeader(item));
+            RINOK(outSeekStream->Seek(item.PackSize, STREAM_SEEK_CUR, NULL));
+            outArchive.Pos += item.PackSize;
+          }
+          RINOK(outArchive.FillDataResidual(item.PackSize));
         }
       }
-      complexity += ui.Size;
+      
+      complexity += item.PackSize;
       RINOK(updateCallback->SetOperationResult(NArchive::NUpdate::NOperationResult::kOK));
     }
     else
     {
-      const CItemEx &existItem = inputItems[ui.IndexInArchive];
+      const CItemEx &existItem = inputItems[ui.IndexInArc];
       UInt64 size;
+      
       if (ui.NewProps)
       {
+        // memcpy(item.Magic, NFileHeader::NMagic::kEmpty, 8);
+        
+        if (!symLink.IsEmpty())
+        {
+          item.PackSize = 0;
+          item.Size = 0;
+        }
+        else
+        {
+          if (ui.IsDir == existItem.IsDir())
+            item.LinkFlag = existItem.LinkFlag;
+        
+          item.SparseBlocks = existItem.SparseBlocks;
+          item.Size = existItem.Size;
+          item.PackSize = existItem.PackSize;
+        }
+        
+        item.DeviceMajorDefined = existItem.DeviceMajorDefined;
+        item.DeviceMinorDefined = existItem.DeviceMinorDefined;
+        item.DeviceMajor = existItem.DeviceMajor;
+        item.DeviceMinor = existItem.DeviceMinor;
+        item.UID = existItem.UID;
+        item.GID = existItem.GID;
+        
         RINOK(outArchive.WriteHeader(item));
         RINOK(inStream->Seek(existItem.GetDataPosition(), STREAM_SEEK_SET, NULL));
-        size = existItem.Size;
+        size = existItem.PackSize;
       }
       else
       {
         RINOK(inStream->Seek(existItem.HeaderPos, STREAM_SEEK_SET, NULL));
         size = existItem.GetFullSize();
       }
+      
       streamSpec->Init(size);
 
+      if (opCallback)
+      {
+        RINOK(opCallback->ReportOperation(
+            NEventIndexType::kInArcIndex, (UInt32)ui.IndexInArc,
+            NUpdateNotifyOp::kReplicate))
+      }
+
       RINOK(copyCoder->Code(inStreamLimited, outStream, NULL, NULL, progress));
       if (copyCoderSpec->TotalSize != size)
         return E_FAIL;
-      RINOK(outArchive.FillDataResidual(existItem.Size));
+      outArchive.Pos += size;
+      RINOK(outArchive.FillDataResidual(existItem.PackSize));
       complexity += size;
     }
   }
+  
+  lps->InSize = lps->OutSize = complexity;
+  RINOK(lps->SetCur());
   return outArchive.WriteFinishHeader();
 }