Simone/nsis-plugin-ns7zip
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 8 Wiki Activity
Files
cda44e07a8259b9a7ae8a1b7a82eefe877f9ea99
nsis-plugin-ns7zip/versions/26.00/CPP/7zip/Archive/7z/7zOut.cpp
T
Simone d074cc7c07 chore: initial commit (extracted from Launchers monorepo) 
Plugin: ns7zip v2.0.0
Architectures: x86-ansi, x86-unicode, amd64-unicode
License: LGPL-2.1-or-later
2026-04-29 14:07:51 +02:00

1027 lines
26 KiB
C++
Raw Blame History

// 7zOut.cpp
#include "StdAfx.h"
#include "../../../../C/7zCrc.h"
#include "../../../../C/CpuArch.h"
#include "../../../Common/AutoPtr.h"
// #include "../../../Common/UTFConvert.h"
#include "../../Common/StreamObjects.h"
#include "../Common/OutStreamWithCRC.h"
#include "7zOut.h"
unsigned BoolVector_CountSum(const CBoolVector &v);
static UInt64 UInt64Vector_CountSum(const CRecordVector<UInt64> &v)
{
UInt64 sum = 0;
const unsigned size = v.Size();
if (size)
{
const UInt64 *p = v.ConstData();
const UInt64 * const lim = p + size;
do
sum += *p++;
while (p != lim);
}
return sum;
}
namespace NArchive {
namespace N7z {
static void FillSignature(Byte *buf)
{
memcpy(buf, kSignature, kSignatureSize);
buf[kSignatureSize] = kMajorVersion;
buf[kSignatureSize + 1] = 4;
}
#ifdef Z7_7Z_VOL
HRESULT COutArchive::WriteFinishSignature()
{
RINOK(WriteDirect(kFinishSignature, kSignatureSize));
CArchiveVersion av;
av.Major = kMajorVersion;
av.Minor = 2;
RINOK(WriteDirectByte(av.Major));
return WriteDirectByte(av.Minor);
}
#endif
static void SetUInt32(Byte *p, UInt32 d)
{
for (int i = 0; i < 4; i++, d >>= 8)
p[i] = (Byte)d;
}
static void SetUInt64(Byte *p, UInt64 d)
{
for (int i = 0; i < 8; i++, d >>= 8)
p[i] = (Byte)d;
}
HRESULT COutArchive::WriteStartHeader(const CStartHeader &h)
{
Byte buf[32];
FillSignature(buf);
SetUInt64(buf + 8 + 4, h.NextHeaderOffset);
SetUInt64(buf + 8 + 12, h.NextHeaderSize);
SetUInt32(buf + 8 + 20, h.NextHeaderCRC);
SetUInt32(buf + 8, CrcCalc(buf + 8 + 4, 20));
return WriteDirect(buf, sizeof(buf));
}
#ifdef Z7_7Z_VOL
HRESULT COutArchive::WriteFinishHeader(const CFinishHeader &h)
{
CCRC crc;
crc.UpdateUInt64(h.NextHeaderOffset);
crc.UpdateUInt64(h.NextHeaderSize);
crc.UpdateUInt32(h.NextHeaderCRC);
crc.UpdateUInt64(h.ArchiveStartOffset);
crc.UpdateUInt64(h.AdditionalStartBlockSize);
RINOK(WriteDirectUInt32(crc.GetDigest()));
RINOK(WriteDirectUInt64(h.NextHeaderOffset));
RINOK(WriteDirectUInt64(h.NextHeaderSize));
RINOK(WriteDirectUInt32(h.NextHeaderCRC));
RINOK(WriteDirectUInt64(h.ArchiveStartOffset));
return WriteDirectUInt64(h.AdditionalStartBlockSize);
}
#endif
HRESULT COutArchive::Create_and_WriteStartPrefix(ISequentialOutStream *stream /* , bool endMarker */)
{
Close();
#ifdef Z7_7Z_VOL
// endMarker = false;
_endMarker = endMarker;
#endif
SeqStream = stream;
// if (!endMarker)
{
SeqStream.QueryInterface(IID_IOutStream, &Stream);
if (!Stream)
{
return E_NOTIMPL;
// endMarker = true;
}
RINOK(Stream->Seek(0, STREAM_SEEK_CUR, &_signatureHeaderPos))
Byte buf[32];
FillSignature(buf);
memset(&buf[8], 0, 32 - 8);
return WriteDirect(buf, sizeof(buf));
}
#ifdef Z7_7Z_VOL
if (endMarker)
{
/*
CStartHeader sh;
sh.NextHeaderOffset = (UInt32)(Int32)-1;
sh.NextHeaderSize = (UInt32)(Int32)-1;
sh.NextHeaderCRC = 0;
WriteStartHeader(sh);
return S_OK;
*/
}
#endif
}
void COutArchive::Close()
{
SeqStream.Release();
Stream.Release();
}
UInt64 COutArchive::GetPos() const
{
if (_countMode)
return _countSize;
if (_writeToStream)
return _outByte.GetProcessedSize();
return _outByte2.GetPos();
}
void COutArchive::WriteBytes(const void *data, size_t size)
{
if (_countMode)
_countSize += size;
else if (_writeToStream)
{
_outByte.WriteBytes(data, size);
// _crc = CrcUpdate(_crc, data, size);
}
else
_outByte2.WriteBytes(data, size);
}
void COutArchive::WriteByte(Byte b)
{
if (_countMode)
_countSize++;
else if (_writeToStream)
WriteByte_ToStream(b);
else
_outByte2.WriteByte(b);
}
/*
void COutArchive::WriteUInt32(UInt32 value)
{
for (int i = 0; i < 4; i++)
{
WriteByte((Byte)value);
value >>= 8;
}
}
void COutArchive::WriteUInt64(UInt64 value)
{
for (int i = 0; i < 8; i++)
{
WriteByte((Byte)value);
value >>= 8;
}
}
*/
void COutArchive::WriteNumber(UInt64 value)
{
Byte firstByte = 0;
Byte mask = 0x80;
int i;
for (i = 0; i < 8; i++)
{
if (value < ((UInt64(1) << ( 7 * (i + 1)))))
{
firstByte |= Byte(value >> (8 * i));
break;
}
firstByte |= mask;
mask = (Byte)(mask >> 1);
}
WriteByte(firstByte);
for (; i > 0; i--)
{
WriteByte((Byte)value);
value >>= 8;
}
}
static unsigned GetBigNumberSize(UInt64 value)
{
unsigned i;
for (i = 1; i < 9; i++)
if (value < (((UInt64)1 << (i * 7))))
break;
return i;
}
#ifdef Z7_7Z_VOL
UInt32 COutArchive::GetVolHeadersSize(UInt64 dataSize, int nameLength, bool props)
{
UInt32 result = GetBigNumberSize(dataSize) * 2 + 41;
if (nameLength != 0)
{
nameLength = (nameLength + 1) * 2;
result += nameLength + GetBigNumberSize(nameLength) + 2;
}
if (props)
{
result += 20;
}
if (result >= 128)
result++;
result += kSignatureSize + 2 + kFinishHeaderSize;
return result;
}
UInt64 COutArchive::GetVolPureSize(UInt64 volSize, int nameLength, bool props)
{
UInt32 headersSizeBase = COutArchive::GetVolHeadersSize(1, nameLength, props);
int testSize;
if (volSize > headersSizeBase)
testSize = volSize - headersSizeBase;
else
testSize = 1;
UInt32 headersSize = COutArchive::GetVolHeadersSize(testSize, nameLength, props);
UInt64 pureSize = 1;
if (volSize > headersSize)
pureSize = volSize - headersSize;
return pureSize;
}
#endif
void COutArchive::WriteFolder(const CFolder &folder)
{
WriteNumber(folder.Coders.Size());
unsigned i;
for (i = 0; i < folder.Coders.Size(); i++)
{
const CCoderInfo &coder = folder.Coders[i];
{
UInt64 id = coder.MethodID;
unsigned idSize;
for (idSize = 1; idSize < sizeof(id); idSize++)
if ((id >> (8 * idSize)) == 0)
break;
// idSize &= 0xF; // idSize is smaller than 16 already
Byte temp[16];
for (unsigned t = idSize; t != 0; t--, id >>= 8)
temp[t] = (Byte)(id & 0xFF);
unsigned b = idSize;
const bool isComplex = !coder.IsSimpleCoder();
b |= (isComplex ? 0x10 : 0);
const size_t propsSize = coder.Props.Size();
b |= ((propsSize != 0) ? 0x20 : 0);
temp[0] = (Byte)b;
WriteBytes(temp, idSize + 1);
if (isComplex)
{
WriteNumber(coder.NumStreams);
WriteNumber(1); // NumOutStreams;
}
if (propsSize == 0)
continue;
WriteNumber(propsSize);
WriteBytes(coder.Props, propsSize);
}
}
for (i = 0; i < folder.Bonds.Size(); i++)
{
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::Write_BoolVector(const CBoolVector &boolVector)
{
Byte b = 0;
Byte mask = 0x80;
FOR_VECTOR (i, boolVector)
{
if (boolVector[i])
b |= mask;
mask = (Byte)(mask >> 1);
if (mask == 0)
{
WriteByte(b);
mask = 0x80;
b = 0;
}
}
if (mask != 0x80)
WriteByte(b);
}
static inline unsigned Bv_GetSizeInBytes(const CBoolVector &v) { return ((unsigned)v.Size() + 7) / 8; }
void COutArchive::WritePropBoolVector(Byte id, const CBoolVector &boolVector)
{
WriteByte(id);
WriteNumber(Bv_GetSizeInBytes(boolVector));
Write_BoolVector(boolVector);
}
void COutArchive::Write_BoolVector_numDefined(const CBoolVector &boolVector, unsigned numDefined)
{
if (numDefined == boolVector.Size())
WriteByte(1);
else
{
WriteByte(0);
Write_BoolVector(boolVector);
}
}
void COutArchive::WriteHashDigests(const CUInt32DefVector &digests)
{
const unsigned numDefined = BoolVector_CountSum(digests.Defs);
if (numDefined == 0)
return;
WriteByte(NID::kCRC);
Write_BoolVector_numDefined(digests.Defs, numDefined);
Write_UInt32DefVector_numDefined(digests, numDefined);
}
void COutArchive::WritePackInfo(
UInt64 dataOffset,
const CRecordVector<UInt64> &packSizes,
const CUInt32DefVector &packCRCs)
{
if (packSizes.IsEmpty())
return;
WriteByte(NID::kPackInfo);
WriteNumber(dataOffset);
WriteNumber(packSizes.Size());
WriteByte(NID::kSize);
FOR_VECTOR (i, packSizes)
WriteNumber(packSizes[i]);
WriteHashDigests(packCRCs);
WriteByte(NID::kEnd);
}
void COutArchive::WriteUnpackInfo(const CObjectVector<CFolder> &folders, const COutFolders &outFolders)
{
if (folders.IsEmpty())
return;
WriteByte(NID::kUnpackInfo);
WriteByte(NID::kFolder);
WriteNumber(folders.Size());
{
WriteByte(0);
FOR_VECTOR (i, folders)
WriteFolder(folders[i]);
}
WriteByte(NID::kCodersUnpackSize);
FOR_VECTOR (i, outFolders.CoderUnpackSizes)
WriteNumber(outFolders.CoderUnpackSizes[i]);
WriteHashDigests(outFolders.FolderUnpackCRCs);
WriteByte(NID::kEnd);
}
void COutArchive::WriteSubStreamsInfo(const CObjectVector<CFolder> &folders,
const COutFolders &outFolders,
const CRecordVector<UInt64> &unpackSizes,
const CUInt32DefVector &digests)
{
const CRecordVector<CNum> &numUnpackStreamsInFolders = outFolders.NumUnpackStreamsVector;
WriteByte(NID::kSubStreamsInfo);
unsigned i;
for (i = 0; i < numUnpackStreamsInFolders.Size(); i++)
if (numUnpackStreamsInFolders[i] != 1)
{
WriteByte(NID::kNumUnpackStream);
for (i = 0; i < numUnpackStreamsInFolders.Size(); i++)
WriteNumber(numUnpackStreamsInFolders[i]);
break;
}
for (i = 0; i < numUnpackStreamsInFolders.Size(); i++)
if (numUnpackStreamsInFolders[i] > 1)
{
WriteByte(NID::kSize);
CNum index = 0;
for (i = 0; i < numUnpackStreamsInFolders.Size(); i++)
{
CNum num = numUnpackStreamsInFolders[i];
for (CNum j = 0; j < num; j++)
{
if (j + 1 != num)
WriteNumber(unpackSizes[index]);
index++;
}
}
break;
}
CUInt32DefVector digests2;
unsigned digestIndex = 0;
for (i = 0; i < folders.Size(); i++)
{
unsigned numSubStreams = (unsigned)numUnpackStreamsInFolders[i];
if (numSubStreams == 1 && outFolders.FolderUnpackCRCs.ValidAndDefined(i))
digestIndex++;
else
for (unsigned j = 0; j < numSubStreams; j++, digestIndex++)
{
digests2.Defs.Add(digests.Defs[digestIndex]);
digests2.Vals.Add(digests.Vals[digestIndex]);
}
}
WriteHashDigests(digests2);
WriteByte(NID::kEnd);
}
// 7-Zip 4.50 - 4.58 contain BUG, so they do not support .7z archives with Unknown field.
void COutArchive::SkipToAligned(unsigned pos, unsigned alignShifts)
{
if (!_useAlign)
return;
const unsigned alignSize = (unsigned)1 << alignShifts;
pos += (unsigned)GetPos();
pos &= (alignSize - 1);
if (pos == 0)
return;
unsigned skip = alignSize - pos;
if (skip < 2)
skip += alignSize;
skip -= 2;
WriteByte(NID::kDummy);
WriteByte((Byte)skip);
for (unsigned i = 0; i < skip; i++)
WriteByte(0);
}
void COutArchive::WriteAlignedBools(const CBoolVector &v, unsigned numDefined, Byte type, unsigned itemSizeShifts)
{
const unsigned bvSize = (numDefined == v.Size()) ? 0 : Bv_GetSizeInBytes(v);
const UInt64 dataSize = ((UInt64)numDefined << itemSizeShifts) + bvSize + 2;
SkipToAligned(3 + bvSize + GetBigNumberSize(dataSize), itemSizeShifts);
WriteByte(type);
WriteNumber(dataSize);
Write_BoolVector_numDefined(v, numDefined);
WriteByte(0); // 0 means no switching to external stream
}
void COutArchive::Write_UInt32DefVector_numDefined(const CUInt32DefVector &v, unsigned numDefined)
{
if (_countMode)
{
_countSize += (size_t)numDefined * 4;
return;
}
const bool * const defs = v.Defs.ConstData();
const UInt32 * const vals = v.Vals.ConstData();
const size_t num = v.Defs.Size();
for (size_t i = 0; i < num; i++)
if (defs[i])
{
UInt32 value = vals[i];
for (int k = 0; k < 4; k++)
{
if (_writeToStream)
WriteByte_ToStream((Byte)value);
else
_outByte2.WriteByte((Byte)value);
// WriteByte((Byte)value);
value >>= 8;
}
// WriteUInt32(v.Vals[i]);
}
}
void COutArchive::Write_UInt64DefVector_type(const CUInt64DefVector &v, Byte type)
{
const unsigned numDefined = BoolVector_CountSum(v.Defs);
if (numDefined == 0)
return;
WriteAlignedBools(v.Defs, numDefined, type, 3);
if (_countMode)
{
_countSize += (size_t)numDefined * 8;
return;
}
const bool * const defs = v.Defs.ConstData();
const UInt64 * const vals = v.Vals.ConstData();
const size_t num = v.Defs.Size();
for (size_t i = 0; i < num; i++)
if (defs[i])
{
UInt64 value = vals[i];
for (int k = 0; k < 8; k++)
{
if (_writeToStream)
WriteByte_ToStream((Byte)value);
else
_outByte2.WriteByte((Byte)value);
// WriteByte((Byte)value);
value >>= 8;
}
// WriteUInt64(v.Vals[i]);
}
}
HRESULT COutArchive::EncodeStream(
DECL_EXTERNAL_CODECS_LOC_VARS
CEncoder &encoder, const CByteBuffer &data,
CRecordVector<UInt64> &packSizes, CObjectVector<CFolder> &folders, COutFolders &outFolders)
{
CMyComPtr2_Create<ISequentialInStream, CBufInStream> streamSpec;
streamSpec->Init(data, data.Size());
outFolders.FolderUnpackCRCs.Defs.Add(true);
outFolders.FolderUnpackCRCs.Vals.Add(CrcCalc(data, data.Size()));
// outFolders.NumUnpackStreamsVector.Add(1);
const UInt64 dataSize64 = data.Size();
const UInt64 expectSize = data.Size();
RINOK(encoder.Encode1(
EXTERNAL_CODECS_LOC_VARS
streamSpec,
// NULL,
&dataSize64, // inSizeForReduce
expectSize,
folders.AddNew(),
// outFolders.CoderUnpackSizes, unpackSize,
SeqStream, packSizes, NULL))
if (!streamSpec->WasFinished())
return E_FAIL;
encoder.Encode_Post(dataSize64, outFolders.CoderUnpackSizes);
return S_OK;
}
void COutArchive::WriteHeader(
const CArchiveDatabaseOut &db,
// const CHeaderOptions &headerOptions,
UInt64 &headerOffset)
{
/*
bool thereIsSecure = (db.SecureBuf.Size() != 0);
*/
_useAlign = true;
headerOffset = UInt64Vector_CountSum(db.PackSizes);
WriteByte(NID::kHeader);
/*
{
// It's example for per archive properies writing
WriteByte(NID::kArchiveProperties);
// you must use random 40-bit number that will identify you
// then you can use same kDeveloperID for any properties and methods
const UInt64 kDeveloperID = 0x123456789A; // change that value to real random 40-bit number
#define GENERATE_7Z_ID(developerID, subID) (((UInt64)0x3F << 56) | ((UInt64)developerID << 16) | subID)
{
const UInt64 kSubID = 0x1; // you can use small number for subID
const UInt64 kID = GENERATE_7Z_ID(kDeveloperID, kSubID);
WriteNumber(kID);
const unsigned kPropsSize = 3; // it's example size
WriteNumber(kPropsSize);
for (unsigned i = 0; i < kPropsSize; i++)
WriteByte((Byte)(i & 0xFF));
}
{
const UInt64 kSubID = 0x2; // you can use small number for subID
const UInt64 kID = GENERATE_7Z_ID(kDeveloperID, kSubID);
WriteNumber(kID);
const unsigned kPropsSize = 5; // it's example size
WriteNumber(kPropsSize);
for (unsigned i = 0; i < kPropsSize; i++)
WriteByte((Byte)(i + 16));
}
WriteByte(NID::kEnd);
}
*/
if (db.Folders.Size() > 0)
{
WriteByte(NID::kMainStreamsInfo);
WritePackInfo(0, db.PackSizes, db.PackCRCs);
WriteUnpackInfo(db.Folders, (const COutFolders &)db);
CRecordVector<UInt64> unpackSizes;
CUInt32DefVector digests;
FOR_VECTOR (i, db.Files)
{
const CFileItem &file = db.Files[i];
if (!file.HasStream)
continue;
unpackSizes.Add(file.Size);
digests.Defs.Add(file.CrcDefined);
digests.Vals.Add(file.Crc);
}
WriteSubStreamsInfo(db.Folders, (const COutFolders &)db, unpackSizes, digests);
WriteByte(NID::kEnd);
}
if (db.Files.IsEmpty())
{
WriteByte(NID::kEnd);
return;
}
WriteByte(NID::kFilesInfo);
WriteNumber(db.Files.Size());
{
/* ---------- Empty Streams ---------- */
CBoolVector emptyStreamVector;
emptyStreamVector.ClearAndSetSize(db.Files.Size());
unsigned numEmptyStreams = 0;
{
FOR_VECTOR (i, db.Files)
if (db.Files[i].HasStream)
emptyStreamVector[i] = false;
else
{
emptyStreamVector[i] = true;
numEmptyStreams++;
}
}
if (numEmptyStreams != 0)
{
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)
{
const CFileItem &file = db.Files[i];
if (file.HasStream)
continue;
emptyFileVector[cur] = !file.IsDir;
if (!file.IsDir)
thereAreEmptyFiles = true;
bool isAnti = db.IsItemAnti(i);
antiVector[cur] = isAnti;
if (isAnti)
thereAreAntiItems = true;
cur++;
}
if (thereAreEmptyFiles)
WritePropBoolVector(NID::kEmptyFile, emptyFileVector);
if (thereAreAntiItems)
WritePropBoolVector(NID::kAnti, antiVector);
}
}
{
/* ---------- Names ---------- */
size_t namesDataSize = 0;
{
FOR_VECTOR (i, db.Files)
{
const UString &name = db.Names[i];
const size_t numUtfChars =
/*
#if WCHAR_MAX > 0xffff
Get_Num_Utf16_chars_from_wchar_string(name.Ptr());
#else
*/
name.Len();
// #endif
namesDataSize += numUtfChars;
}
}
if (namesDataSize)
{
namesDataSize += db.Files.Size(); // we will write tail zero wchar for each name
namesDataSize *= 2; // 2 bytes per wchar for UTF16 encoding
namesDataSize++; // for additional switch byte (zero value)
SkipToAligned(2 + GetBigNumberSize(namesDataSize), 4);
WriteByte(NID::kName);
WriteNumber(namesDataSize);
if (_countMode)
_countSize += namesDataSize;
else
{
WriteByte(0);
FOR_VECTOR (i, db.Files)
{
const UString &name = db.Names[i];
const wchar_t *p = name.Ptr();
const size_t len = (size_t)name.Len() + 1;
const wchar_t * const lim = p + len;
if (_writeToStream)
{
do
{
const wchar_t c = *p++;
WriteByte_ToStream((Byte)c);
WriteByte_ToStream((Byte)(c >> 8));
}
while (p != lim);
}
else
{
Byte *dest = _outByte2.GetDest_and_Update(len * 2);
do
{
/*
#if WCHAR_MAX > 0xffff
if (c >= 0x10000)
{
c -= 0x10000;
if (c < (1 << 20))
{
unsigned c0 = 0xd800 + ((c >> 10) & 0x3FF);
WriteByte((Byte)c0);
WriteByte((Byte)(c0 >> 8));
c = 0xdc00 + (c & 0x3FF);
}
else
c = '_'; // we change character unsupported by UTF16
}
#endif
*/
const wchar_t c = *p++;
SetUi16(dest, (UInt16)c)
dest += 2;
}
while (p != lim);
}
}
}
}
}
/* if (headerOptions.WriteCTime) */ Write_UInt64DefVector_type(db.CTime, NID::kCTime);
/* if (headerOptions.WriteATime) */ Write_UInt64DefVector_type(db.ATime, NID::kATime);
/* if (headerOptions.WriteMTime) */ Write_UInt64DefVector_type(db.MTime, NID::kMTime);
Write_UInt64DefVector_type(db.StartPos, NID::kStartPos);
{
/* ---------- Write Attrib ---------- */
const unsigned numDefined = BoolVector_CountSum(db.Attrib.Defs);
if (numDefined != 0)
{
WriteAlignedBools(db.Attrib.Defs, numDefined, NID::kWinAttrib, 2);
Write_UInt32DefVector_numDefined(db.Attrib, numDefined);
}
}
/*
{
// ---------- Write IsAux ----------
if (BoolVector_CountSum(db.IsAux) != 0)
WritePropBoolVector(NID::kIsAux, db.IsAux);
}
{
// ---------- Write Parent ----------
CBoolVector boolVector;
boolVector.Reserve(db.Files.Size());
unsigned numIsDir = 0;
unsigned numParentLinks = 0;
for (i = 0; i < db.Files.Size(); i++)
{
const CFileItem &file = db.Files[i];
bool defined = !file.IsAltStream;
boolVector.Add(defined);
if (defined)
numIsDir++;
if (file.Parent >= 0)
numParentLinks++;
}
if (numParentLinks > 0)
{
// WriteAlignedBools(boolVector, numDefined, NID::kParent, 2);
const unsigned bvSize = (numIsDir == boolVector.Size()) ? 0 : Bv_GetSizeInBytes(boolVector);
const UInt64 dataSize = (UInt64)db.Files.Size() * 4 + bvSize + 1;
SkipToAligned(2 + (unsigned)bvSize + (unsigned)GetBigNumberSize(dataSize), 2);
WriteByte(NID::kParent);
WriteNumber(dataSize);
Write_BoolVector_numDefined(boolVector, numIsDir);
for (i = 0; i < db.Files.Size(); i++)
{
const CFileItem &file = db.Files[i];
// 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]);
SkipToAligned(2 + GetBigNumberSize(secureDataSize), 2);
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 CArchiveDatabaseOut &db,
const CCompressionMethodMode *options,
const CHeaderOptions &headerOptions)
{
if (!db.CheckNumFiles())
return E_FAIL;
CStartHeader sh;
sh.NextHeaderOffset = 0;
sh.NextHeaderSize = 0;
sh.NextHeaderCRC = 0; // CrcCalc(NULL, 0);
if (!db.IsEmpty())
{
CMyComPtr2_Create<ISequentialOutStream, COutStreamWithCRC> crcStream;
crcStream->SetStream(SeqStream);
crcStream->Init();
bool encodeHeaders = false;
if (options)
if (options->IsEmpty())
options = NULL;
if (options)
if (options->PasswordIsDefined || headerOptions.CompressMainHeader)
encodeHeaders = true;
if (!_outByte.Create(1 << 16))
return E_OUTOFMEMORY;
_outByte.SetStream(crcStream.Interface());
_outByte.Init();
// _crc = CRC_INIT_VAL;
_countMode = encodeHeaders;
_writeToStream = true;
_countSize = 0;
WriteHeader(db, /* headerOptions, */ sh.NextHeaderOffset);
if (encodeHeaders)
{
CByteBuffer buf(_countSize);
_outByte2.Init((Byte *)buf, _countSize);
_countMode = false;
_writeToStream = false;
WriteHeader(db, /* headerOptions, */ sh.NextHeaderOffset);
if (_countSize != _outByte2.GetPos())
return E_FAIL;
CCompressionMethodMode encryptOptions;
encryptOptions.PasswordIsDefined = options->PasswordIsDefined;
encryptOptions.Password = options->Password;
CEncoder encoder(headerOptions.CompressMainHeader ? *options : encryptOptions);
CRecordVector<UInt64> packSizes;
CObjectVector<CFolder> folders;
COutFolders outFolders;
RINOK(EncodeStream(
EXTERNAL_CODECS_LOC_VARS
encoder, buf,
packSizes, folders, outFolders))
_writeToStream = true;
if (folders.Size() == 0)
throw 1;
WriteID(NID::kEncodedHeader);
WritePackInfo(sh.NextHeaderOffset, packSizes, CUInt32DefVector());
WriteUnpackInfo(folders, outFolders);
WriteByte(NID::kEnd);
sh.NextHeaderOffset += UInt64Vector_CountSum(packSizes);
}
RINOK(_outByte.Flush())
sh.NextHeaderCRC = crcStream->GetCRC();
// sh.NextHeaderCRC = CRC_GET_DIGEST(_crc);
// if (CRC_GET_DIGEST(_crc) != sh.NextHeaderCRC) throw 1;
sh.NextHeaderSize = _outByte.GetProcessedSize();
}
#ifdef Z7_7Z_VOL
if (_endMarker)
{
CFinishHeader h;
h.NextHeaderSize = headerSize;
h.NextHeaderCRC = headerCRC;
h.NextHeaderOffset =
UInt64(0) - (headerSize +
4 + kFinishHeaderSize);
h.ArchiveStartOffset = h.NextHeaderOffset - headerOffset;
h.AdditionalStartBlockSize = 0;
RINOK(WriteFinishHeader(h));
return WriteFinishSignature();
}
else
#endif
if (Stream)
{
RINOK(Stream->Seek((Int64)_signatureHeaderPos, STREAM_SEEK_SET, NULL))
return WriteStartHeader(sh);
}
return S_OK;
}
void CUInt32DefVector::SetItem(unsigned index, bool defined, UInt32 value)
{
while (index >= Defs.Size())
Defs.Add(false);
Defs[index] = defined;
if (!defined)
return;
while (index >= Vals.Size())
Vals.Add(0);
Vals[index] = value;
}
void CUInt64DefVector::SetItem(unsigned index, bool defined, UInt64 value)
{
while (index >= Defs.Size())
Defs.Add(false);
Defs[index] = defined;
if (!defined)
return;
while (index >= Vals.Size())
Vals.Add(0);
Vals[index] = value;
}
void CArchiveDatabaseOut::AddFile(const CFileItem &file, const CFileItem2 &file2, const UString &name)
{
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);
Attrib.SetItem(index, file2.AttribDefined, file2.Attrib);
SetItem_Anti(index, file2.IsAnti);
// SetItem_Aux(index, file2.IsAux);
Names.Add(name);
Files.Add(file);
}
}}
Reference in New Issue View Git Blame Copy Permalink