public void Write(Stream inputStream, bool encrypt = false, bool seek = true)
{
_header.ArchiveFlags = encrypt ? 4U : 0U;
_header.TOCEntrySize = 30U;
WriteManifest();
//Pack entries
List<uint> zLengths;
Dictionary<Entry, byte[]> zStreams;
DeflateEntries(out zStreams, out zLengths);
//Build zLengths
_writer = new BigEndianBinaryWriter(inputStream);
_header.TotalTOCSize = (uint)(32 + _toc.Count * _header.TOCEntrySize + zLengths.Count * bNum);
_toc[0].Offset = _header.TotalTOCSize;
for (int i = 1; i < _toc.Count; i++)
{
_toc[i].Offset = _toc[i - 1].Offset + (ulong)(zStreams[_toc[i - 1]].Length);
}
//Write Header
_writer.Write(_header.MagicNumber);
_writer.Write(_header.VersionNumber);
_writer.Write(_header.CompressionMethod);
_writer.Write(_header.TotalTOCSize);
_writer.Write(_header.TOCEntrySize);
_writer.Write(_toc.Count);
_writer.Write(_header.BlockSizeAlloc);
_writer.Write(_header.ArchiveFlags);
//Write Table of contents
foreach (Entry current in _toc)
{
current.UpdateNameMD5();
_writer.Write(current.MD5);
_writer.Write(current.zIndexBegin);
_writer.WriteUInt40((ulong)current.Data.Length);//current.Length
_writer.WriteUInt40(current.Offset);
}
foreach (uint zLen in zLengths)
{
switch (bNum)
{
case 2://16bit
_writer.Write((ushort)zLen);
break;
case 3://24bit
_writer.WriteUInt24(zLen);
break;
case 4://32bit
_writer.Write(zLen);
break;
}
}
zLengths = null;
// Write zData
var ndx = 0; // for debugging
var step = Math.Round(1D / (this.TOC.Count + 2) * 100, 3);
double progress = 0;
GlobalExtension.ShowProgress("Writing Zipped Data ...");
foreach (Entry current in _toc)
{
_writer.Write(zStreams[current]);
progress += step;
GlobalExtension.UpdateProgress.Value = (int)progress;
Debug.WriteLine("Zipped: " + ndx++);
current.Data.Close();
}
zStreams = null;
if (encrypt) // Encrypt TOC
{
using (var outputStream = new MemoryStreamExtension())
{
var encStream = new MemoryStreamExtension();
inputStream.Position = 32L;
RijndaelEncryptor.EncryptPSARC(inputStream, outputStream, _header.TotalTOCSize);
inputStream.Position = 0L;
// quick copy header from input stream
var buffer = new byte[32];
encStream.Write(buffer, 0, inputStream.Read(buffer, 0, buffer.Length));
encStream.Position = 32; //sainty check ofc
inputStream.Flush();
int tocSize = (int)_header.TotalTOCSize - 32;
int decSize = 0;
buffer = new byte[1024 * 16]; // more effecient use of memory
ndx = 0; // for debuging
step = Math.Round(1D / (((double)tocSize / buffer.Length) + 2) * 100, 3);
progress = 0;
GlobalExtension.ShowProgress("Writing Encrypted Data ...");
int bytesRead;
while ((bytesRead = outputStream.Read(buffer, 0, buffer.Length)) > 0)
{
decSize += bytesRead;
if (decSize > tocSize)
bytesRead = tocSize - (decSize - bytesRead);
encStream.Write(buffer, 0, bytesRead);
progress += step;
GlobalExtension.UpdateProgress.Value = (int)progress;
Debug.WriteLine("Encrypted: " + ndx++);
}
inputStream.Position = 0;
encStream.Position = 0;
encStream.CopyTo(inputStream, (int)_header.BlockSizeAlloc);
}
}
if (seek) // May be redundant
{
inputStream.Flush();
inputStream.Position = 0;
}
GlobalExtension.HideProgress();
}
public void Write(Stream str, bool encrypt)
{
if (encrypt)
this.header.archiveFlags = 4;
this.header.TOCEntrySize = 30;
this.UpdateManifest();
Dictionary<Entry, byte[]> dictionary;
List<uint> list;
this.deflateEntries(out dictionary, out list, this.header.blockSize);
byte b = 1;
uint num = 256;
do
{
num *= 256;
b += 1;
}
while (num < this.header.blockSize);
BigEndianBinaryWriter bigEndianBinaryWriter = new BigEndianBinaryWriter(str);
this.header.TotalTOCSize = (uint)(32 + this.header.TOCEntrySize * (this.Entries.Count) + ((int)b * list.Count));
this.Entries[0].Offset = (ulong)this.header.TotalTOCSize;
for (int i = 1; i < this.Entries.Count; i++)
{
this.Entries[i].Offset = this.Entries[i - 1].Offset + (ulong)(dictionary[this.Entries[i - 1]].Length);
}
bigEndianBinaryWriter.Write(this.header.MagicNumber);
bigEndianBinaryWriter.Write(this.header.VersionNumber);
bigEndianBinaryWriter.Write(this.header.CompressionMethod);
bigEndianBinaryWriter.Write(this.header.TotalTOCSize);
bigEndianBinaryWriter.Write(this.header.TOCEntrySize);
bigEndianBinaryWriter.Write(this.Entries.Count);
bigEndianBinaryWriter.Write(this.header.blockSize);
bigEndianBinaryWriter.Write(this.header.archiveFlags);
foreach (Entry current in this.Entries)
{
current.UpdateNameMD5();
bigEndianBinaryWriter.Write((current.id == 0) ? new byte[16] : current.MD5);
bigEndianBinaryWriter.Write(current.zIndex);
bigEndianBinaryWriter.WriteUInt40((ulong)current.Data.Length);
bigEndianBinaryWriter.WriteUInt40(current.Offset);
}
foreach (uint current2 in list)
{
switch (b)
{
case 2:
bigEndianBinaryWriter.Write((ushort)current2);
break;
case 3:
bigEndianBinaryWriter.WriteUInt24(current2);
break;
case 4:
bigEndianBinaryWriter.Write(current2);
break;
}
}
foreach (Entry current in this.Entries)
{
bigEndianBinaryWriter.Write(dictionary[current]);
}
if (encrypt)
{
var encStream = new MemoryStreamExtension();
using (var outputStream = new MemoryStreamExtension())
{
str.Seek(32, SeekOrigin.Begin);
RijndaelEncryptor.EncryptPSARC(str, outputStream, this.header.TotalTOCSize);
int bytesRead;
byte[] buffer = new byte[30000];
str.Seek(0, SeekOrigin.Begin);
while ((bytesRead = str.Read(buffer, 0, buffer.Length)) > 0)
encStream.Write(buffer, 0, bytesRead);
int decMax = (int)this.header.TotalTOCSize - 32;
int decSize = 0;
outputStream.Seek(0, SeekOrigin.Begin);
encStream.Seek(32, SeekOrigin.Begin);
while ((bytesRead = outputStream.Read(buffer, 0, buffer.Length)) > 0)
{
decSize += bytesRead;
if (decSize > decMax) bytesRead = decMax - (decSize - bytesRead);
encStream.Write(buffer, 0, bytesRead);
}
}
str.Seek(0, SeekOrigin.Begin);
encStream.Seek(0, SeekOrigin.Begin);
encStream.CopyTo(str);
}
str.Flush();
}