1 // 7zOut.cpp
2
3 #include "StdAfx.h"
4
5 #include "../../../../C/7zCrc.h"
6
7 #include "../../../Common/AutoPtr.h"
8
9 #include "../../Common/StreamObjects.h"
10
11 #include "7zOut.h"
12
13 namespace NArchive {
14 namespace N7z {
15
WriteSignature()16 HRESULT COutArchive::WriteSignature()
17 {
18 Byte buf[8];
19 memcpy(buf, kSignature, kSignatureSize);
20 buf[kSignatureSize] = kMajorVersion;
21 buf[kSignatureSize + 1] = 4;
22 return WriteDirect(buf, 8);
23 }
24
25 #ifdef _7Z_VOL
WriteFinishSignature()26 HRESULT COutArchive::WriteFinishSignature()
27 {
28 RINOK(WriteDirect(kFinishSignature, kSignatureSize));
29 CArchiveVersion av;
30 av.Major = kMajorVersion;
31 av.Minor = 2;
32 RINOK(WriteDirectByte(av.Major));
33 return WriteDirectByte(av.Minor);
34 }
35 #endif
36
SetUInt32(Byte * p,UInt32 d)37 static void SetUInt32(Byte *p, UInt32 d)
38 {
39 for (int i = 0; i < 4; i++, d >>= 8)
40 p[i] = (Byte)d;
41 }
42
SetUInt64(Byte * p,UInt64 d)43 static void SetUInt64(Byte *p, UInt64 d)
44 {
45 for (int i = 0; i < 8; i++, d >>= 8)
46 p[i] = (Byte)d;
47 }
48
WriteStartHeader(const CStartHeader & h)49 HRESULT COutArchive::WriteStartHeader(const CStartHeader &h)
50 {
51 Byte buf[24];
52 SetUInt64(buf + 4, h.NextHeaderOffset);
53 SetUInt64(buf + 12, h.NextHeaderSize);
54 SetUInt32(buf + 20, h.NextHeaderCRC);
55 SetUInt32(buf, CrcCalc(buf + 4, 20));
56 return WriteDirect(buf, 24);
57 }
58
59 #ifdef _7Z_VOL
WriteFinishHeader(const CFinishHeader & h)60 HRESULT COutArchive::WriteFinishHeader(const CFinishHeader &h)
61 {
62 CCRC crc;
63 crc.UpdateUInt64(h.NextHeaderOffset);
64 crc.UpdateUInt64(h.NextHeaderSize);
65 crc.UpdateUInt32(h.NextHeaderCRC);
66 crc.UpdateUInt64(h.ArchiveStartOffset);
67 crc.UpdateUInt64(h.AdditionalStartBlockSize);
68 RINOK(WriteDirectUInt32(crc.GetDigest()));
69 RINOK(WriteDirectUInt64(h.NextHeaderOffset));
70 RINOK(WriteDirectUInt64(h.NextHeaderSize));
71 RINOK(WriteDirectUInt32(h.NextHeaderCRC));
72 RINOK(WriteDirectUInt64(h.ArchiveStartOffset));
73 return WriteDirectUInt64(h.AdditionalStartBlockSize);
74 }
75 #endif
76
Create(ISequentialOutStream * stream,bool endMarker)77 HRESULT COutArchive::Create(ISequentialOutStream *stream, bool endMarker)
78 {
79 Close();
80 #ifdef _7Z_VOL
81 // endMarker = false;
82 _endMarker = endMarker;
83 #endif
84 SeqStream = stream;
85 if (!endMarker)
86 {
87 SeqStream.QueryInterface(IID_IOutStream, &Stream);
88 if (!Stream)
89 {
90 return E_NOTIMPL;
91 // endMarker = true;
92 }
93 }
94 #ifdef _7Z_VOL
95 if (endMarker)
96 {
97 /*
98 CStartHeader sh;
99 sh.NextHeaderOffset = (UInt32)(Int32)-1;
100 sh.NextHeaderSize = (UInt32)(Int32)-1;
101 sh.NextHeaderCRC = 0;
102 WriteStartHeader(sh);
103 */
104 }
105 else
106 #endif
107 {
108 if (!Stream)
109 return E_FAIL;
110 RINOK(WriteSignature());
111 RINOK(Stream->Seek(0, STREAM_SEEK_CUR, &_prefixHeaderPos));
112 }
113 return S_OK;
114 }
115
Close()116 void COutArchive::Close()
117 {
118 SeqStream.Release();
119 Stream.Release();
120 }
121
SkipPrefixArchiveHeader()122 HRESULT COutArchive::SkipPrefixArchiveHeader()
123 {
124 #ifdef _7Z_VOL
125 if (_endMarker)
126 return S_OK;
127 #endif
128 Byte buf[24];
129 memset(buf, 0, 24);
130 return WriteDirect(buf, 24);
131 }
132
GetPos() const133 UInt64 COutArchive::GetPos() const
134 {
135 if (_countMode)
136 return _countSize;
137 if (_writeToStream)
138 return _outByte.GetProcessedSize();
139 return _outByte2.GetPos();
140 }
141
WriteBytes(const void * data,size_t size)142 void COutArchive::WriteBytes(const void *data, size_t size)
143 {
144 if (_countMode)
145 _countSize += size;
146 else if (_writeToStream)
147 {
148 _outByte.WriteBytes(data, size);
149 _crc = CrcUpdate(_crc, data, size);
150 }
151 else
152 _outByte2.WriteBytes(data, size);
153 }
154
WriteByte(Byte b)155 void COutArchive::WriteByte(Byte b)
156 {
157 if (_countMode)
158 _countSize++;
159 else if (_writeToStream)
160 {
161 _outByte.WriteByte(b);
162 _crc = CRC_UPDATE_BYTE(_crc, b);
163 }
164 else
165 _outByte2.WriteByte(b);
166 }
167
WriteUInt32(UInt32 value)168 void COutArchive::WriteUInt32(UInt32 value)
169 {
170 for (int i = 0; i < 4; i++)
171 {
172 WriteByte((Byte)value);
173 value >>= 8;
174 }
175 }
176
WriteUInt64(UInt64 value)177 void COutArchive::WriteUInt64(UInt64 value)
178 {
179 for (int i = 0; i < 8; i++)
180 {
181 WriteByte((Byte)value);
182 value >>= 8;
183 }
184 }
185
WriteNumber(UInt64 value)186 void COutArchive::WriteNumber(UInt64 value)
187 {
188 Byte firstByte = 0;
189 Byte mask = 0x80;
190 int i;
191 for (i = 0; i < 8; i++)
192 {
193 if (value < ((UInt64(1) << ( 7 * (i + 1)))))
194 {
195 firstByte |= Byte(value >> (8 * i));
196 break;
197 }
198 firstByte |= mask;
199 mask >>= 1;
200 }
201 WriteByte(firstByte);
202 for (;i > 0; i--)
203 {
204 WriteByte((Byte)value);
205 value >>= 8;
206 }
207 }
208
GetBigNumberSize(UInt64 value)209 static UInt32 GetBigNumberSize(UInt64 value)
210 {
211 int i;
212 for (i = 1; i < 9; i++)
213 if (value < (((UInt64)1 << (i * 7))))
214 break;
215 return i;
216 }
217
218 #ifdef _7Z_VOL
GetVolHeadersSize(UInt64 dataSize,int nameLength,bool props)219 UInt32 COutArchive::GetVolHeadersSize(UInt64 dataSize, int nameLength, bool props)
220 {
221 UInt32 result = GetBigNumberSize(dataSize) * 2 + 41;
222 if (nameLength != 0)
223 {
224 nameLength = (nameLength + 1) * 2;
225 result += nameLength + GetBigNumberSize(nameLength) + 2;
226 }
227 if (props)
228 {
229 result += 20;
230 }
231 if (result >= 128)
232 result++;
233 result += kSignatureSize + 2 + kFinishHeaderSize;
234 return result;
235 }
236
GetVolPureSize(UInt64 volSize,int nameLength,bool props)237 UInt64 COutArchive::GetVolPureSize(UInt64 volSize, int nameLength, bool props)
238 {
239 UInt32 headersSizeBase = COutArchive::GetVolHeadersSize(1, nameLength, props);
240 int testSize;
241 if (volSize > headersSizeBase)
242 testSize = volSize - headersSizeBase;
243 else
244 testSize = 1;
245 UInt32 headersSize = COutArchive::GetVolHeadersSize(testSize, nameLength, props);
246 UInt64 pureSize = 1;
247 if (volSize > headersSize)
248 pureSize = volSize - headersSize;
249 return pureSize;
250 }
251 #endif
252
WriteFolder(const CFolder & folder)253 void COutArchive::WriteFolder(const CFolder &folder)
254 {
255 WriteNumber(folder.Coders.Size());
256 unsigned i;
257 for (i = 0; i < folder.Coders.Size(); i++)
258 {
259 const CCoderInfo &coder = folder.Coders[i];
260 {
261 size_t propsSize = coder.Props.Size();
262
263 UInt64 id = coder.MethodID;
264 int idSize;
265 for (idSize = 1; idSize < sizeof(id); idSize++)
266 if ((id >> (8 * idSize)) == 0)
267 break;
268 Byte longID[15];
269 for (int t = idSize - 1; t >= 0 ; t--, id >>= 8)
270 longID[t] = (Byte)(id & 0xFF);
271 Byte b;
272 b = (Byte)(idSize & 0xF);
273 bool isComplex = !coder.IsSimpleCoder();
274 b |= (isComplex ? 0x10 : 0);
275 b |= ((propsSize != 0) ? 0x20 : 0 );
276 WriteByte(b);
277 WriteBytes(longID, idSize);
278 if (isComplex)
279 {
280 WriteNumber(coder.NumInStreams);
281 WriteNumber(coder.NumOutStreams);
282 }
283 if (propsSize == 0)
284 continue;
285 WriteNumber(propsSize);
286 WriteBytes(coder.Props, propsSize);
287 }
288 }
289 for (i = 0; i < folder.BindPairs.Size(); i++)
290 {
291 const CBindPair &bindPair = folder.BindPairs[i];
292 WriteNumber(bindPair.InIndex);
293 WriteNumber(bindPair.OutIndex);
294 }
295 if (folder.PackStreams.Size() > 1)
296 for (i = 0; i < folder.PackStreams.Size(); i++)
297 {
298 WriteNumber(folder.PackStreams[i]);
299 }
300 }
301
WriteBoolVector(const CBoolVector & boolVector)302 void COutArchive::WriteBoolVector(const CBoolVector &boolVector)
303 {
304 Byte b = 0;
305 Byte mask = 0x80;
306 FOR_VECTOR (i, boolVector)
307 {
308 if (boolVector[i])
309 b |= mask;
310 mask >>= 1;
311 if (mask == 0)
312 {
313 WriteByte(b);
314 mask = 0x80;
315 b = 0;
316 }
317 }
318 if (mask != 0x80)
319 WriteByte(b);
320 }
321
Bv_GetSizeInBytes(const CBoolVector & v)322 static inline unsigned Bv_GetSizeInBytes(const CBoolVector &v) { return ((unsigned)v.Size() + 7) / 8; }
323
WritePropBoolVector(Byte id,const CBoolVector & boolVector)324 void COutArchive::WritePropBoolVector(Byte id, const CBoolVector &boolVector)
325 {
326 WriteByte(id);
327 WriteNumber(Bv_GetSizeInBytes(boolVector));
328 WriteBoolVector(boolVector);
329 }
330
WriteHashDigests(const CUInt32DefVector & digests)331 void COutArchive::WriteHashDigests(const CUInt32DefVector &digests)
332 {
333 unsigned numDefined = 0;
334 unsigned i;
335 for (i = 0; i < digests.Defs.Size(); i++)
336 if (digests.Defs[i])
337 numDefined++;
338 if (numDefined == 0)
339 return;
340
341 WriteByte(NID::kCRC);
342 if (numDefined == digests.Defs.Size())
343 WriteByte(1);
344 else
345 {
346 WriteByte(0);
347 WriteBoolVector(digests.Defs);
348 }
349 for (i = 0; i < digests.Defs.Size(); i++)
350 if (digests.Defs[i])
351 WriteUInt32(digests.Vals[i]);
352 }
353
WritePackInfo(UInt64 dataOffset,const CRecordVector<UInt64> & packSizes,const CUInt32DefVector & packCRCs)354 void COutArchive::WritePackInfo(
355 UInt64 dataOffset,
356 const CRecordVector<UInt64> &packSizes,
357 const CUInt32DefVector &packCRCs)
358 {
359 if (packSizes.IsEmpty())
360 return;
361 WriteByte(NID::kPackInfo);
362 WriteNumber(dataOffset);
363 WriteNumber(packSizes.Size());
364 WriteByte(NID::kSize);
365 FOR_VECTOR (i, packSizes)
366 WriteNumber(packSizes[i]);
367
368 WriteHashDigests(packCRCs);
369
370 WriteByte(NID::kEnd);
371 }
372
WriteUnpackInfo(const CObjectVector<CFolder> & folders,const COutFolders & outFolders)373 void COutArchive::WriteUnpackInfo(const CObjectVector<CFolder> &folders, const COutFolders &outFolders)
374 {
375 if (folders.IsEmpty())
376 return;
377
378 WriteByte(NID::kUnpackInfo);
379
380 WriteByte(NID::kFolder);
381 WriteNumber(folders.Size());
382 {
383 WriteByte(0);
384 FOR_VECTOR (i, folders)
385 WriteFolder(folders[i]);
386 }
387
388 WriteByte(NID::kCodersUnpackSize);
389 FOR_VECTOR (i, outFolders.CoderUnpackSizes)
390 WriteNumber(outFolders.CoderUnpackSizes[i]);
391
392 WriteHashDigests(outFolders.FolderUnpackCRCs);
393
394 WriteByte(NID::kEnd);
395 }
396
WriteSubStreamsInfo(const CObjectVector<CFolder> & folders,const COutFolders & outFolders,const CRecordVector<UInt64> & unpackSizes,const CUInt32DefVector & digests)397 void COutArchive::WriteSubStreamsInfo(const CObjectVector<CFolder> &folders,
398 const COutFolders &outFolders,
399 const CRecordVector<UInt64> &unpackSizes,
400 const CUInt32DefVector &digests)
401 {
402 const CRecordVector<CNum> &numUnpackStreamsInFolders = outFolders.NumUnpackStreamsVector;
403 WriteByte(NID::kSubStreamsInfo);
404
405 unsigned i;
406 for (i = 0; i < numUnpackStreamsInFolders.Size(); i++)
407 if (numUnpackStreamsInFolders[i] != 1)
408 {
409 WriteByte(NID::kNumUnpackStream);
410 for (i = 0; i < numUnpackStreamsInFolders.Size(); i++)
411 WriteNumber(numUnpackStreamsInFolders[i]);
412 break;
413 }
414
415 for (i = 0; i < numUnpackStreamsInFolders.Size(); i++)
416 if (numUnpackStreamsInFolders[i] > 1)
417 {
418 WriteByte(NID::kSize);
419 CNum index = 0;
420 for (i = 0; i < numUnpackStreamsInFolders.Size(); i++)
421 {
422 CNum num = numUnpackStreamsInFolders[i];
423 for (CNum j = 0; j < num; j++)
424 {
425 if (j + 1 != num)
426 WriteNumber(unpackSizes[index]);
427 index++;
428 }
429 }
430 break;
431 }
432
433 CUInt32DefVector digests2;
434
435 unsigned digestIndex = 0;
436 for (i = 0; i < folders.Size(); i++)
437 {
438 unsigned numSubStreams = (unsigned)numUnpackStreamsInFolders[i];
439 if (numSubStreams == 1 && outFolders.FolderUnpackCRCs.ValidAndDefined(i))
440 digestIndex++;
441 else
442 for (unsigned j = 0; j < numSubStreams; j++, digestIndex++)
443 {
444 digests2.Defs.Add(digests.Defs[digestIndex]);
445 digests2.Vals.Add(digests.Vals[digestIndex]);
446 }
447 }
448 WriteHashDigests(digests2);
449 WriteByte(NID::kEnd);
450 }
451
452 // 7-Zip 4.50 - 4.58 contain BUG, so they do not support .7z archives with Unknown field.
453
SkipAlign(unsigned pos,unsigned alignSize)454 void COutArchive::SkipAlign(unsigned pos, unsigned alignSize)
455 {
456 if (!_useAlign)
457 return;
458 pos += (unsigned)GetPos();
459 pos &= (alignSize - 1);
460 if (pos == 0)
461 return;
462 unsigned skip = alignSize - pos;
463 if (skip < 2)
464 skip += alignSize;
465 skip -= 2;
466 WriteByte(NID::kDummy);
467 WriteByte((Byte)skip);
468 for (unsigned i = 0; i < skip; i++)
469 WriteByte(0);
470 }
471
WriteAlignedBoolHeader(const CBoolVector & v,unsigned numDefined,Byte type,unsigned itemSize)472 void COutArchive::WriteAlignedBoolHeader(const CBoolVector &v, unsigned numDefined, Byte type, unsigned itemSize)
473 {
474 const unsigned bvSize = (numDefined == v.Size()) ? 0 : Bv_GetSizeInBytes(v);
475 const UInt64 dataSize = (UInt64)numDefined * itemSize + bvSize + 2;
476 SkipAlign(3 + (unsigned)bvSize + (unsigned)GetBigNumberSize(dataSize), itemSize);
477
478 WriteByte(type);
479 WriteNumber(dataSize);
480 if (numDefined == v.Size())
481 WriteByte(1);
482 else
483 {
484 WriteByte(0);
485 WriteBoolVector(v);
486 }
487 WriteByte(0);
488 }
489
WriteUInt64DefVector(const CUInt64DefVector & v,Byte type)490 void COutArchive::WriteUInt64DefVector(const CUInt64DefVector &v, Byte type)
491 {
492 unsigned numDefined = 0;
493
494 unsigned i;
495 for (i = 0; i < v.Defs.Size(); i++)
496 if (v.Defs[i])
497 numDefined++;
498
499 if (numDefined == 0)
500 return;
501
502 WriteAlignedBoolHeader(v.Defs, numDefined, type, 8);
503
504 for (i = 0; i < v.Defs.Size(); i++)
505 if (v.Defs[i])
506 WriteUInt64(v.Vals[i]);
507 }
508
EncodeStream(DECL_EXTERNAL_CODECS_LOC_VARS CEncoder & encoder,const CByteBuffer & data,CRecordVector<UInt64> & packSizes,CObjectVector<CFolder> & folders,COutFolders & outFolders)509 HRESULT COutArchive::EncodeStream(
510 DECL_EXTERNAL_CODECS_LOC_VARS
511 CEncoder &encoder, const CByteBuffer &data,
512 CRecordVector<UInt64> &packSizes, CObjectVector<CFolder> &folders, COutFolders &outFolders)
513 {
514 CBufInStream *streamSpec = new CBufInStream;
515 CMyComPtr<ISequentialInStream> stream = streamSpec;
516 streamSpec->Init(data, data.Size());
517 outFolders.FolderUnpackCRCs.Defs.Add(true);
518 outFolders.FolderUnpackCRCs.Vals.Add(CrcCalc(data, data.Size()));
519 // outFolders.NumUnpackStreamsVector.Add(1);
520 UInt64 dataSize64 = data.Size();
521 UInt64 unpackSize;
522 RINOK(encoder.Encode(
523 EXTERNAL_CODECS_LOC_VARS
524 stream, NULL, &dataSize64, folders.AddNew(), outFolders.CoderUnpackSizes, unpackSize, SeqStream, packSizes, NULL))
525 return S_OK;
526 }
527
WriteHeader(const CArchiveDatabaseOut & db,UInt64 & headerOffset)528 void COutArchive::WriteHeader(
529 const CArchiveDatabaseOut &db,
530 // const CHeaderOptions &headerOptions,
531 UInt64 &headerOffset)
532 {
533 /*
534 bool thereIsSecure = (db.SecureBuf.Size() != 0);
535 */
536 _useAlign = true;
537
538 unsigned i;
539
540 UInt64 packedSize = 0;
541 for (i = 0; i < db.PackSizes.Size(); i++)
542 packedSize += db.PackSizes[i];
543
544 headerOffset = packedSize;
545
546 WriteByte(NID::kHeader);
547
548 // Archive Properties
549
550 if (db.Folders.Size() > 0)
551 {
552 WriteByte(NID::kMainStreamsInfo);
553 WritePackInfo(0, db.PackSizes, db.PackCRCs);
554 WriteUnpackInfo(db.Folders, (const COutFolders &)db);
555
556 CRecordVector<UInt64> unpackSizes;
557 CUInt32DefVector digests;
558 for (i = 0; i < db.Files.Size(); i++)
559 {
560 const CFileItem &file = db.Files[i];
561 if (!file.HasStream)
562 continue;
563 unpackSizes.Add(file.Size);
564 digests.Defs.Add(file.CrcDefined);
565 digests.Vals.Add(file.Crc);
566 }
567
568 WriteSubStreamsInfo(db.Folders, (const COutFolders &)db, unpackSizes, digests);
569 WriteByte(NID::kEnd);
570 }
571
572 if (db.Files.IsEmpty())
573 {
574 WriteByte(NID::kEnd);
575 return;
576 }
577
578 WriteByte(NID::kFilesInfo);
579 WriteNumber(db.Files.Size());
580
581 {
582 /* ---------- Empty Streams ---------- */
583 CBoolVector emptyStreamVector;
584 emptyStreamVector.ClearAndSetSize(db.Files.Size());
585 unsigned numEmptyStreams = 0;
586 for (i = 0; i < db.Files.Size(); i++)
587 if (db.Files[i].HasStream)
588 emptyStreamVector[i] = false;
589 else
590 {
591 emptyStreamVector[i] = true;
592 numEmptyStreams++;
593 }
594 if (numEmptyStreams != 0)
595 {
596 WritePropBoolVector(NID::kEmptyStream, emptyStreamVector);
597
598 CBoolVector emptyFileVector, antiVector;
599 emptyFileVector.ClearAndSetSize(numEmptyStreams);
600 antiVector.ClearAndSetSize(numEmptyStreams);
601 bool thereAreEmptyFiles = false, thereAreAntiItems = false;
602 unsigned cur = 0;
603 for (i = 0; i < db.Files.Size(); i++)
604 {
605 const CFileItem &file = db.Files[i];
606 if (file.HasStream)
607 continue;
608 emptyFileVector[cur] = !file.IsDir;
609 if (!file.IsDir)
610 thereAreEmptyFiles = true;
611 bool isAnti = db.IsItemAnti(i);
612 antiVector[cur] = isAnti;
613 if (isAnti)
614 thereAreAntiItems = true;
615 cur++;
616 }
617
618 if (thereAreEmptyFiles)
619 WritePropBoolVector(NID::kEmptyFile, emptyFileVector);
620 if (thereAreAntiItems)
621 WritePropBoolVector(NID::kAnti, antiVector);
622 }
623 }
624
625
626 {
627 /* ---------- Names ---------- */
628
629 unsigned numDefined = 0;
630 size_t namesDataSize = 0;
631 FOR_VECTOR (i, db.Files)
632 {
633 const UString &name = db.Names[i];
634 if (!name.IsEmpty())
635 numDefined++;
636 namesDataSize += (name.Len() + 1) * 2;
637 }
638
639 if (numDefined > 0)
640 {
641 namesDataSize++;
642 SkipAlign(2 + GetBigNumberSize(namesDataSize), 16);
643
644 WriteByte(NID::kName);
645 WriteNumber(namesDataSize);
646 WriteByte(0);
647 FOR_VECTOR (i, db.Files)
648 {
649 const UString &name = db.Names[i];
650 for (unsigned t = 0; t <= name.Len(); t++)
651 {
652 wchar_t c = name[t];
653 WriteByte((Byte)c);
654 WriteByte((Byte)(c >> 8));
655 }
656 }
657 }
658 }
659
660 /* if (headerOptions.WriteCTime) */ WriteUInt64DefVector(db.CTime, NID::kCTime);
661 /* if (headerOptions.WriteATime) */ WriteUInt64DefVector(db.ATime, NID::kATime);
662 /* if (headerOptions.WriteMTime) */ WriteUInt64DefVector(db.MTime, NID::kMTime);
663 WriteUInt64DefVector(db.StartPos, NID::kStartPos);
664
665 {
666 /* ---------- Write Attrib ---------- */
667 CBoolVector boolVector;
668 boolVector.ClearAndSetSize(db.Files.Size());
669 unsigned numDefined = 0;
670 for (i = 0; i < db.Files.Size(); i++)
671 {
672 bool defined = db.Files[i].AttribDefined;
673 boolVector[i] = defined;
674 if (defined)
675 numDefined++;
676 }
677 if (numDefined != 0)
678 {
679 WriteAlignedBoolHeader(boolVector, numDefined, NID::kWinAttrib, 4);
680 for (i = 0; i < db.Files.Size(); i++)
681 {
682 const CFileItem &file = db.Files[i];
683 if (file.AttribDefined)
684 WriteUInt32(file.Attrib);
685 }
686 }
687 }
688
689 /*
690 {
691 // ---------- Write IsAux ----------
692 unsigned numAux = 0;
693 const CBoolVector &isAux = db.IsAux;
694 for (i = 0; i < isAux.Size(); i++)
695 if (isAux[i])
696 numAux++;
697 if (numAux > 0)
698 {
699 const unsigned bvSize = Bv_GetSizeInBytes(isAux);
700 WriteByte(NID::kIsAux);
701 WriteNumber(bvSize);
702 WriteBoolVector(isAux);
703 }
704 }
705
706 {
707 // ---------- Write Parent ----------
708 CBoolVector boolVector;
709 boolVector.Reserve(db.Files.Size());
710 unsigned numIsDir = 0;
711 unsigned numParentLinks = 0;
712 for (i = 0; i < db.Files.Size(); i++)
713 {
714 const CFileItem &file = db.Files[i];
715 bool defined = !file.IsAltStream;
716 boolVector.Add(defined);
717 if (defined)
718 numIsDir++;
719 if (file.Parent >= 0)
720 numParentLinks++;
721 }
722 if (numParentLinks > 0)
723 {
724 // WriteAlignedBoolHeader(boolVector, numDefined, NID::kParent, 4);
725 const unsigned bvSize = (numIsDir == boolVector.Size()) ? 0 : Bv_GetSizeInBytes(boolVector);
726 const UInt64 dataSize = (UInt64)db.Files.Size() * 4 + bvSize + 1;
727 SkipAlign(2 + (unsigned)bvSize + (unsigned)GetBigNumberSize(dataSize), 4);
728
729 WriteByte(NID::kParent);
730 WriteNumber(dataSize);
731 if (numIsDir == boolVector.Size())
732 WriteByte(1);
733 else
734 {
735 WriteByte(0);
736 WriteBoolVector(boolVector);
737 }
738 for (i = 0; i < db.Files.Size(); i++)
739 {
740 const CFileItem &file = db.Files[i];
741 // if (file.Parent >= 0)
742 WriteUInt32(file.Parent);
743 }
744 }
745 }
746
747 if (thereIsSecure)
748 {
749 UInt64 secureDataSize = 1 + 4 +
750 db.SecureBuf.Size() +
751 db.SecureSizes.Size() * 4;
752 // secureDataSize += db.SecureIDs.Size() * 4;
753 for (i = 0; i < db.SecureIDs.Size(); i++)
754 secureDataSize += GetBigNumberSize(db.SecureIDs[i]);
755 SkipAlign(2 + GetBigNumberSize(secureDataSize), 4);
756 WriteByte(NID::kNtSecure);
757 WriteNumber(secureDataSize);
758 WriteByte(0);
759 WriteUInt32(db.SecureSizes.Size());
760 for (i = 0; i < db.SecureSizes.Size(); i++)
761 WriteUInt32(db.SecureSizes[i]);
762 WriteBytes(db.SecureBuf, db.SecureBuf.Size());
763 for (i = 0; i < db.SecureIDs.Size(); i++)
764 {
765 WriteNumber(db.SecureIDs[i]);
766 // WriteUInt32(db.SecureIDs[i]);
767 }
768 }
769 */
770
771 WriteByte(NID::kEnd); // for files
772 WriteByte(NID::kEnd); // for headers
773 }
774
WriteDatabase(DECL_EXTERNAL_CODECS_LOC_VARS const CArchiveDatabaseOut & db,const CCompressionMethodMode * options,const CHeaderOptions & headerOptions)775 HRESULT COutArchive::WriteDatabase(
776 DECL_EXTERNAL_CODECS_LOC_VARS
777 const CArchiveDatabaseOut &db,
778 const CCompressionMethodMode *options,
779 const CHeaderOptions &headerOptions)
780 {
781 if (!db.CheckNumFiles())
782 return E_FAIL;
783
784 UInt64 headerOffset;
785 UInt32 headerCRC;
786 UInt64 headerSize;
787 if (db.IsEmpty())
788 {
789 headerSize = 0;
790 headerOffset = 0;
791 headerCRC = CrcCalc(0, 0);
792 }
793 else
794 {
795 bool encodeHeaders = false;
796 if (options != 0)
797 if (options->IsEmpty())
798 options = 0;
799 if (options != 0)
800 if (options->PasswordIsDefined || headerOptions.CompressMainHeader)
801 encodeHeaders = true;
802
803 _outByte.SetStream(SeqStream);
804 _outByte.Init();
805 _crc = CRC_INIT_VAL;
806 _countMode = encodeHeaders;
807 _writeToStream = true;
808 _countSize = 0;
809 WriteHeader(db, /* headerOptions, */ headerOffset);
810
811 if (encodeHeaders)
812 {
813 CByteBuffer buf(_countSize);
814 _outByte2.Init((Byte *)buf, _countSize);
815
816 _countMode = false;
817 _writeToStream = false;
818 WriteHeader(db, /* headerOptions, */ headerOffset);
819
820 if (_countSize != _outByte2.GetPos())
821 return E_FAIL;
822
823 CCompressionMethodMode encryptOptions;
824 encryptOptions.PasswordIsDefined = options->PasswordIsDefined;
825 encryptOptions.Password = options->Password;
826 CEncoder encoder(headerOptions.CompressMainHeader ? *options : encryptOptions);
827 CRecordVector<UInt64> packSizes;
828 CObjectVector<CFolder> folders;
829 COutFolders outFolders;
830
831 RINOK(EncodeStream(
832 EXTERNAL_CODECS_LOC_VARS
833 encoder, buf,
834 packSizes, folders, outFolders));
835
836 _writeToStream = true;
837
838 if (folders.Size() == 0)
839 throw 1;
840
841 WriteID(NID::kEncodedHeader);
842 WritePackInfo(headerOffset, packSizes, CUInt32DefVector());
843 WriteUnpackInfo(folders, outFolders);
844 WriteByte(NID::kEnd);
845 FOR_VECTOR (i, packSizes)
846 headerOffset += packSizes[i];
847 }
848 RINOK(_outByte.Flush());
849 headerCRC = CRC_GET_DIGEST(_crc);
850 headerSize = _outByte.GetProcessedSize();
851 }
852 #ifdef _7Z_VOL
853 if (_endMarker)
854 {
855 CFinishHeader h;
856 h.NextHeaderSize = headerSize;
857 h.NextHeaderCRC = headerCRC;
858 h.NextHeaderOffset =
859 UInt64(0) - (headerSize +
860 4 + kFinishHeaderSize);
861 h.ArchiveStartOffset = h.NextHeaderOffset - headerOffset;
862 h.AdditionalStartBlockSize = 0;
863 RINOK(WriteFinishHeader(h));
864 return WriteFinishSignature();
865 }
866 else
867 #endif
868 {
869 CStartHeader h;
870 h.NextHeaderSize = headerSize;
871 h.NextHeaderCRC = headerCRC;
872 h.NextHeaderOffset = headerOffset;
873 RINOK(Stream->Seek(_prefixHeaderPos, STREAM_SEEK_SET, NULL));
874 return WriteStartHeader(h);
875 }
876 }
877
SetItem(unsigned index,bool defined,UInt64 value)878 void CUInt64DefVector::SetItem(unsigned index, bool defined, UInt64 value)
879 {
880 while (index >= Defs.Size())
881 Defs.Add(false);
882 Defs[index] = defined;
883 if (!defined)
884 return;
885 while (index >= Vals.Size())
886 Vals.Add(0);
887 Vals[index] = value;
888 }
889
AddFile(const CFileItem & file,const CFileItem2 & file2,const UString & name)890 void CArchiveDatabaseOut::AddFile(const CFileItem &file, const CFileItem2 &file2, const UString &name)
891 {
892 unsigned index = Files.Size();
893 CTime.SetItem(index, file2.CTimeDefined, file2.CTime);
894 ATime.SetItem(index, file2.ATimeDefined, file2.ATime);
895 MTime.SetItem(index, file2.MTimeDefined, file2.MTime);
896 StartPos.SetItem(index, file2.StartPosDefined, file2.StartPos);
897 SetItem_Anti(index, file2.IsAnti);
898 // SetItem_Aux(index, file2.IsAux);
899 Names.Add(name);
900 Files.Add(file);
901 }
902
903 }}
904