vcs.maemo.org Git - physicsfs/blob - lzma/CPP/7zip/Archive/7z/7zUpdate.cpp

   1 // UpdateMain.cpp
   2
   3 #include "StdAfx.h"
   4
   5 #include "7zUpdate.h"
   6 #include "7zFolderInStream.h"
   7 #include "7zEncode.h"
   8 #include "7zHandler.h"
   9 #include "7zOut.h"
  10
  11 #include "../../Compress/Copy/CopyCoder.h"
  12 #include "../../Common/ProgressUtils.h"
  13 #include "../../Common/LimitedStreams.h"
  14 #include "../../Common/LimitedStreams.h"
  15 #include "../Common/ItemNameUtils.h"
  16
  17 namespace NArchive {
  18 namespace N7z {
  19
  20 static const wchar_t *kMatchFinderForBCJ2_LZMA = L"BT2";
  21 static const UInt32 kDictionaryForBCJ2_LZMA = 1 << 20;
  22 static const UInt32 kAlgorithmForBCJ2_LZMA = 1;
  23 static const UInt32 kNumFastBytesForBCJ2_LZMA = 64;
  24
  25 static HRESULT WriteRange(IInStream *inStream, ISequentialOutStream *outStream,
  26     UInt64 position, UInt64 size, ICompressProgressInfo *progress)
  27 {
  28   RINOK(inStream->Seek(position, STREAM_SEEK_SET, 0));
  29   CLimitedSequentialInStream *streamSpec = new CLimitedSequentialInStream;
  30   CMyComPtr<CLimitedSequentialInStream> inStreamLimited(streamSpec);
  31   streamSpec->SetStream(inStream);
  32   streamSpec->Init(size);
  33
  34   NCompress::CCopyCoder *copyCoderSpec = new NCompress::CCopyCoder;
  35   CMyComPtr<ICompressCoder> copyCoder = copyCoderSpec;
  36   RINOK(copyCoder->Code(inStreamLimited, outStream, NULL, NULL, progress));
  37   return (copyCoderSpec->TotalSize == size ? S_OK : E_FAIL);
  38 }
  39
  40 static int GetReverseSlashPos(const UString &name)
  41 {
  42   int slashPos = name.ReverseFind(L'/');
  43   #ifdef _WIN32
  44   int slash1Pos = name.ReverseFind(L'\\');
  45   slashPos = MyMax(slashPos, slash1Pos);
  46   #endif
  47   return slashPos;
  48 }
  49
  50 int CUpdateItem::GetExtensionPos() const
  51 {
  52   int slashPos = GetReverseSlashPos(Name);
  53   int dotPos = Name.ReverseFind(L'.');
  54   if (dotPos < 0 || (dotPos < slashPos && slashPos >= 0))
  55     return Name.Length();
  56   return dotPos + 1;
  57 }
  58
  59 UString CUpdateItem::GetExtension() const
  60 {
  61   return Name.Mid(GetExtensionPos());
  62 }
  63
  64 #define RINOZ(x) { int __tt = (x); if (__tt != 0) return __tt; }
  65
  66 static int CompareBuffers(const CByteBuffer &a1, const CByteBuffer &a2)
  67 {
  68   size_t c1 = a1.GetCapacity();
  69   size_t c2 = a2.GetCapacity();
  70   RINOZ(MyCompare(c1, c2));
  71   for (size_t i = 0; i < c1; i++)
  72     RINOZ(MyCompare(a1[i], a2[i]));
  73   return 0;
  74 }
  75
  76 static int CompareCoders(const CCoderInfo &c1, const CCoderInfo &c2)
  77 {
  78   RINOZ(MyCompare(c1.NumInStreams, c2.NumInStreams));
  79   RINOZ(MyCompare(c1.NumOutStreams, c2.NumOutStreams));
  80   RINOZ(MyCompare(c1.MethodID, c2.MethodID));
  81   return CompareBuffers(c1.Properties, c2.Properties);
  82 }
  83
  84 static int CompareBindPairs(const CBindPair &b1, const CBindPair &b2)
  85 {
  86   RINOZ(MyCompare(b1.InIndex, b2.InIndex));
  87   return MyCompare(b1.OutIndex, b2.OutIndex);
  88 }
  89
  90 static int CompareFolders(const CFolder &f1, const CFolder &f2)
  91 {
  92   int s1 = f1.Coders.Size();
  93   int s2 = f2.Coders.Size();
  94   RINOZ(MyCompare(s1, s2));
  95   int i;
  96   for (i = 0; i < s1; i++)
  97     RINOZ(CompareCoders(f1.Coders[i], f2.Coders[i]));
  98   s1 = f1.BindPairs.Size();
  99   s2 = f2.BindPairs.Size();
 100   RINOZ(MyCompare(s1, s2));
 101   for (i = 0; i < s1; i++)
 102     RINOZ(CompareBindPairs(f1.BindPairs[i], f2.BindPairs[i]));
 103   return 0;
 104 }
 105
 106 static int CompareFiles(const CFileItem &f1, const CFileItem &f2)
 107 {
 108   return MyStringCompareNoCase(f1.Name, f2.Name);
 109 }
 110
 111 static int CompareFolderRefs(const int *p1, const int *p2, void *param)
 112 {
 113   int i1 = *p1;
 114   int i2 = *p2;
 115   const CArchiveDatabaseEx &db = *(const CArchiveDatabaseEx *)param;
 116   RINOZ(CompareFolders(
 117       db.Folders[i1],
 118       db.Folders[i2]));
 119   RINOZ(MyCompare(
 120       db.NumUnPackStreamsVector[i1],
 121       db.NumUnPackStreamsVector[i2]));
 122   if (db.NumUnPackStreamsVector[i1] == 0)
 123     return 0;
 124   return CompareFiles(
 125       db.Files[db.FolderStartFileIndex[i1]],
 126       db.Files[db.FolderStartFileIndex[i2]]);
 127 }
 128
 129 ////////////////////////////////////////////////////////////
 130
 131 static int CompareEmptyItems(const int *p1, const int *p2, void *param)
 132 {
 133   const CObjectVector<CUpdateItem> &updateItems = *(const CObjectVector<CUpdateItem> *)param;
 134   const CUpdateItem &u1 = updateItems[*p1];
 135   const CUpdateItem &u2 = updateItems[*p2];
 136   if (u1.IsDirectory != u2.IsDirectory)
 137     return (u1.IsDirectory) ? 1 : -1;
 138   if (u1.IsDirectory)
 139   {
 140     if (u1.IsAnti != u2.IsAnti)
 141       return (u1.IsAnti ? 1 : -1);
 142     int n = MyStringCompareNoCase(u1.Name, u2.Name);
 143     return -n;
 144   }
 145   if (u1.IsAnti != u2.IsAnti)
 146     return (u1.IsAnti ? 1 : -1);
 147   return MyStringCompareNoCase(u1.Name, u2.Name);
 148 }
 149
 150 static const char *g_Exts =
 151   " lzma 7z ace arc arj bz bz2 deb lzo lzx gz pak rpm sit tgz tbz tbz2 tgz cab ha lha lzh rar zoo"
 152   " zip jar ear war msi"
 153   " 3gp avi mov mpeg mpg mpe wmv"
 154   " aac ape fla flac la mp3 m4a mp4 ofr ogg pac ra rm rka shn swa tta wv wma wav"
 155   " swf "
 156   " chm hxi hxs"
 157   " gif jpeg jpg jp2 png tiff  bmp ico psd psp"
 158   " awg ps eps cgm dxf svg vrml wmf emf ai md"
 159   " cad dwg pps key sxi"
 160   " max 3ds"
 161   " iso bin nrg mdf img pdi tar cpio xpi"
 162   " vfd vhd vud vmc vsv"
 163   " vmdk dsk nvram vmem vmsd vmsn vmss vmtm"
 164   " inl inc idl acf asa h hpp hxx c cpp cxx rc java cs pas bas vb cls ctl frm dlg def"
 165   " f77 f f90 f95"
 166   " asm sql manifest dep "
 167   " mak clw csproj vcproj sln dsp dsw "
 168   " class "
 169   " bat cmd"
 170   " xml xsd xsl xslt hxk hxc htm html xhtml xht mht mhtml htw asp aspx css cgi jsp shtml"
 171   " awk sed hta js php php3 php4 php5 phptml pl pm py pyo rb sh tcl vbs"
 172   " text txt tex ans asc srt reg ini doc docx mcw dot rtf hlp xls xlr xlt xlw ppt pdf"
 173   " sxc sxd sxi sxg sxw stc sti stw stm odt ott odg otg odp otp ods ots odf"
 174   " abw afp cwk lwp wpd wps wpt wrf wri"
 175   " abf afm bdf fon mgf otf pcf pfa snf ttf"
 176   " dbf mdb nsf ntf wdb db fdb gdb"
 177   " exe dll ocx vbx sfx sys tlb awx com obj lib out o so "
 178   " pdb pch idb ncb opt";
 179
 180 int GetExtIndex(const char *ext)
 181 {
 182   int extIndex = 1;
 183   const char *p = g_Exts;
 184   for (;;)
 185   {
 186     char c = *p++;
 187     if (c == 0)
 188       return extIndex;
 189     if (c == ' ')
 190       continue;
 191     int pos = 0;
 192     for (;;)
 193     {
 194       char c2 = ext[pos++];
 195       if (c2 == 0 && (c == 0 || c == ' '))
 196         return extIndex;
 197       if (c != c2)
 198         break;
 199       c = *p++;
 200     }
 201     extIndex++;
 202     for (;;)
 203     {
 204       if (c == 0)
 205         return extIndex;
 206       if (c == ' ')
 207         break;
 208       c = *p++;
 209     }
 210   }
 211 }
 212
 213 struct CRefItem
 214 {
 215   UInt32 Index;
 216   const CUpdateItem *UpdateItem;
 217   UInt32 ExtensionPos;
 218   UInt32 NamePos;
 219   int ExtensionIndex;
 220   CRefItem(UInt32 index, const CUpdateItem &updateItem, bool sortByType):
 221     Index(index),
 222     UpdateItem(&updateItem),
 223     ExtensionPos(0),
 224     NamePos(0),
 225     ExtensionIndex(0)
 226   {
 227     if (sortByType)
 228     {
 229       int slashPos = GetReverseSlashPos(updateItem.Name);
 230       NamePos = ((slashPos >= 0) ? (slashPos + 1) : 0);
 231       int dotPos = updateItem.Name.ReverseFind(L'.');
 232       if (dotPos < 0 || (dotPos < slashPos && slashPos >= 0))
 233         ExtensionPos = updateItem.Name.Length();
 234       else
 235       {
 236         ExtensionPos = dotPos + 1;
 237         UString us = updateItem.Name.Mid(ExtensionPos);
 238         if (!us.IsEmpty())
 239         {
 240           us.MakeLower();
 241           int i;
 242           AString s;
 243           for (i = 0; i < us.Length(); i++)
 244           {
 245             wchar_t c = us[i];
 246             if (c >= 0x80)
 247               break;
 248             s += (char)c;
 249           }
 250           if (i == us.Length())
 251             ExtensionIndex = GetExtIndex(s);
 252           else
 253             ExtensionIndex = 0;
 254         }
 255       }
 256     }
 257   }
 258 };
 259
 260 static int CompareUpdateItems(const CRefItem *p1, const CRefItem *p2, void *param)
 261 {
 262   const CRefItem &a1 = *p1;
 263   const CRefItem &a2 = *p2;
 264   const CUpdateItem &u1 = *a1.UpdateItem;
 265   const CUpdateItem &u2 = *a2.UpdateItem;
 266   int n;
 267   if (u1.IsDirectory != u2.IsDirectory)
 268     return (u1.IsDirectory) ? 1 : -1;
 269   if (u1.IsDirectory)
 270   {
 271     if (u1.IsAnti != u2.IsAnti)
 272       return (u1.IsAnti ? 1 : -1);
 273     n = MyStringCompareNoCase(u1.Name, u2.Name);
 274     return -n;
 275   }
 276   bool sortByType = *(bool *)param;
 277   if (sortByType)
 278   {
 279     RINOZ(MyCompare(a1.ExtensionIndex, a2.ExtensionIndex))
 280     RINOZ(MyStringCompareNoCase(u1.Name + a1.ExtensionPos, u2.Name + a2.ExtensionPos));
 281     RINOZ(MyStringCompareNoCase(u1.Name + a1.NamePos, u2.Name + a2.NamePos));
 282     if (u1.IsLastWriteTimeDefined && u2.IsLastWriteTimeDefined)
 283       RINOZ(CompareFileTime(&u1.LastWriteTime, &u2.LastWriteTime));
 284     RINOZ(MyCompare(u1.Size, u2.Size))
 285   }
 286   return MyStringCompareNoCase(u1.Name, u2.Name);
 287 }
 288
 289 struct CSolidGroup
 290 {
 291   CCompressionMethodMode Method;
 292   CRecordVector<UInt32> Indices;
 293 };
 294
 295 static wchar_t *g_ExeExts[] =
 296 {
 297   L"dll",
 298   L"exe",
 299   L"ocx",
 300   L"sfx",
 301   L"sys"
 302 };
 303
 304 static bool IsExeFile(const UString &ext)
 305 {
 306   for (int i = 0; i < sizeof(g_ExeExts) / sizeof(g_ExeExts[0]); i++)
 307     if (ext.CompareNoCase(g_ExeExts[i]) == 0)
 308       return true;
 309   return false;
 310 }
 311
 312 static const UInt64 k_LZMA  = 0x030101;
 313 static const UInt64 k_BCJ   = 0x03030103;
 314 static const UInt64 k_BCJ2  = 0x0303011B;
 315
 316 static bool GetMethodFull(UInt64 methodID,
 317     UInt32 numInStreams, CMethodFull &methodResult)
 318 {
 319   methodResult.Id = methodID;
 320   methodResult.NumInStreams = numInStreams;
 321   methodResult.NumOutStreams = 1;
 322   return true;
 323 }
 324
 325 static bool MakeExeMethod(const CCompressionMethodMode &method,
 326     bool bcj2Filter, CCompressionMethodMode &exeMethod)
 327 {
 328   exeMethod = method;
 329   if (bcj2Filter)
 330   {
 331     CMethodFull methodFull;
 332     if (!GetMethodFull(k_BCJ2, 4, methodFull))
 333       return false;
 334     exeMethod.Methods.Insert(0, methodFull);
 335     if (!GetMethodFull(k_LZMA, 1, methodFull))
 336       return false;
 337     {
 338       CProp property;
 339       property.Id = NCoderPropID::kAlgorithm;
 340       property.Value = kAlgorithmForBCJ2_LZMA;
 341       methodFull.Properties.Add(property);
 342     }
 343     {
 344       CProp property;
 345       property.Id = NCoderPropID::kMatchFinder;
 346       property.Value = kMatchFinderForBCJ2_LZMA;
 347       methodFull.Properties.Add(property);
 348     }
 349     {
 350       CProp property;
 351       property.Id = NCoderPropID::kDictionarySize;
 352       property.Value = kDictionaryForBCJ2_LZMA;
 353       methodFull.Properties.Add(property);
 354     }
 355     {
 356       CProp property;
 357       property.Id = NCoderPropID::kNumFastBytes;
 358       property.Value = kNumFastBytesForBCJ2_LZMA;
 359       methodFull.Properties.Add(property);
 360     }
 361
 362     exeMethod.Methods.Add(methodFull);
 363     exeMethod.Methods.Add(methodFull);
 364     CBind bind;
 365
 366     bind.OutCoder = 0;
 367     bind.InStream = 0;
 368
 369     bind.InCoder = 1;
 370     bind.OutStream = 0;
 371     exeMethod.Binds.Add(bind);
 372
 373     bind.InCoder = 2;
 374     bind.OutStream = 1;
 375     exeMethod.Binds.Add(bind);
 376
 377     bind.InCoder = 3;
 378     bind.OutStream = 2;
 379     exeMethod.Binds.Add(bind);
 380   }
 381   else
 382   {
 383     CMethodFull methodFull;
 384     if (!GetMethodFull(k_BCJ, 1, methodFull))
 385       return false;
 386     exeMethod.Methods.Insert(0, methodFull);
 387     CBind bind;
 388     bind.OutCoder = 0;
 389     bind.InStream = 0;
 390     bind.InCoder = 1;
 391     bind.OutStream = 0;
 392     exeMethod.Binds.Add(bind);
 393   }
 394   return true;
 395 }
 396
 397 static void SplitFilesToGroups(
 398     const CCompressionMethodMode &method,
 399     bool useFilters, bool maxFilter,
 400     const CObjectVector<CUpdateItem> &updateItems,
 401     CObjectVector<CSolidGroup> &groups)
 402 {
 403   if (method.Methods.Size() != 1 || method.Binds.Size() != 0)
 404     useFilters = false;
 405   groups.Clear();
 406   groups.Add(CSolidGroup());
 407   groups.Add(CSolidGroup());
 408   CSolidGroup &generalGroup = groups[0];
 409   CSolidGroup &exeGroup = groups[1];
 410   generalGroup.Method = method;
 411   int i;
 412   for (i = 0; i < updateItems.Size(); i++)
 413   {
 414     const CUpdateItem &updateItem = updateItems[i];
 415     if (!updateItem.NewData)
 416       continue;
 417     if (!updateItem.HasStream())
 418       continue;
 419     if (useFilters)
 420     {
 421       const UString name = updateItem.Name;
 422       int dotPos = name.ReverseFind(L'.');
 423       if (dotPos >= 0)
 424       {
 425         UString ext = name.Mid(dotPos + 1);
 426         if (IsExeFile(ext))
 427         {
 428           exeGroup.Indices.Add(i);
 429           continue;
 430         }
 431       }
 432     }
 433     generalGroup.Indices.Add(i);
 434   }
 435   if (exeGroup.Indices.Size() > 0)
 436     if (!MakeExeMethod(method, maxFilter, exeGroup.Method))
 437       exeGroup.Method = method;
 438   for (i = 0; i < groups.Size();)
 439     if (groups[i].Indices.Size() == 0)
 440       groups.Delete(i);
 441     else
 442       i++;
 443 }
 444
 445 static void FromUpdateItemToFileItem(const CUpdateItem &updateItem,
 446     CFileItem &file)
 447 {
 448   file.Name = NItemName::MakeLegalName(updateItem.Name);
 449   if (updateItem.AttributesAreDefined)
 450     file.SetAttributes(updateItem.Attributes);
 451
 452   if (updateItem.IsCreationTimeDefined)
 453     file.SetCreationTime(updateItem.CreationTime);
 454   if (updateItem.IsLastWriteTimeDefined)
 455     file.SetLastWriteTime(updateItem.LastWriteTime);
 456   if (updateItem.IsLastAccessTimeDefined)
 457     file.SetLastAccessTime(updateItem.LastAccessTime);
 458
 459   file.UnPackSize = updateItem.Size;
 460   file.IsDirectory = updateItem.IsDirectory;
 461   file.IsAnti = updateItem.IsAnti;
 462   file.HasStream = updateItem.HasStream();
 463 }
 464
 465 static HRESULT Update2(
 466     DECL_EXTERNAL_CODECS_LOC_VARS
 467     IInStream *inStream,
 468     const CArchiveDatabaseEx *database,
 469     const CObjectVector<CUpdateItem> &updateItems,
 470     ISequentialOutStream *seqOutStream,
 471     IArchiveUpdateCallback *updateCallback,
 472     const CUpdateOptions &options)
 473 {
 474   UInt64 numSolidFiles = options.NumSolidFiles;
 475   if (numSolidFiles == 0)
 476     numSolidFiles = 1;
 477   /*
 478   CMyComPtr<IOutStream> outStream;
 479   RINOK(seqOutStream->QueryInterface(IID_IOutStream, (void **)&outStream));
 480   if (!outStream)
 481     return E_NOTIMPL;
 482   */
 483
 484   UInt64 startBlockSize = database != 0 ? database->ArchiveInfo.StartPosition: 0;
 485   if (startBlockSize > 0 && !options.RemoveSfxBlock)
 486   {
 487     RINOK(WriteRange(inStream, seqOutStream, 0, startBlockSize, NULL));
 488   }
 489
 490   CRecordVector<int> fileIndexToUpdateIndexMap;
 491   if (database != 0)
 492   {
 493     fileIndexToUpdateIndexMap.Reserve(database->Files.Size());
 494     for (int i = 0; i < database->Files.Size(); i++)
 495       fileIndexToUpdateIndexMap.Add(-1);
 496   }
 497   int i;
 498   for(i = 0; i < updateItems.Size(); i++)
 499   {
 500     int index = updateItems[i].IndexInArchive;
 501     if (index != -1)
 502       fileIndexToUpdateIndexMap[index] = i;
 503   }
 504
 505   CRecordVector<int> folderRefs;
 506   if (database != 0)
 507   {
 508     for(i = 0; i < database->Folders.Size(); i++)
 509     {
 510       CNum indexInFolder = 0;
 511       CNum numCopyItems = 0;
 512       CNum numUnPackStreams = database->NumUnPackStreamsVector[i];
 513       for (CNum fileIndex = database->FolderStartFileIndex[i];
 514       indexInFolder < numUnPackStreams; fileIndex++)
 515       {
 516         if (database->Files[fileIndex].HasStream)
 517         {
 518           indexInFolder++;
 519           int updateIndex = fileIndexToUpdateIndexMap[fileIndex];
 520           if (updateIndex >= 0)
 521             if (!updateItems[updateIndex].NewData)
 522               numCopyItems++;
 523         }
 524       }
 525       if (numCopyItems != numUnPackStreams && numCopyItems != 0)
 526         return E_NOTIMPL; // It needs repacking !!!
 527       if (numCopyItems > 0)
 528         folderRefs.Add(i);
 529     }
 530     folderRefs.Sort(CompareFolderRefs, (void *)database);
 531   }
 532
 533   CArchiveDatabase newDatabase;
 534
 535   ////////////////////////////
 536
 537   COutArchive archive;
 538   RINOK(archive.Create(seqOutStream, false));
 539   RINOK(archive.SkeepPrefixArchiveHeader());
 540   UInt64 complexity = 0;
 541   for(i = 0; i < folderRefs.Size(); i++)
 542     complexity += database->GetFolderFullPackSize(folderRefs[i]);
 543   UInt64 inSizeForReduce = 0;
 544   for(i = 0; i < updateItems.Size(); i++)
 545   {
 546     const CUpdateItem &updateItem = updateItems[i];
 547     if (updateItem.NewData)
 548     {
 549       complexity += updateItem.Size;
 550       if (numSolidFiles == 1)
 551       {
 552         if (updateItem.Size > inSizeForReduce)
 553           inSizeForReduce = updateItem.Size;
 554       }
 555       else
 556         inSizeForReduce += updateItem.Size;
 557     }
 558   }
 559   RINOK(updateCallback->SetTotal(complexity));
 560   complexity = 0;
 561   RINOK(updateCallback->SetCompleted(&complexity));
 562
 563
 564   CLocalProgress *lps = new CLocalProgress;
 565   CMyComPtr<ICompressProgressInfo> progress = lps;
 566   lps->Init(updateCallback, true);
 567
 568   /////////////////////////////////////////
 569   // Write Copy Items
 570
 571   for(i = 0; i < folderRefs.Size(); i++)
 572   {
 573     int folderIndex = folderRefs[i];
 574
 575     lps->ProgressOffset = complexity;
 576     UInt64 packSize = database->GetFolderFullPackSize(folderIndex);
 577     RINOK(WriteRange(inStream, archive.SeqStream,
 578         database->GetFolderStreamPos(folderIndex, 0), packSize, progress));
 579     complexity += packSize;
 580
 581     const CFolder &folder = database->Folders[folderIndex];
 582     CNum startIndex = database->FolderStartPackStreamIndex[folderIndex];
 583     for (int j = 0; j < folder.PackStreams.Size(); j++)
 584     {
 585       newDatabase.PackSizes.Add(database->PackSizes[startIndex + j]);
 586       // newDatabase.PackCRCsDefined.Add(database.PackCRCsDefined[startIndex + j]);
 587       // newDatabase.PackCRCs.Add(database.PackCRCs[startIndex + j]);
 588     }
 589     newDatabase.Folders.Add(folder);
 590
 591     CNum numUnPackStreams = database->NumUnPackStreamsVector[folderIndex];
 592     newDatabase.NumUnPackStreamsVector.Add(numUnPackStreams);
 593
 594     CNum indexInFolder = 0;
 595     for (CNum fi = database->FolderStartFileIndex[folderIndex];
 596         indexInFolder < numUnPackStreams; fi++)
 597     {
 598       CFileItem file = database->Files[fi];
 599       if (file.HasStream)
 600       {
 601         indexInFolder++;
 602         int updateIndex = fileIndexToUpdateIndexMap[fi];
 603         if (updateIndex >= 0)
 604         {
 605           const CUpdateItem &updateItem = updateItems[updateIndex];
 606           if (updateItem.NewProperties)
 607           {
 608             CFileItem file2;
 609             FromUpdateItemToFileItem(updateItem, file2);
 610             file2.UnPackSize = file.UnPackSize;
 611             file2.FileCRC = file.FileCRC;
 612             file2.IsFileCRCDefined = file.IsFileCRCDefined;
 613             file2.HasStream = file.HasStream;
 614             file = file2;
 615           }
 616         }
 617         newDatabase.Files.Add(file);
 618       }
 619     }
 620   }
 621
 622   /////////////////////////////////////////
 623   // Compress New Files
 624
 625   CObjectVector<CSolidGroup> groups;
 626   SplitFilesToGroups(*options.Method, options.UseFilters, options.MaxFilter,
 627       updateItems, groups);
 628
 629   const UInt32 kMinReduceSize = (1 << 16);
 630   if (inSizeForReduce < kMinReduceSize)
 631     inSizeForReduce = kMinReduceSize;
 632
 633   for (int groupIndex = 0; groupIndex < groups.Size(); groupIndex++)
 634   {
 635     const CSolidGroup &group = groups[groupIndex];
 636     int numFiles = group.Indices.Size();
 637     if (numFiles == 0)
 638       continue;
 639     CRecordVector<CRefItem> refItems;
 640     refItems.Reserve(numFiles);
 641     bool sortByType = (numSolidFiles > 1);
 642     for (i = 0; i < numFiles; i++)
 643       refItems.Add(CRefItem(group.Indices[i], updateItems[group.Indices[i]], sortByType));
 644     refItems.Sort(CompareUpdateItems, (void *)&sortByType);
 645
 646     CRecordVector<UInt32> indices;
 647     indices.Reserve(numFiles);
 648
 649     for (i = 0; i < numFiles; i++)
 650     {
 651       UInt32 index = refItems[i].Index;
 652       indices.Add(index);
 653       /*
 654       const CUpdateItem &updateItem = updateItems[index];
 655       CFileItem file;
 656       if (updateItem.NewProperties)
 657         FromUpdateItemToFileItem(updateItem, file);
 658       else
 659         file = database.Files[updateItem.IndexInArchive];
 660       if (file.IsAnti || file.IsDirectory)
 661         return E_FAIL;
 662       newDatabase.Files.Add(file);
 663       */
 664     }
 665
 666     CEncoder encoder(group.Method);
 667
 668     for (i = 0; i < numFiles;)
 669     {
 670       UInt64 totalSize = 0;
 671       int numSubFiles;
 672       UString prevExtension;
 673       for (numSubFiles = 0; i + numSubFiles < numFiles &&
 674           numSubFiles < numSolidFiles; numSubFiles++)
 675       {
 676         const CUpdateItem &updateItem = updateItems[indices[i + numSubFiles]];
 677         totalSize += updateItem.Size;
 678         if (totalSize > options.NumSolidBytes)
 679           break;
 680         if (options.SolidExtension)
 681         {
 682           UString ext = updateItem.GetExtension();
 683           if (numSubFiles == 0)
 684             prevExtension = ext;
 685           else
 686             if (ext.CompareNoCase(prevExtension) != 0)
 687               break;
 688         }
 689       }
 690       if (numSubFiles < 1)
 691         numSubFiles = 1;
 692
 693       CFolderInStream *inStreamSpec = new CFolderInStream;
 694       CMyComPtr<ISequentialInStream> solidInStream(inStreamSpec);
 695       inStreamSpec->Init(updateCallback, &indices[i], numSubFiles);
 696
 697       CFolder folderItem;
 698
 699       int startPackIndex = newDatabase.PackSizes.Size();
 700       RINOK(encoder.Encode(
 701           EXTERNAL_CODECS_LOC_VARS
 702           solidInStream, NULL, &inSizeForReduce, folderItem,
 703           archive.SeqStream, newDatabase.PackSizes, progress));
 704
 705       for (; startPackIndex < newDatabase.PackSizes.Size(); startPackIndex++)
 706         lps->OutSize += newDatabase.PackSizes[startPackIndex];
 707
 708       lps->InSize += folderItem.GetUnPackSize();
 709       // for()
 710       // newDatabase.PackCRCsDefined.Add(false);
 711       // newDatabase.PackCRCs.Add(0);
 712
 713       newDatabase.Folders.Add(folderItem);
 714
 715       CNum numUnPackStreams = 0;
 716       for (int subIndex = 0; subIndex < numSubFiles; subIndex++)
 717       {
 718         const CUpdateItem &updateItem = updateItems[indices[i + subIndex]];
 719         CFileItem file;
 720         if (updateItem.NewProperties)
 721           FromUpdateItemToFileItem(updateItem, file);
 722         else
 723           file = database->Files[updateItem.IndexInArchive];
 724         if (file.IsAnti || file.IsDirectory)
 725           return E_FAIL;
 726
 727         /*
 728         CFileItem &file = newDatabase.Files[
 729               startFileIndexInDatabase + i + subIndex];
 730         */
 731         if (!inStreamSpec->Processed[subIndex])
 732         {
 733           continue;
 734           // file.Name += L".locked";
 735         }
 736
 737         file.FileCRC = inStreamSpec->CRCs[subIndex];
 738         file.UnPackSize = inStreamSpec->Sizes[subIndex];
 739         if (file.UnPackSize != 0)
 740         {
 741           file.IsFileCRCDefined = true;
 742           file.HasStream = true;
 743           numUnPackStreams++;
 744         }
 745         else
 746         {
 747           file.IsFileCRCDefined = false;
 748           file.HasStream = false;
 749         }
 750         newDatabase.Files.Add(file);
 751       }
 752       // numUnPackStreams = 0 is very bad case for locked files
 753       // v3.13 doesn't understand it.
 754       newDatabase.NumUnPackStreamsVector.Add(numUnPackStreams);
 755       i += numSubFiles;
 756     }
 757   }
 758
 759   {
 760     /////////////////////////////////////////
 761     // Write Empty Files & Folders
 762
 763     CRecordVector<int> emptyRefs;
 764     for(i = 0; i < updateItems.Size(); i++)
 765     {
 766       const CUpdateItem &updateItem = updateItems[i];
 767       if (updateItem.NewData)
 768       {
 769         if (updateItem.HasStream())
 770           continue;
 771       }
 772       else
 773         if (updateItem.IndexInArchive != -1)
 774           if (database->Files[updateItem.IndexInArchive].HasStream)
 775             continue;
 776       emptyRefs.Add(i);
 777     }
 778     emptyRefs.Sort(CompareEmptyItems, (void *)&updateItems);
 779     for(i = 0; i < emptyRefs.Size(); i++)
 780     {
 781       const CUpdateItem &updateItem = updateItems[emptyRefs[i]];
 782       CFileItem file;
 783       if (updateItem.NewProperties)
 784         FromUpdateItemToFileItem(updateItem, file);
 785       else
 786         file = database->Files[updateItem.IndexInArchive];
 787       newDatabase.Files.Add(file);
 788     }
 789   }
 790
 791   /*
 792   if (newDatabase.Files.Size() != updateItems.Size())
 793     return E_FAIL;
 794   */
 795
 796   return archive.WriteDatabase(EXTERNAL_CODECS_LOC_VARS
 797       newDatabase, options.HeaderMethod, options.HeaderOptions);
 798 }
 799
 800 #ifdef _7Z_VOL
 801
 802 static const UInt64 k_Copy = 0x0;
 803
 804 static HRESULT WriteVolumeHeader(COutArchive &archive, CFileItem &file, const CUpdateOptions &options)
 805 {
 806   CCoderInfo coder;
 807   coder.NumInStreams = coder.NumOutStreams = 1;
 808   coder.MethodID = k_Copy;
 809
 810   CFolder folder;
 811   folder.Coders.Add(coder);
 812   folder.PackStreams.Add(0);
 813
 814   CNum numUnPackStreams = 0;
 815   if (file.UnPackSize != 0)
 816   {
 817     file.IsFileCRCDefined = true;
 818     file.HasStream = true;
 819     numUnPackStreams++;
 820   }
 821   else
 822   {
 823     throw 1;
 824     file.IsFileCRCDefined = false;
 825     file.HasStream = false;
 826   }
 827   folder.UnPackSizes.Add(file.UnPackSize);
 828
 829   CArchiveDatabase newDatabase;
 830   newDatabase.Files.Add(file);
 831   newDatabase.Folders.Add(folder);
 832   newDatabase.NumUnPackStreamsVector.Add(numUnPackStreams);
 833   newDatabase.PackSizes.Add(file.UnPackSize);
 834   newDatabase.PackCRCsDefined.Add(false);
 835   newDatabase.PackCRCs.Add(file.FileCRC);
 836
 837   return archive.WriteDatabase(newDatabase,
 838       options.HeaderMethod,
 839       false,
 840       false);
 841 }
 842
 843 HRESULT UpdateVolume(
 844     IInStream *inStream,
 845     const CArchiveDatabaseEx *database,
 846     CObjectVector<CUpdateItem> &updateItems,
 847     ISequentialOutStream *seqOutStream,
 848     IArchiveUpdateCallback *updateCallback,
 849     const CUpdateOptions &options)
 850 {
 851   if (updateItems.Size() != 1)
 852     return E_NOTIMPL;
 853
 854   CMyComPtr<IArchiveUpdateCallback2> volumeCallback;
 855   RINOK(updateCallback->QueryInterface(IID_IArchiveUpdateCallback2, (void **)&volumeCallback));
 856   if (!volumeCallback)
 857     return E_NOTIMPL;
 858
 859   CMyComPtr<ISequentialInStream> fileStream;
 860   HRESULT result = updateCallback->GetStream(0, &fileStream);
 861   if (result != S_OK && result != S_FALSE)
 862     return result;
 863   if (result == S_FALSE)
 864     return E_FAIL;
 865
 866   CFileItem file;
 867
 868   const CUpdateItem &updateItem = updateItems[0];
 869   if (updateItem.NewProperties)
 870     FromUpdateItemToFileItem(updateItem, file);
 871   else
 872     file = database->Files[updateItem.IndexInArchive];
 873   if (file.IsAnti || file.IsDirectory)
 874     return E_FAIL;
 875
 876   UInt64 complexity = 0;
 877   file.IsStartPosDefined = true;
 878   file.StartPos = 0;
 879   for (UInt64 volumeIndex = 0; true; volumeIndex++)
 880   {
 881     UInt64 volSize;
 882     RINOK(volumeCallback->GetVolumeSize(volumeIndex, &volSize));
 883     UInt64 pureSize = COutArchive::GetVolPureSize(volSize, file.Name.Length(), true);
 884     CMyComPtr<ISequentialOutStream> volumeStream;
 885     RINOK(volumeCallback->GetVolumeStream(volumeIndex, &volumeStream));
 886
 887     COutArchive archive;
 888     RINOK(archive.Create(volumeStream, true));
 889     RINOK(archive.SkeepPrefixArchiveHeader());
 890
 891     CSequentialInStreamWithCRC *inCrcStreamSpec = new CSequentialInStreamWithCRC;
 892     CMyComPtr<ISequentialInStream> inCrcStream = inCrcStreamSpec;
 893     inCrcStreamSpec->Init(fileStream);
 894
 895     RINOK(WriteRange(inCrcStream, volumeStream, pureSize, updateCallback, complexity));
 896     file.UnPackSize = inCrcStreamSpec->GetSize();
 897     if (file.UnPackSize == 0)
 898       break;
 899     file.FileCRC = inCrcStreamSpec->GetCRC();
 900     RINOK(WriteVolumeHeader(archive, file, options));
 901     file.StartPos += file.UnPackSize;
 902     if (file.UnPackSize < pureSize)
 903       break;
 904   }
 905   return S_OK;
 906 }
 907
 908 class COutVolumeStream:
 909   public ISequentialOutStream,
 910   public CMyUnknownImp
 911 {
 912   int _volIndex;
 913   UInt64 _volSize;
 914   UInt64 _curPos;
 915   CMyComPtr<ISequentialOutStream> _volumeStream;
 916   COutArchive _archive;
 917   CCRC _crc;
 918
 919 public:
 920   MY_UNKNOWN_IMP
 921
 922   CFileItem _file;
 923   CUpdateOptions _options;
 924   CMyComPtr<IArchiveUpdateCallback2> VolumeCallback;
 925   void Init(IArchiveUpdateCallback2 *volumeCallback,
 926       const UString &name)
 927   {
 928     _file.Name = name;
 929     _file.IsStartPosDefined = true;
 930     _file.StartPos = 0;
 931
 932     VolumeCallback = volumeCallback;
 933     _volIndex = 0;
 934     _volSize = 0;
 935   }
 936
 937   HRESULT Flush();
 938   STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize);
 939 };
 940
 941 HRESULT COutVolumeStream::Flush()
 942 {
 943   if (_volumeStream)
 944   {
 945     _file.UnPackSize = _curPos;
 946     _file.FileCRC = _crc.GetDigest();
 947     RINOK(WriteVolumeHeader(_archive, _file, _options));
 948     _archive.Close();
 949     _volumeStream.Release();
 950     _file.StartPos += _file.UnPackSize;
 951   }
 952   return S_OK;
 953 }
 954
 955 STDMETHODIMP COutVolumeStream::Write(const void *data, UInt32 size, UInt32 *processedSize)
 956 {
 957   if(processedSize != NULL)
 958     *processedSize = 0;
 959   while(size > 0)
 960   {
 961     if (!_volumeStream)
 962     {
 963       RINOK(VolumeCallback->GetVolumeSize(_volIndex, &_volSize));
 964       RINOK(VolumeCallback->GetVolumeStream(_volIndex, &_volumeStream));
 965       _volIndex++;
 966       _curPos = 0;
 967       RINOK(_archive.Create(_volumeStream, true));
 968       RINOK(_archive.SkeepPrefixArchiveHeader());
 969       _crc.Init();
 970       continue;
 971     }
 972     UInt64 pureSize = COutArchive::GetVolPureSize(_volSize, _file.Name.Length());
 973     UInt32 curSize = (UInt32)MyMin(UInt64(size), pureSize - _curPos);
 974
 975     _crc.Update(data, curSize);
 976     UInt32 realProcessed;
 977     RINOK(_volumeStream->Write(data, curSize, &realProcessed))
 978     data = (void *)((Byte *)data + realProcessed);
 979     size -= realProcessed;
 980     if(processedSize != NULL)
 981       *processedSize += realProcessed;
 982     _curPos += realProcessed;
 983     if (realProcessed != curSize && realProcessed == 0)
 984       return E_FAIL;
 985     if (_curPos == pureSize)
 986     {
 987       RINOK(Flush());
 988     }
 989   }
 990   return S_OK;
 991 }
 992
 993 #endif
 994
 995 HRESULT Update(
 996     DECL_EXTERNAL_CODECS_LOC_VARS
 997     IInStream *inStream,
 998     const CArchiveDatabaseEx *database,
 999     const CObjectVector<CUpdateItem> &updateItems,
1000     ISequentialOutStream *seqOutStream,
1001     IArchiveUpdateCallback *updateCallback,
1002     const CUpdateOptions &options)
1003 {
1004   #ifdef _7Z_VOL
1005   if (seqOutStream)
1006   #endif
1007     return Update2(
1008         EXTERNAL_CODECS_LOC_VARS
1009         inStream, database, updateItems,
1010         seqOutStream, updateCallback, options);
1011   #ifdef _7Z_VOL
1012   if (options.VolumeMode)
1013     return UpdateVolume(inStream, database, updateItems,
1014       seqOutStream, updateCallback, options);
1015   COutVolumeStream *volStreamSpec = new COutVolumeStream;
1016   CMyComPtr<ISequentialOutStream> volStream = volStreamSpec;
1017   CMyComPtr<IArchiveUpdateCallback2> volumeCallback;
1018   RINOK(updateCallback->QueryInterface(IID_IArchiveUpdateCallback2, (void **)&volumeCallback));
1019   if (!volumeCallback)
1020     return E_NOTIMPL;
1021   volStreamSpec->Init(volumeCallback, L"a.7z");
1022   volStreamSpec->_options = options;
1023   RINOK(Update2(inStream, database, updateItems,
1024     volStream, updateCallback, options));
1025   return volStreamSpec->Flush();
1026   #endif
1027 }
1028
1029 }}