seven-zip 1.4.1 → 1.7.0.rc1

data/ext/p7zip/CPP/7zip/Archive/7z/7zOut.cpp

@@ -10,35 +10,15 @@
 
 #include "7zOut.h"
 
-static HRESULT WriteBytes(ISequentialOutStream *stream, const void *data, size_t size)
-{
-  while (size > 0)
-  {
-    UInt32 curSize = (UInt32)MyMin(size, (size_t)0xFFFFFFFF);
-    UInt32 processedSize;
-    RINOK(stream->Write(data, curSize, &processedSize));
-    if (processedSize == 0)
-      return E_FAIL;
-    data = (const void *)((const Byte *)data + processedSize);
-    size -= processedSize;
-  }
-  return S_OK;
-}
-
 namespace NArchive {
 namespace N7z {
 
-HRESULT COutArchive::WriteDirect(const void *data, UInt32 size)
-{
-  return ::WriteBytes(SeqStream, data, size);
-}
-
 HRESULT COutArchive::WriteSignature()
 {
   Byte buf[8];
   memcpy(buf, kSignature, kSignatureSize);
   buf[kSignatureSize] = kMajorVersion;
-  buf[kSignatureSize + 1] = 3;
+  buf[kSignatureSize + 1] = 4;
   return WriteDirect(buf, 8);
 }
 
@@ -145,7 +125,9 @@ HRESULT COutArchive::SkipPrefixArchiveHeader()
   if (_endMarker)
     return S_OK;
   #endif
-  return Stream->Seek(24, STREAM_SEEK_CUR, NULL);
+  Byte buf[24];
+  memset(buf, 0, 24);
+  return WriteDirect(buf, 24);
 }
 
 UInt64 COutArchive::GetPos() const
@@ -217,7 +199,7 @@ void COutArchive::WriteNumber(UInt64 value)
     mask >>= 1;
   }
   WriteByte(firstByte);
-  for (;i > 0; i--)
+  for (; i > 0; i--)
   {
     WriteByte((Byte)value);
     value >>= 8;
@@ -271,32 +253,34 @@ UInt64 COutArchive::GetVolPureSize(UInt64 volSize, int nameLength, bool props)
 void COutArchive::WriteFolder(const CFolder &folder)
 {
   WriteNumber(folder.Coders.Size());
-  int i;
+  unsigned i;
+  
   for (i = 0; i < folder.Coders.Size(); i++)
   {
     const CCoderInfo &coder = folder.Coders[i];
     {
-      size_t propsSize = coder.Props.GetCapacity();
-      
       UInt64 id = coder.MethodID;
-      int idSize;
+      unsigned idSize;
       for (idSize = 1; idSize < sizeof(id); idSize++)
         if ((id >> (8 * idSize)) == 0)
           break;
-      BYTE longID[15];
-      for (int t = idSize - 1; t >= 0 ; t--, id >>= 8)
-        longID[t] = (Byte)(id & 0xFF);
-      Byte b;
-      b = (Byte)(idSize & 0xF);
+      idSize &= 0xF;
+      Byte temp[16];
+      for (unsigned t = idSize; t != 0; t--, id >>= 8)
+        temp[t] = (Byte)(id & 0xFF);
+  
+      Byte b = (Byte)(idSize);
       bool isComplex = !coder.IsSimpleCoder();
       b |= (isComplex ? 0x10 : 0);
-      b |= ((propsSize != 0) ? 0x20 : 0 );
-      WriteByte(b);
-      WriteBytes(longID, idSize);
+
+      size_t propsSize = coder.Props.Size();
+      b |= ((propsSize != 0) ? 0x20 : 0);
+      temp[0] = b;
+      WriteBytes(temp, idSize + 1);
       if (isComplex)
       {
-        WriteNumber(coder.NumInStreams);
-        WriteNumber(coder.NumOutStreams);
+        WriteNumber(coder.NumStreams);
+        WriteNumber(1); // NumOutStreams;
       }
       if (propsSize == 0)
         continue;
@@ -304,24 +288,24 @@ void COutArchive::WriteFolder(const CFolder &folder)
       WriteBytes(coder.Props, propsSize);
     }
   }
-  for (i = 0; i < folder.BindPairs.Size(); i++)
+  
+  for (i = 0; i < folder.Bonds.Size(); i++)
   {
-    const CBindPair &bindPair = folder.BindPairs[i];
-    WriteNumber(bindPair.InIndex);
-    WriteNumber(bindPair.OutIndex);
+    const CBond &bond = folder.Bonds[i];
+    WriteNumber(bond.PackIndex);
+    WriteNumber(bond.UnpackIndex);
   }
+  
   if (folder.PackStreams.Size() > 1)
     for (i = 0; i < folder.PackStreams.Size(); i++)
-    {
       WriteNumber(folder.PackStreams[i]);
-    }
 }
 
 void COutArchive::WriteBoolVector(const CBoolVector &boolVector)
 {
   Byte b = 0;
   Byte mask = 0x80;
-  for (int i = 0; i < boolVector.Size(); i++)
+  FOR_VECTOR (i, boolVector)
   {
     if (boolVector[i])
       b |= mask;
@@ -337,37 +321,42 @@ void COutArchive::WriteBoolVector(const CBoolVector &boolVector)
     WriteByte(b);
 }
 
+static inline unsigned Bv_GetSizeInBytes(const CBoolVector &v) { return ((unsigned)v.Size() + 7) / 8; }
 
-void COutArchive::WriteHashDigests(
-    const CRecordVector<bool> &digestsDefined,
-    const CRecordVector<UInt32> &digests)
+void COutArchive::WritePropBoolVector(Byte id, const CBoolVector &boolVector)
 {
-  int numDefined = 0;
-  int i;
-  for (i = 0; i < digestsDefined.Size(); i++)
-    if (digestsDefined[i])
+  WriteByte(id);
+  WriteNumber(Bv_GetSizeInBytes(boolVector));
+  WriteBoolVector(boolVector);
+}
+
+void COutArchive::WriteHashDigests(const CUInt32DefVector &digests)
+{
+  unsigned numDefined = 0;
+  unsigned i;
+  for (i = 0; i < digests.Defs.Size(); i++)
+    if (digests.Defs[i])
       numDefined++;
   if (numDefined == 0)
     return;
 
   WriteByte(NID::kCRC);
-  if (numDefined == digestsDefined.Size())
+  if (numDefined == digests.Defs.Size())
     WriteByte(1);
   else
   {
     WriteByte(0);
-    WriteBoolVector(digestsDefined);
+    WriteBoolVector(digests.Defs);
   }
-  for (i = 0; i < digests.Size(); i++)
-    if (digestsDefined[i])
-      WriteUInt32(digests[i]);
+  for (i = 0; i < digests.Defs.Size(); i++)
+    if (digests.Defs[i])
+      WriteUInt32(digests.Vals[i]);
 }
 
 void COutArchive::WritePackInfo(
     UInt64 dataOffset,
     const CRecordVector<UInt64> &packSizes,
-    const CRecordVector<bool> &packCRCsDefined,
-    const CRecordVector<UInt32> &packCRCs)
+    const CUInt32DefVector &packCRCs)
 {
   if (packSizes.IsEmpty())
     return;
@@ -375,15 +364,15 @@ void COutArchive::WritePackInfo(
   WriteNumber(dataOffset);
   WriteNumber(packSizes.Size());
   WriteByte(NID::kSize);
-  for (int i = 0; i < packSizes.Size(); i++)
+  FOR_VECTOR (i, packSizes)
     WriteNumber(packSizes[i]);
 
-  WriteHashDigests(packCRCsDefined, packCRCs);
+  WriteHashDigests(packCRCs);
   
   WriteByte(NID::kEnd);
 }
 
-void COutArchive::WriteUnpackInfo(const CObjectVector<CFolder> &folders)
+void COutArchive::WriteUnpackInfo(const CObjectVector<CFolder> &folders, const COutFolders &outFolders)
 {
   if (folders.IsEmpty())
     return;
@@ -394,44 +383,29 @@ void COutArchive::WriteUnpackInfo(const CObjectVector<CFolder> &folders)
   WriteNumber(folders.Size());
   {
     WriteByte(0);
-    for (int i = 0; i < folders.Size(); i++)
+    FOR_VECTOR (i, folders)
       WriteFolder(folders[i]);
   }
   
   WriteByte(NID::kCodersUnpackSize);
-  int i;
-  for (i = 0; i < folders.Size(); i++)
-  {
-    const CFolder &folder = folders[i];
-    for (int j = 0; j < folder.UnpackSizes.Size(); j++)
-      WriteNumber(folder.UnpackSizes[j]);
-  }
-
-  CRecordVector<bool> unpackCRCsDefined;
-  CRecordVector<UInt32> unpackCRCs;
-  for (i = 0; i < folders.Size(); i++)
-  {
-    const CFolder &folder = folders[i];
-    unpackCRCsDefined.Add(folder.UnpackCRCDefined);
-    unpackCRCs.Add(folder.UnpackCRC);
-  }
-  WriteHashDigests(unpackCRCsDefined, unpackCRCs);
-
+  FOR_VECTOR (i, outFolders.CoderUnpackSizes)
+    WriteNumber(outFolders.CoderUnpackSizes[i]);
+  
+  WriteHashDigests(outFolders.FolderUnpackCRCs);
+  
   WriteByte(NID::kEnd);
 }
 
-void COutArchive::WriteSubStreamsInfo(
-    const CObjectVector<CFolder> &folders,
-    const CRecordVector<CNum> &numUnpackStreamsInFolders,
+void COutArchive::WriteSubStreamsInfo(const CObjectVector<CFolder> &folders,
+    const COutFolders &outFolders,
     const CRecordVector<UInt64> &unpackSizes,
-    const CRecordVector<bool> &digestsDefined,
-    const CRecordVector<UInt32> &digests)
+    const CUInt32DefVector &digests)
 {
+  const CRecordVector<CNum> &numUnpackStreamsInFolders = outFolders.NumUnpackStreamsVector;
   WriteByte(NID::kSubStreamsInfo);
 
-  int i;
+  unsigned i;
   for (i = 0; i < numUnpackStreamsInFolders.Size(); i++)
-  {
     if (numUnpackStreamsInFolders[i] != 1)
     {
       WriteByte(NID::kNumUnpackStream);
@@ -439,54 +413,50 @@ void COutArchive::WriteSubStreamsInfo(
         WriteNumber(numUnpackStreamsInFolders[i]);
       break;
     }
-  }
  
-
-  bool needFlag = true;
-  CNum index = 0;
   for (i = 0; i < numUnpackStreamsInFolders.Size(); i++)
-    for (CNum j = 0; j < numUnpackStreamsInFolders[i]; j++)
+    if (numUnpackStreamsInFolders[i] > 1)
     {
-      if (j + 1 != numUnpackStreamsInFolders[i])
+      WriteByte(NID::kSize);
+      CNum index = 0;
+      for (i = 0; i < numUnpackStreamsInFolders.Size(); i++)
       {
-        if (needFlag)
-          WriteByte(NID::kSize);
-        needFlag = false;
-        WriteNumber(unpackSizes[index]);
+        CNum num = numUnpackStreamsInFolders[i];
+        for (CNum j = 0; j < num; j++)
+        {
+          if (j + 1 != num)
+            WriteNumber(unpackSizes[index]);
+          index++;
+        }
       }
-      index++;
+      break;
     }
 
-  CRecordVector<bool> digestsDefined2;
-  CRecordVector<UInt32> digests2;
+  CUInt32DefVector digests2;
 
-  int digestIndex = 0;
+  unsigned digestIndex = 0;
   for (i = 0; i < folders.Size(); i++)
   {
-    int numSubStreams = (int)numUnpackStreamsInFolders[i];
-    if (numSubStreams == 1 && folders[i].UnpackCRCDefined)
+    unsigned numSubStreams = (unsigned)numUnpackStreamsInFolders[i];
+    if (numSubStreams == 1 && outFolders.FolderUnpackCRCs.ValidAndDefined(i))
       digestIndex++;
     else
-      for (int j = 0; j < numSubStreams; j++, digestIndex++)
+      for (unsigned j = 0; j < numSubStreams; j++, digestIndex++)
       {
-        digestsDefined2.Add(digestsDefined[digestIndex]);
-        digests2.Add(digests[digestIndex]);
+        digests2.Defs.Add(digests.Defs[digestIndex]);
+        digests2.Vals.Add(digests.Vals[digestIndex]);
       }
   }
-  WriteHashDigests(digestsDefined2, digests2);
+  WriteHashDigests(digests2);
   WriteByte(NID::kEnd);
 }
 
-void COutArchive::SkipAlign(unsigned /* pos */, unsigned /* alignSize */)
-{
-  return;
-}
-
-/*
-7-Zip 4.50 - 4.58 contain BUG, so they do not support .7z archives with Unknown field.
+// 7-Zip 4.50 - 4.58 contain BUG, so they do not support .7z archives with Unknown field.
 
 void COutArchive::SkipAlign(unsigned pos, unsigned alignSize)
 {
+  if (!_useAlign)
+    return;
   pos += (unsigned)GetPos();
   pos &= (alignSize - 1);
   if (pos == 0)
@@ -500,11 +470,8 @@ void COutArchive::SkipAlign(unsigned pos, unsigned alignSize)
   for (unsigned i = 0; i < skip; i++)
     WriteByte(0);
 }
-*/
-
-static inline unsigned Bv_GetSizeInBytes(const CBoolVector &v) { return ((unsigned)v.Size() + 7) / 8; }
 
-void COutArchive::WriteAlignedBoolHeader(const CBoolVector &v, int numDefined, Byte type, unsigned itemSize)
+void COutArchive::WriteAlignedBoolHeader(const CBoolVector &v, unsigned numDefined, Byte type, unsigned itemSize)
 {
   const unsigned bvSize = (numDefined == v.Size()) ? 0 : Bv_GetSizeInBytes(v);
   const UInt64 dataSize = (UInt64)numDefined * itemSize + bvSize + 2;
@@ -524,54 +491,62 @@ void COutArchive::WriteAlignedBoolHeader(const CBoolVector &v, int numDefined, B
 
 void COutArchive::WriteUInt64DefVector(const CUInt64DefVector &v, Byte type)
 {
-  int numDefined = 0;
+  unsigned numDefined = 0;
 
-  int i;
-  for (i = 0; i < v.Defined.Size(); i++)
-    if (v.Defined[i])
+  unsigned i;
+  for (i = 0; i < v.Defs.Size(); i++)
+    if (v.Defs[i])
       numDefined++;
 
   if (numDefined == 0)
     return;
 
-  WriteAlignedBoolHeader(v.Defined, numDefined, type, 8);
+  WriteAlignedBoolHeader(v.Defs, numDefined, type, 8);
   
-  for (i = 0; i < v.Defined.Size(); i++)
-    if (v.Defined[i])
-      WriteUInt64(v.Values[i]);
+  for (i = 0; i < v.Defs.Size(); i++)
+    if (v.Defs[i])
+      WriteUInt64(v.Vals[i]);
 }
 
 HRESULT COutArchive::EncodeStream(
     DECL_EXTERNAL_CODECS_LOC_VARS
     CEncoder &encoder, const CByteBuffer &data,
-    CRecordVector<UInt64> &packSizes, CObjectVector<CFolder> &folders)
+    CRecordVector<UInt64> &packSizes, CObjectVector<CFolder> &folders, COutFolders &outFolders)
 {
   CBufInStream *streamSpec = new CBufInStream;
   CMyComPtr<ISequentialInStream> stream = streamSpec;
-  streamSpec->Init(data, data.GetCapacity());
-  CFolder folderItem;
-  folderItem.UnpackCRCDefined = true;
-  folderItem.UnpackCRC = CrcCalc(data, data.GetCapacity());
-  UInt64 dataSize64 = data.GetCapacity();
+  streamSpec->Init(data, data.Size());
+  outFolders.FolderUnpackCRCs.Defs.Add(true);
+  outFolders.FolderUnpackCRCs.Vals.Add(CrcCalc(data, data.Size()));
+  // outFolders.NumUnpackStreamsVector.Add(1);
+  UInt64 dataSize64 = data.Size();
+  UInt64 unpackSize;
   RINOK(encoder.Encode(
       EXTERNAL_CODECS_LOC_VARS
-      stream, NULL, &dataSize64, folderItem, SeqStream, packSizes, NULL))
-  folders.Add(folderItem);
+      stream,
+      // NULL,
+      &dataSize64,
+      folders.AddNew(), outFolders.CoderUnpackSizes, unpackSize, SeqStream, packSizes, NULL))
   return S_OK;
 }
 
 void COutArchive::WriteHeader(
-    const CArchiveDatabase &db,
-    const CHeaderOptions &headerOptions,
+    const CArchiveDatabaseOut &db,
+    // const CHeaderOptions &headerOptions,
     UInt64 &headerOffset)
 {
-  int i;
-  
-  UInt64 packedSize = 0;
-  for (i = 0; i < db.PackSizes.Size(); i++)
-    packedSize += db.PackSizes[i];
+  /*
+  bool thereIsSecure = (db.SecureBuf.Size() != 0);
+  */
+  _useAlign = true;
+
+  {
+    UInt64 packSize = 0;
+    FOR_VECTOR (i, db.PackSizes)
+      packSize += db.PackSizes[i];
+    headerOffset = packSize;
+  }
 
-  headerOffset = packedSize;
 
   WriteByte(NID::kHeader);
 
@@ -580,31 +555,22 @@ void COutArchive::WriteHeader(
   if (db.Folders.Size() > 0)
   {
     WriteByte(NID::kMainStreamsInfo);
-    WritePackInfo(0, db.PackSizes,
-        db.PackCRCsDefined,
-        db.PackCRCs);
-
-    WriteUnpackInfo(db.Folders);
+    WritePackInfo(0, db.PackSizes, db.PackCRCs);
+    WriteUnpackInfo(db.Folders, (const COutFolders &)db);
 
     CRecordVector<UInt64> unpackSizes;
-    CRecordVector<bool> digestsDefined;
-    CRecordVector<UInt32> digests;
-    for (i = 0; i < db.Files.Size(); i++)
+    CUInt32DefVector digests;
+    FOR_VECTOR (i, db.Files)
     {
       const CFileItem &file = db.Files[i];
       if (!file.HasStream)
         continue;
       unpackSizes.Add(file.Size);
-      digestsDefined.Add(file.CrcDefined);
-      digests.Add(file.Crc);
+      digests.Defs.Add(file.CrcDefined);
+      digests.Vals.Add(file.Crc);
     }
 
-    WriteSubStreamsInfo(
-        db.Folders,
-        db.NumUnpackStreamsVector,
-        unpackSizes,
-        digestsDefined,
-        digests);
+    WriteSubStreamsInfo(db.Folders, (const COutFolders &)db, unpackSizes, digests);
     WriteByte(NID::kEnd);
   }
 
@@ -618,85 +584,79 @@ void COutArchive::WriteHeader(
   WriteNumber(db.Files.Size());
 
   {
-  /* ---------- Empty Streams ---------- */
-  CBoolVector emptyStreamVector;
-  emptyStreamVector.Reserve(db.Files.Size());
-  int numEmptyStreams = 0;
-  for (i = 0; i < db.Files.Size(); i++)
-    if (db.Files[i].HasStream)
-      emptyStreamVector.Add(false);
-    else
+    /* ---------- Empty Streams ---------- */
+    CBoolVector emptyStreamVector;
+    emptyStreamVector.ClearAndSetSize(db.Files.Size());
+    unsigned numEmptyStreams = 0;
     {
-      emptyStreamVector.Add(true);
-      numEmptyStreams++;
+      FOR_VECTOR (i, db.Files)
+        if (db.Files[i].HasStream)
+          emptyStreamVector[i] = false;
+        else
+        {
+          emptyStreamVector[i] = true;
+          numEmptyStreams++;
+        }
     }
-  if (numEmptyStreams > 0)
-  {
-    WriteByte(NID::kEmptyStream);
-    WriteNumber(Bv_GetSizeInBytes(emptyStreamVector));
-    WriteBoolVector(emptyStreamVector);
-
-    CBoolVector emptyFileVector, antiVector;
-    emptyFileVector.Reserve(numEmptyStreams);
-    antiVector.Reserve(numEmptyStreams);
-    CNum numEmptyFiles = 0, numAntiItems = 0;
-    for (i = 0; i < db.Files.Size(); i++)
+
+    if (numEmptyStreams != 0)
     {
-      const CFileItem &file = db.Files[i];
-      if (!file.HasStream)
+      WritePropBoolVector(NID::kEmptyStream, emptyStreamVector);
+      
+      CBoolVector emptyFileVector, antiVector;
+      emptyFileVector.ClearAndSetSize(numEmptyStreams);
+      antiVector.ClearAndSetSize(numEmptyStreams);
+      bool thereAreEmptyFiles = false, thereAreAntiItems = false;
+      unsigned cur = 0;
+      
+      FOR_VECTOR (i, db.Files)
       {
-        emptyFileVector.Add(!file.IsDir);
+        const CFileItem &file = db.Files[i];
+        if (file.HasStream)
+          continue;
+        emptyFileVector[cur] = !file.IsDir;
         if (!file.IsDir)
-          numEmptyFiles++;
+          thereAreEmptyFiles = true;
         bool isAnti = db.IsItemAnti(i);
-        antiVector.Add(isAnti);
+        antiVector[cur] = isAnti;
         if (isAnti)
-          numAntiItems++;
+          thereAreAntiItems = true;
+        cur++;
       }
-    }
-
-    if (numEmptyFiles > 0)
-    {
-      WriteByte(NID::kEmptyFile);
-      WriteNumber(Bv_GetSizeInBytes(emptyFileVector));
-      WriteBoolVector(emptyFileVector);
-    }
-
-    if (numAntiItems > 0)
-    {
-      WriteByte(NID::kAnti);
-      WriteNumber(Bv_GetSizeInBytes(antiVector));
-      WriteBoolVector(antiVector);
+      
+      if (thereAreEmptyFiles)
+        WritePropBoolVector(NID::kEmptyFile, emptyFileVector);
+      if (thereAreAntiItems)
+        WritePropBoolVector(NID::kAnti, antiVector);
     }
   }
-  }
 
 
   {
     /* ---------- Names ---------- */
     
-    int numDefined = 0;
+    unsigned numDefined = 0;
     size_t namesDataSize = 0;
-    for (int i = 0; i < db.Files.Size(); i++)
+    FOR_VECTOR (i, db.Files)
     {
-      const UString &name = db.Files[i].Name;
+      const UString &name = db.Names[i];
       if (!name.IsEmpty())
         numDefined++;
-      namesDataSize += (name.Length() + 1) * 2;
+      namesDataSize += (name.Len() + 1) * 2;
     }
     
     if (numDefined > 0)
     {
       namesDataSize++;
-      SkipAlign(2 + GetBigNumberSize(namesDataSize), 2);
+      SkipAlign(2 + GetBigNumberSize(namesDataSize), 16);
 
       WriteByte(NID::kName);
       WriteNumber(namesDataSize);
       WriteByte(0);
-      for (int i = 0; i < db.Files.Size(); i++)
+      FOR_VECTOR (i, db.Files)
       {
-        const UString &name = db.Files[i].Name;
-        for (int t = 0; t <= name.Length(); t++)
+        const UString &name = db.Names[i];
+        for (unsigned t = 0; t <= name.Len(); t++)
         {
           wchar_t c = name[t];
           WriteByte((Byte)c);
@@ -706,42 +666,128 @@ void COutArchive::WriteHeader(
     }
   }
 
-  if (headerOptions.WriteCTime) WriteUInt64DefVector(db.CTime, NID::kCTime);
-  if (headerOptions.WriteATime) WriteUInt64DefVector(db.ATime, NID::kATime);
-  if (headerOptions.WriteMTime) WriteUInt64DefVector(db.MTime, NID::kMTime);
+  /* if (headerOptions.WriteCTime) */ WriteUInt64DefVector(db.CTime, NID::kCTime);
+  /* if (headerOptions.WriteATime) */ WriteUInt64DefVector(db.ATime, NID::kATime);
+  /* if (headerOptions.WriteMTime) */ WriteUInt64DefVector(db.MTime, NID::kMTime);
   WriteUInt64DefVector(db.StartPos, NID::kStartPos);
   
   {
     /* ---------- Write Attrib ---------- */
     CBoolVector boolVector;
+    boolVector.ClearAndSetSize(db.Files.Size());
+    unsigned numDefined = 0;
+    
+    {
+      FOR_VECTOR (i, db.Files)
+      {
+        bool defined = db.Files[i].AttribDefined;
+        boolVector[i] = defined;
+        if (defined)
+          numDefined++;
+      }
+    }
+    
+    if (numDefined != 0)
+    {
+      WriteAlignedBoolHeader(boolVector, numDefined, NID::kWinAttrib, 4);
+      FOR_VECTOR (i, db.Files)
+      {
+        const CFileItem &file = db.Files[i];
+        if (file.AttribDefined)
+          WriteUInt32(file.Attrib);
+      }
+    }
+  }
+
+  /*
+  {
+    // ---------- Write IsAux ----------
+    unsigned numAux = 0;
+    const CBoolVector &isAux = db.IsAux;
+    for (i = 0; i < isAux.Size(); i++)
+      if (isAux[i])
+        numAux++;
+    if (numAux > 0)
+    {
+      const unsigned bvSize = Bv_GetSizeInBytes(isAux);
+      WriteByte(NID::kIsAux);
+      WriteNumber(bvSize);
+      WriteBoolVector(isAux);
+    }
+  }
+
+  {
+    // ---------- Write Parent ----------
+    CBoolVector boolVector;
     boolVector.Reserve(db.Files.Size());
-    int numDefined = 0;
+    unsigned numIsDir = 0;
+    unsigned numParentLinks = 0;
     for (i = 0; i < db.Files.Size(); i++)
     {
-      bool defined = db.Files[i].AttribDefined;
+      const CFileItem &file = db.Files[i];
+      bool defined = !file.IsAltStream;
       boolVector.Add(defined);
       if (defined)
-        numDefined++;
+        numIsDir++;
+      if (file.Parent >= 0)
+        numParentLinks++;
     }
-    if (numDefined > 0)
+    if (numParentLinks > 0)
     {
-      WriteAlignedBoolHeader(boolVector, numDefined, NID::kWinAttributes, 4);
+      // WriteAlignedBoolHeader(boolVector, numDefined, NID::kParent, 4);
+      const unsigned bvSize = (numIsDir == boolVector.Size()) ? 0 : Bv_GetSizeInBytes(boolVector);
+      const UInt64 dataSize = (UInt64)db.Files.Size() * 4 + bvSize + 1;
+      SkipAlign(2 + (unsigned)bvSize + (unsigned)GetBigNumberSize(dataSize), 4);
+      
+      WriteByte(NID::kParent);
+      WriteNumber(dataSize);
+      if (numIsDir == boolVector.Size())
+        WriteByte(1);
+      else
+      {
+        WriteByte(0);
+        WriteBoolVector(boolVector);
+      }
       for (i = 0; i < db.Files.Size(); i++)
       {
         const CFileItem &file = db.Files[i];
-        if (file.AttribDefined)
-          WriteUInt32(file.Attrib);
+        // if (file.Parent >= 0)
+          WriteUInt32(file.Parent);
       }
     }
   }
 
+  if (thereIsSecure)
+  {
+    UInt64 secureDataSize = 1 + 4 +
+       db.SecureBuf.Size() +
+       db.SecureSizes.Size() * 4;
+    // secureDataSize += db.SecureIDs.Size() * 4;
+    for (i = 0; i < db.SecureIDs.Size(); i++)
+      secureDataSize += GetBigNumberSize(db.SecureIDs[i]);
+    SkipAlign(2 + GetBigNumberSize(secureDataSize), 4);
+    WriteByte(NID::kNtSecure);
+    WriteNumber(secureDataSize);
+    WriteByte(0);
+    WriteUInt32(db.SecureSizes.Size());
+    for (i = 0; i < db.SecureSizes.Size(); i++)
+      WriteUInt32(db.SecureSizes[i]);
+    WriteBytes(db.SecureBuf, db.SecureBuf.Size());
+    for (i = 0; i < db.SecureIDs.Size(); i++)
+    {
+      WriteNumber(db.SecureIDs[i]);
+      // WriteUInt32(db.SecureIDs[i]);
+    }
+  }
+  */
+
   WriteByte(NID::kEnd); // for files
   WriteByte(NID::kEnd); // for headers
 }
 
 HRESULT COutArchive::WriteDatabase(
     DECL_EXTERNAL_CODECS_LOC_VARS
-    const CArchiveDatabase &db,
+    const CArchiveDatabaseOut &db,
     const CCompressionMethodMode *options,
     const CHeaderOptions &headerOptions)
 {
@@ -773,17 +819,16 @@ HRESULT COutArchive::WriteDatabase(
     _countMode = encodeHeaders;
     _writeToStream = true;
     _countSize = 0;
-    WriteHeader(db, headerOptions, headerOffset);
+    WriteHeader(db, /* headerOptions, */ headerOffset);
 
     if (encodeHeaders)
     {
-      CByteBuffer buf;
-      buf.SetCapacity(_countSize);
+      CByteBuffer buf(_countSize);
       _outByte2.Init((Byte *)buf, _countSize);
       
       _countMode = false;
       _writeToStream = false;
-      WriteHeader(db, headerOptions, headerOffset);
+      WriteHeader(db, /* headerOptions, */ headerOffset);
       
       if (_countSize != _outByte2.GetPos())
         return E_FAIL;
@@ -794,10 +839,12 @@ HRESULT COutArchive::WriteDatabase(
       CEncoder encoder(headerOptions.CompressMainHeader ? *options : encryptOptions);
       CRecordVector<UInt64> packSizes;
       CObjectVector<CFolder> folders;
+      COutFolders outFolders;
+
       RINOK(EncodeStream(
           EXTERNAL_CODECS_LOC_VARS
           encoder, buf,
-          packSizes, folders));
+          packSizes, folders, outFolders));
 
       _writeToStream = true;
       
@@ -805,11 +852,10 @@ HRESULT COutArchive::WriteDatabase(
         throw 1;
 
       WriteID(NID::kEncodedHeader);
-      WritePackInfo(headerOffset, packSizes,
-        CRecordVector<bool>(), CRecordVector<UInt32>());
-      WriteUnpackInfo(folders);
+      WritePackInfo(headerOffset, packSizes, CUInt32DefVector());
+      WriteUnpackInfo(folders, outFolders);
       WriteByte(NID::kEnd);
-      for (int i = 0; i < packSizes.Size(); i++)
+      FOR_VECTOR (i, packSizes)
         headerOffset += packSizes[i];
     }
     RINOK(_outByte.Flush());
@@ -842,24 +888,28 @@ HRESULT COutArchive::WriteDatabase(
   }
 }
 
-void CArchiveDatabase::GetFile(int index, CFileItem &file, CFileItem2 &file2) const
+void CUInt64DefVector::SetItem(unsigned index, bool defined, UInt64 value)
 {
-  file = Files[index];
-  file2.CTimeDefined = CTime.GetItem(index, file2.CTime);
-  file2.ATimeDefined = ATime.GetItem(index, file2.ATime);
-  file2.MTimeDefined = MTime.GetItem(index, file2.MTime);
-  file2.StartPosDefined = StartPos.GetItem(index, file2.StartPos);
-  file2.IsAnti = IsItemAnti(index);
+  while (index >= Defs.Size())
+    Defs.Add(false);
+  Defs[index] = defined;
+  if (!defined)
+    return;
+  while (index >= Vals.Size())
+    Vals.Add(0);
+  Vals[index] = value;
 }
 
-void CArchiveDatabase::AddFile(const CFileItem &file, const CFileItem2 &file2)
+void CArchiveDatabaseOut::AddFile(const CFileItem &file, const CFileItem2 &file2, const UString &name)
 {
-  int index = Files.Size();
+  unsigned index = Files.Size();
   CTime.SetItem(index, file2.CTimeDefined, file2.CTime);
   ATime.SetItem(index, file2.ATimeDefined, file2.ATime);
   MTime.SetItem(index, file2.MTimeDefined, file2.MTime);
   StartPos.SetItem(index, file2.StartPosDefined, file2.StartPos);
-  SetItemAnti(index, file2.IsAnti);
+  SetItem_Anti(index, file2.IsAnti);
+  // SetItem_Aux(index, file2.IsAux);
+  Names.Add(name);
   Files.Add(file);
 }