starred/sharpcompress
1
0
Fork 0
mirror of https://github.com/adamhathcock/sharpcompress.git synced 2026-09-22 23:15:20 +00:00
Code Issues 975 Packages Projects Releases 25 Wiki Activity

Merge pull request #119 from benshoof/endian-neutral

Browse Source 
SharpCompress now endian neutral
This commit is contained in:
Adam Hathcock
2016-01-26 11:51:30 +00:00
parent 0de64b1551 8ceac9000c
commit 681b28f654
30 changed files with 2208 additions and 334 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
SharpCompress/Common/GZip/GZipFilePart.cs
View File

@@ -3,6 +3,7 @@ using System.IO;
using SharpCompress.Common.Tar.Headers;
using SharpCompress.Compressor;
using SharpCompress.Compressor.Deflate;
using SharpCompress.Converter;
namespace SharpCompress.Common.GZip
{
@@ -50,7 +51,7 @@ namespace SharpCompress.Common.GZip
if (header[0] != 0x1F || header[1] != 0x8B || header[2] != 8)
throw new ZlibException("Bad GZIP header.");
Int32 timet = BitConverter.ToInt32(header, 4);
Int32 timet = DataConverter.LittleEndian.GetInt32(header, 4);
DateModified = TarHeader.Epoch.AddSeconds(timet);
if ((header[3] & 0x04) == 0x04)
{

14
SharpCompress/Common/Tar/Headers/TarHeader.cs
View File

@@ -4,6 +4,7 @@ using System.IO;
using System.Net;
#endif
using System.Text;
using SharpCompress.Converter;
namespace SharpCompress.Common.Tar.Headers
{
@@ -64,11 +65,7 @@ namespace SharpCompress.Common.Tar.Headers
if (Size >= 0x1FFFFFFFF)
{
#if PORTABLE || NETFX_CORE
byte[] bytes = BitConverter.GetBytes(Utility.HostToNetworkOrder(Size));
#else
byte[] bytes = BitConverter.GetBytes(IPAddress.HostToNetworkOrder(Size));
#endif
byte[] bytes = DataConverter.BigEndian.GetBytes(Size);
var bytes12 = new byte[12];
bytes.CopyTo(bytes12, 12 - bytes.Length);
bytes12[0] |= 0x80;
@@ -119,12 +116,7 @@ namespace SharpCompress.Common.Tar.Headers
EntryType = (EntryType) buffer[156];
if ((buffer[124] & 0x80) == 0x80) // if size in binary
{
long sizeBigEndian = BitConverter.ToInt64(buffer, 0x80);
#if PORTABLE || NETFX_CORE
Size = Utility.NetworkToHostOrder(sizeBigEndian);
#else
Size = IPAddress.NetworkToHostOrder(sizeBigEndian);
#endif
Size = DataConverter.BigEndian.GetInt64(buffer, 0x80);
}
else
{

5
SharpCompress/Common/Zip/Headers/ZipFileEntry.cs
View File

@@ -2,6 +2,7 @@
using System.Collections.Generic;
using System.IO;
using System.Text;
using SharpCompress.Converter;
namespace SharpCompress.Common.Zip.Headers
{
@@ -68,13 +69,13 @@ namespace SharpCompress.Common.Zip.Headers
{
for (int i = 0; i < extra.Length-4;)
{
ExtraDataType type = (ExtraDataType) BitConverter.ToUInt16(extra, i);
ExtraDataType type = (ExtraDataType)DataConverter.LittleEndian.GetUInt16(extra, i);
if (!Enum.IsDefined(typeof (ExtraDataType), type))
{
type = ExtraDataType.NotImplementedExtraData;
}
ushort length = BitConverter.ToUInt16(extra, i + 2);
ushort length = DataConverter.LittleEndian.GetUInt16(extra, i + 2);
byte[] data = new byte[length];
Buffer.BlockCopy(extra, i + 4, data, 0, length);
Extra.Add(LocalEntryHeaderExtraFactory.Create(type,length,data));

3
SharpCompress/Common/Zip/WinzipAesCryptoStream.Portable.cs
View File

@@ -3,6 +3,7 @@ using System.IO;
using Org.BouncyCastle.Crypto;
using Org.BouncyCastle.Crypto.Engines;
using Org.BouncyCastle.Crypto.Parameters;
using SharpCompress.Converter;
namespace SharpCompress.Common.Zip
{
@@ -113,7 +114,7 @@ namespace SharpCompress.Common.Zip
: bytesRemaining;
// update the counter
Array.Copy(BitConverter.GetBytes(nonce++), 0, counter, 0, 4);
DataConverter.LittleEndian.PutBytes(counter, 0, nonce++);
// Determine if this is the final block
if ((bytesToRead == bytesRemaining) && (totalBytesLeftToRead == 0))

3
SharpCompress/Common/Zip/WinzipAesCryptoStream.cs
View File

@@ -1,6 +1,7 @@
using System;
using System.IO;
using System.Security.Cryptography;
using SharpCompress.Converter;
namespace SharpCompress.Common.Zip
{
@@ -117,7 +118,7 @@ namespace SharpCompress.Common.Zip
: bytesRemaining;
// update the counter
Array.Copy(BitConverter.GetBytes(nonce++), 0, counter, 0, 4);
DataConverter.LittleEndian.PutBytes(counter, 0, nonce++);
// Determine if this is the final block
if ((bytesToRead == bytesRemaining) && (totalBytesLeftToRead == 0))

5
SharpCompress/Common/Zip/WinzipAesEncryptionData.Portable.cs
View File

@@ -1,5 +1,6 @@
using System;
using System.Text;
using SharpCompress.Converter;
using SharpCompress.Crypto;
namespace SharpCompress.Common.Zip
@@ -56,10 +57,10 @@ namespace SharpCompress.Common.Zip
generatedVerifyValue = paramz.GetBytes(2);
short verify = BitConverter.ToInt16(passwordVerifyValue, 0);
short verify = DataConverter.LittleEndian.GetInt16(passwordVerifyValue, 0);
if (password != null)
{
short generated = BitConverter.ToInt16(generatedVerifyValue, 0);
short generated = DataConverter.LittleEndian.GetInt16(generatedVerifyValue, 0);
if (verify != generated)
throw new InvalidFormatException("bad password");
}

5
SharpCompress/Common/Zip/WinzipAesEncryptionData.cs
View File

@@ -1,4 +1,5 @@
using System;
using SharpCompress.Converter;
namespace SharpCompress.Common.Zip
{
@@ -54,10 +55,10 @@ namespace SharpCompress.Common.Zip
IvBytes = rfc2898.GetBytes(KeySizeInBytes);
generatedVerifyValue = rfc2898.GetBytes(2);
short verify = BitConverter.ToInt16(passwordVerifyValue, 0);
short verify = DataConverter.LittleEndian.GetInt16(passwordVerifyValue, 0);
if (password != null)
{
short generated = BitConverter.ToInt16(generatedVerifyValue, 0);
short generated = DataConverter.LittleEndian.GetInt16(generatedVerifyValue, 0);
if (verify != generated)
throw new InvalidFormatException("bad password");
}

7
SharpCompress/Common/Zip/ZipFilePart.cs
View File

@@ -7,6 +7,7 @@ using SharpCompress.Compressor.BZip2;
using SharpCompress.Compressor.Deflate;
using SharpCompress.Compressor.LZMA;
using SharpCompress.Compressor.PPMd;
using SharpCompress.Converter;
using SharpCompress.IO;
namespace SharpCompress.Common.Zip
@@ -108,19 +109,19 @@ namespace SharpCompress.Common.Zip
{
throw new InvalidFormatException("Winzip data length is not 7.");
}
ushort method = BitConverter.ToUInt16(data.DataBytes, 0);
ushort method = DataConverter.LittleEndian.GetUInt16(data.DataBytes, 0);
if (method != 0x01 && method != 0x02)
{
throw new InvalidFormatException("Unexpected vendor version number for WinZip AES metadata");
}
ushort vendorId = BitConverter.ToUInt16(data.DataBytes, 2);
ushort vendorId = DataConverter.LittleEndian.GetUInt16(data.DataBytes, 2);
if (vendorId != 0x4541)
{
throw new InvalidFormatException("Unexpected vendor ID for WinZip AES metadata");
}
Header.CompressionMethod = (ZipCompressionMethod)BitConverter.ToUInt16(data.DataBytes, 5);
Header.CompressionMethod = (ZipCompressionMethod)DataConverter.LittleEndian.GetUInt16(data.DataBytes, 5);
return CreateDecompressionStream(stream);
}
default:

3
SharpCompress/Compressor/Deflate/GZipStream.cs
View File

@@ -30,6 +30,7 @@
using System;
using System.IO;
using SharpCompress.Common;
using SharpCompress.Converter;
namespace SharpCompress.Compressor.Deflate
{
@@ -417,7 +418,7 @@ namespace SharpCompress.Compressor.Deflate
LastModified = DateTime.Now;
TimeSpan delta = LastModified.Value - UnixEpoch;
var timet = (Int32) delta.TotalSeconds;
Array.Copy(BitConverter.GetBytes(timet), 0, header, i, 4);
DataConverter.LittleEndian.PutBytes(header, i, timet);
i += 4;
// xflg

11
SharpCompress/Compressor/Deflate/ZlibBaseStream.cs
View File

@@ -27,6 +27,7 @@
using System;
using SharpCompress.Common;
using SharpCompress.Common.Tar.Headers;
using SharpCompress.Converter;
namespace SharpCompress.Compressor.Deflate
{
@@ -221,9 +222,9 @@ namespace SharpCompress.Compressor.Deflate
{
// Emit the GZIP trailer: CRC32 and size mod 2^32
int c1 = crc.Crc32Result;
_stream.Write(BitConverter.GetBytes(c1), 0, 4);
_stream.Write(DataConverter.LittleEndian.GetBytes(c1), 0, 4);
int c2 = (Int32)(crc.TotalBytesRead & 0x00000000FFFFFFFF);
_stream.Write(BitConverter.GetBytes(c2), 0, 4);
_stream.Write(DataConverter.LittleEndian.GetBytes(c2), 0, 4);
}
else
{
@@ -267,9 +268,9 @@ namespace SharpCompress.Compressor.Deflate
}
Int32 crc32_expected = BitConverter.ToInt32(trailer, 0);
Int32 crc32_expected = DataConverter.LittleEndian.GetInt32(trailer, 0);
Int32 crc32_actual = crc.Crc32Result;
Int32 isize_expected = BitConverter.ToInt32(trailer, 4);
Int32 isize_expected = DataConverter.LittleEndian.GetInt32(trailer, 4);
Int32 isize_actual = (Int32)(_z.TotalBytesOut & 0x00000000FFFFFFFF);
if (crc32_actual != crc32_expected)
@@ -405,7 +406,7 @@ namespace SharpCompress.Compressor.Deflate
if (header[0] != 0x1F || header[1] != 0x8B || header[2] != 8)
throw new ZlibException("Bad GZIP header.");
Int32 timet = BitConverter.ToInt32(header, 4);
Int32 timet = DataConverter.LittleEndian.GetInt32(header, 4);
_GzipMtime = TarHeader.Epoch.AddSeconds(timet);
totalBytesRead += n;
if ((header[3] & 0x04) == 0x04)

3
SharpCompress/Compressor/LZMA/LzmaStream.cs
View File

@@ -1,6 +1,7 @@
using System;
using System.IO;
using SharpCompress.Compressor.LZMA.LZ;
using SharpCompress.Converter;
namespace SharpCompress.Compressor.LZMA
{
@@ -56,7 +57,7 @@ namespace SharpCompress.Compressor.LZMA
if (!isLZMA2)
{
dictionarySize = BitConverter.ToInt32(properties, 1);
dictionarySize = DataConverter.LittleEndian.GetInt32(properties, 1);
outWindow.Create(dictionarySize);
if (presetDictionary != null)
outWindow.Train(presetDictionary);

13
SharpCompress/Compressor/PPMd/H/FreqData.cs
View File

@@ -1,4 +1,5 @@
using System.Text;
using SharpCompress.Converter;
namespace SharpCompress.Compressor.PPMd.H
{
@@ -19,9 +20,9 @@ namespace SharpCompress.Compressor.PPMd.H
internal int SummFreq
{
get { return Utility.readShortLittleEndian(Memory, Address) & 0xffff; }
get { return DataConverter.LittleEndian.GetInt16(Memory, Address) & 0xffff; }
set { Utility.WriteLittleEndian(Memory, Address, (short) value); }
set { DataConverter.LittleEndian.PutBytes(Memory, Address, (short)value); }
}
internal FreqData Initialize(byte[] mem)
@@ -31,12 +32,14 @@ namespace SharpCompress.Compressor.PPMd.H
internal void IncrementSummFreq(int dSummFreq)
{
Utility.incShortLittleEndian(Memory, Address, (short) dSummFreq);
short summFreq = DataConverter.LittleEndian.GetInt16(Memory, Address);
summFreq += (short)dSummFreq;
DataConverter.LittleEndian.PutBytes(Memory, Address, summFreq);
}
internal int GetStats()
{
return Utility.readIntLittleEndian(Memory, Address + 2);
return DataConverter.LittleEndian.GetInt32(Memory, Address + 2);
}
internal virtual void SetStats(State state)
@@ -46,7 +49,7 @@ namespace SharpCompress.Compressor.PPMd.H
internal void SetStats(int state)
{
Utility.WriteLittleEndian(Memory, Address + 2, state);
DataConverter.LittleEndian.PutBytes(Memory, Address + 2, state);
}
public override System.String ToString()

9
SharpCompress/Compressor/PPMd/H/PPMContext.cs
View File

@@ -1,4 +1,5 @@
using System.Text;
using SharpCompress.Converter;
namespace SharpCompress.Compressor.PPMd.H
{
@@ -21,7 +22,7 @@ namespace SharpCompress.Compressor.PPMd.H
{
if (Memory != null)
{
numStats = Utility.readShortLittleEndian(Memory, Address) & 0xffff;
numStats = DataConverter.LittleEndian.GetInt16(Memory, Address) & 0xffff;
}
return numStats;
}
@@ -31,7 +32,7 @@ namespace SharpCompress.Compressor.PPMd.H
this.numStats = value & 0xffff;
if (Memory != null)
{
Utility.WriteLittleEndian(Memory, Address, (short) value);
DataConverter.LittleEndian.PutBytes(Memory, Address, (short) value);
}
}
}
@@ -103,7 +104,7 @@ namespace SharpCompress.Compressor.PPMd.H
{
if (Memory != null)
{
suffix = Utility.readIntLittleEndian(Memory, Address + 8);
suffix = DataConverter.LittleEndian.GetInt32(Memory, Address + 8);
}
return suffix;
}
@@ -118,7 +119,7 @@ namespace SharpCompress.Compressor.PPMd.H
this.suffix = suffix;
if (Memory != null)
{
Utility.WriteLittleEndian(Memory, Address + 8, suffix);
DataConverter.LittleEndian.PutBytes(Memory, Address + 8, suffix);
}
}

18
SharpCompress/Compressor/PPMd/H/RarMemBlock.cs
View File

@@ -1,3 +1,5 @@
using SharpCompress.Converter;
namespace SharpCompress.Compressor.PPMd.H
{
internal class RarMemBlock : Pointer
@@ -19,7 +21,7 @@ namespace SharpCompress.Compressor.PPMd.H
{
if (Memory != null)
{
stamp = Utility.readShortLittleEndian(Memory, Address) & 0xffff;
stamp = DataConverter.LittleEndian.GetInt16(Memory, Address) & 0xffff;
}
return stamp;
}
@@ -29,7 +31,7 @@ namespace SharpCompress.Compressor.PPMd.H
this.stamp = value;
if (Memory != null)
{
Utility.WriteLittleEndian(Memory, Address, (short) value);
DataConverter.LittleEndian.PutBytes(Memory, Address, (short)value);
}
}
}
@@ -60,7 +62,7 @@ namespace SharpCompress.Compressor.PPMd.H
{
if (Memory != null)
{
next = Utility.readIntLittleEndian(Memory, Address + 4);
next = DataConverter.LittleEndian.GetInt32(Memory, Address + 4);
}
return next;
}
@@ -75,7 +77,7 @@ namespace SharpCompress.Compressor.PPMd.H
this.next = next;
if (Memory != null)
{
Utility.WriteLittleEndian(Memory, Address + 4, next);
DataConverter.LittleEndian.PutBytes(Memory, Address + 4, next);
}
}
@@ -83,7 +85,7 @@ namespace SharpCompress.Compressor.PPMd.H
{
if (Memory != null)
{
NU = Utility.readShortLittleEndian(Memory, Address + 2) & 0xffff;
NU = DataConverter.LittleEndian.GetInt16(Memory, Address + 2) & 0xffff;
}
return NU;
}
@@ -93,7 +95,7 @@ namespace SharpCompress.Compressor.PPMd.H
NU = nu & 0xffff;
if (Memory != null)
{
Utility.WriteLittleEndian(Memory, Address + 2, (short) nu);
DataConverter.LittleEndian.PutBytes(Memory, Address + 2, (short)nu);
}
}
@@ -101,7 +103,7 @@ namespace SharpCompress.Compressor.PPMd.H
{
if (Memory != null)
{
prev = Utility.readIntLittleEndian(Memory, Address + 8);
prev = DataConverter.LittleEndian.GetInt32(Memory, Address + 8);
}
return prev;
}
@@ -116,7 +118,7 @@ namespace SharpCompress.Compressor.PPMd.H
this.prev = prev;
if (Memory != null)
{
Utility.WriteLittleEndian(Memory, Address + 8, prev);
DataConverter.LittleEndian.PutBytes(Memory, Address + 8, prev);
}
}
}

5
SharpCompress/Compressor/PPMd/H/RarNode.cs
View File

@@ -1,4 +1,5 @@
using System.Text;
using SharpCompress.Converter;
namespace SharpCompress.Compressor.PPMd.H
{
@@ -17,7 +18,7 @@ namespace SharpCompress.Compressor.PPMd.H
{
if (Memory != null)
{
next = Utility.readIntLittleEndian(Memory, Address);
next = DataConverter.LittleEndian.GetInt32(Memory, Address);
}
return next;
}
@@ -32,7 +33,7 @@ namespace SharpCompress.Compressor.PPMd.H
this.next = next;
if (Memory != null)
{
Utility.WriteLittleEndian(Memory, Address, next);
DataConverter.LittleEndian.PutBytes(Memory, Address, next);
}
}

5
SharpCompress/Compressor/PPMd/H/State.cs
View File

@@ -1,5 +1,6 @@
using System;
using System.Text;
using SharpCompress.Converter;
namespace SharpCompress.Compressor.PPMd.H
{
@@ -38,7 +39,7 @@ namespace SharpCompress.Compressor.PPMd.H
internal int GetSuccessor()
{
return Utility.readIntLittleEndian(Memory, Address + 2);
return DataConverter.LittleEndian.GetInt32(Memory, Address + 2);
}
internal void SetSuccessor(PPMContext successor)
@@ -48,7 +49,7 @@ namespace SharpCompress.Compressor.PPMd.H
internal void SetSuccessor(int successor)
{
Utility.WriteLittleEndian(Memory, Address + 2, successor);
DataConverter.LittleEndian.PutBytes(Memory, Address + 2, successor);
}
internal void SetValues(StateRef state)

7
SharpCompress/Compressor/PPMd/PpmdProperties.cs
View File

@@ -1,4 +1,5 @@
using System;
using SharpCompress.Converter;
namespace SharpCompress.Compressor.PPMd
{
@@ -39,7 +40,7 @@ namespace SharpCompress.Compressor.PPMd
{
if (properties.Length == 2)
{
ushort props = BitConverter.ToUInt16(properties, 0);
ushort props = DataConverter.LittleEndian.GetUInt16(properties, 0);
AllocatorSize = (((props >> 4) & 0xff) + 1) << 20;
ModelOrder = (props & 0x0f) + 1;
ModelRestorationMethod = (I1.ModelRestorationMethod) (props >> 12);
@@ -47,7 +48,7 @@ namespace SharpCompress.Compressor.PPMd
else if (properties.Length == 5)
{
Version = PpmdVersion.H7z;
AllocatorSize = BitConverter.ToInt32(properties, 1);
AllocatorSize = DataConverter.LittleEndian.GetInt32(properties, 1);
ModelOrder = properties[0];
}
}
@@ -72,7 +73,7 @@ namespace SharpCompress.Compressor.PPMd
get
{
return
BitConverter.GetBytes(
DataConverter.LittleEndian.GetBytes(
(ushort)
((ModelOrder - 1) + (((AllocatorSize >> 20) - 1) << 4) + ((ushort) ModelRestorationMethod << 12)));
}

22
SharpCompress/Compressor/Rar/VM/RarVM.cs
View File

@@ -1,5 +1,6 @@
using System;
using System.Collections.Generic;
using SharpCompress.Converter;
namespace SharpCompress.Compressor.Rar.VM
{
@@ -77,11 +78,12 @@ namespace SharpCompress.Compressor.Rar.VM
{
if (IsVMMem(mem))
{
return Utility.readIntLittleEndian(mem, offset);
return DataConverter.LittleEndian.GetInt32(mem, offset);
}
else
{
return Utility.readIntBigEndian(mem, offset);
return DataConverter.BigEndian.GetInt32(mem, offset);
}
}
}
@@ -103,19 +105,11 @@ namespace SharpCompress.Compressor.Rar.VM
{
if (IsVMMem(mem))
{
Utility.WriteLittleEndian(mem, offset, value);
// Mem[offset + 0] = (byte) value;
// Mem[offset + 1] = (byte) (value >>> 8);
// Mem[offset + 2] = (byte) (value >>> 16);
// Mem[offset + 3] = (byte) (value >>> 24);
DataConverter.LittleEndian.PutBytes(mem, offset, value);
}
else
{
Utility.writeIntBigEndian(mem, offset, value);
// Mem[offset + 3] = (byte) value;
// Mem[offset + 2] = (byte) (value >>> 8);
// Mem[offset + 1] = (byte) (value >>> 16);
// Mem[offset + 0] = (byte) (value >>> 24);
DataConverter.BigEndian.PutBytes(mem, offset, value);
}
}
// #define SET_VALUE(ByteMode,Addr,Value) SetValue(ByteMode,(uint
@@ -136,12 +130,12 @@ namespace SharpCompress.Compressor.Rar.VM
if (cmdOp.Type == VMOpType.VM_OPREGMEM)
{
int pos = (cmdOp.Offset + cmdOp.Base) & VM_MEMMASK;
ret = Utility.readIntLittleEndian(Mem, pos);
ret = DataConverter.LittleEndian.GetInt32(Mem, pos);
}
else
{
int pos = cmdOp.Offset;
ret = Utility.readIntLittleEndian(Mem, pos);
ret = DataConverter.LittleEndian.GetInt32(Mem, pos);
}
return ret;
}

237
SharpCompress/Converter/DataConverter.Portable.cs Normal file
View File

@@ -0,0 +1,237 @@
using System;
namespace SharpCompress.Converter
{
// This is a portable version of Mono's DataConverter class with just the small subset of functionality
// needed by SharpCompress. Portable in this case means that it contains no unsafe code.
//
// This class simply wraps BitConverter and reverses byte arrays when endianess doesn't match the host's.
//
// Everything public in this class must match signatures in Mono's DataConverter.
abstract class DataConverter
{
static readonly DataConverter copyConverter = new CopyConverter();
static readonly DataConverter swapConverter = new SwapConverter();
static readonly bool isLittleEndian = BitConverter.IsLittleEndian;
public static DataConverter LittleEndian
{
get { return isLittleEndian ? copyConverter : swapConverter; }
}
public static DataConverter BigEndian
{
get { return isLittleEndian ? swapConverter : copyConverter; }
}
public abstract Int16 GetInt16(byte[] data, int index);
public abstract UInt16 GetUInt16(byte[] data, int index);
public abstract Int32 GetInt32(byte[] data, int index);
public abstract UInt32 GetUInt32(byte[] data, int index);
public abstract Int64 GetInt64(byte[] data, int index);
public abstract UInt64 GetUInt64(byte[] data, int index);
public abstract byte[] GetBytes(Int16 value);
public abstract byte[] GetBytes(UInt16 value);
public abstract byte[] GetBytes(Int32 value);
public abstract byte[] GetBytes(UInt32 value);
public abstract byte[] GetBytes(Int64 value);
public abstract byte[] GetBytes(UInt64 value);
public void PutBytes(byte[] data, int index, Int16 value)
{
byte[] temp = GetBytes(value);
Array.Copy(temp, 0, data, index, 2);
}
public void PutBytes(byte[] data, int index, UInt16 value)
{
byte[] temp = GetBytes(value);
Array.Copy(temp, 0, data, index, 2);
}
public void PutBytes(byte[] data, int index, Int32 value)
{
byte[] temp = GetBytes(value);
Array.Copy(temp, 0, data, index, 4);
}
public void PutBytes(byte[] data, int index, UInt32 value)
{
byte[] temp = GetBytes(value);
Array.Copy(temp, 0, data, index, 4);
}
public void PutBytes(byte[] data, int index, Int64 value)
{
byte[] temp = GetBytes(value);
Array.Copy(temp, 0, data, index, 8);
}
public void PutBytes(byte[] data, int index, UInt64 value)
{
byte[] temp = GetBytes(value);
Array.Copy(temp, 0, data, index, 8);
}
// CopyConverter wraps BitConverter making all conversions host endian
class CopyConverter : DataConverter
{
public override Int16 GetInt16(byte[] data, int index)
{
return BitConverter.ToInt16(data, index);
}
public override UInt16 GetUInt16(byte[] data, int index)
{
return BitConverter.ToUInt16(data, index);
}
public override Int32 GetInt32(byte[] data, int index)
{
return BitConverter.ToInt32(data, index);
}
public override UInt32 GetUInt32(byte[] data, int index)
{
return BitConverter.ToUInt32(data, index);
}
public override Int64 GetInt64(byte[] data, int index)
{
return BitConverter.ToInt64(data, index);
}
public override UInt64 GetUInt64(byte[] data, int index)
{
return BitConverter.ToUInt64(data, index);
}
public override byte[] GetBytes(Int16 value)
{
return BitConverter.GetBytes(value);
}
public override byte[] GetBytes(UInt16 value)
{
return BitConverter.GetBytes(value);
}
public override byte[] GetBytes(Int32 value)
{
return BitConverter.GetBytes(value);
}
public override byte[] GetBytes(UInt32 value)
{
return BitConverter.GetBytes(value);
}
public override byte[] GetBytes(Int64 value)
{
return BitConverter.GetBytes(value);
}
public override byte[] GetBytes(UInt64 value)
{
return BitConverter.GetBytes(value);
}
}
// SwapConverter wraps and reverses BitConverter making all conversions the opposite of host endian
class SwapConverter : DataConverter
{
public override Int16 GetInt16(byte[] data, int index)
{
byte[] temp = new byte[2];
Array.Copy(data, index, temp, 0, 2);
Array.Reverse(temp);
return BitConverter.ToInt16(temp, 0);
}
public override UInt16 GetUInt16(byte[] data, int index)
{
byte[] temp = new byte[2];
Array.Copy(data, index, temp, 0, 2);
Array.Reverse(temp);
return BitConverter.ToUInt16(temp, 0);
}
public override Int32 GetInt32(byte[] data, int index)
{
byte[] temp = new byte[4];
Array.Copy(data, index, temp, 0, 4);
Array.Reverse(temp);
return BitConverter.ToInt32(temp, 0);
}
public override UInt32 GetUInt32(byte[] data, int index)
{
byte[] temp = new byte[4];
Array.Copy(data, index, temp, 0, 4);
Array.Reverse(temp);
return BitConverter.ToUInt32(temp, 0);
}
public override Int64 GetInt64(byte[] data, int index)
{
byte[] temp = new byte[8];
Array.Copy(data, index, temp, 0, 8);
Array.Reverse(temp);
return BitConverter.ToInt64(temp, 0);
}
public override UInt64 GetUInt64(byte[] data, int index)
{
byte[] temp = new byte[8];
Array.Copy(data, index, temp, 0, 8);
Array.Reverse(temp);
return BitConverter.ToUInt64(temp, 0);
}
public override byte[] GetBytes(Int16 value)
{
byte[] ret = BitConverter.GetBytes(value);
Array.Reverse(ret);
return ret;
}
public override byte[] GetBytes(UInt16 value)
{
byte[] ret = BitConverter.GetBytes(value);
Array.Reverse(ret);
return ret;
}
public override byte[] GetBytes(Int32 value)
{
byte[] ret = BitConverter.GetBytes(value);
Array.Reverse(ret);
return ret;
}
public override byte[] GetBytes(UInt32 value)
{
byte[] ret = BitConverter.GetBytes(value);
Array.Reverse(ret);
return ret;
}
public override byte[] GetBytes(Int64 value)
{
byte[] ret = BitConverter.GetBytes(value);
Array.Reverse(ret);
return ret;
}
public override byte[] GetBytes(UInt64 value)
{
byte[] ret = BitConverter.GetBytes(value);
Array.Reverse(ret);
return ret;
}
}
}
}

1849
SharpCompress/Converter/DataConverter.cs Normal file
View File

File diff suppressed because it is too large Load Diff

21
SharpCompress/Crypto/PBKDF2.cs
View File

@@ -3,6 +3,7 @@ using Org.BouncyCastle.Crypto;
using Org.BouncyCastle.Crypto.Digests;
using Org.BouncyCastle.Crypto.Macs;
using Org.BouncyCastle.Crypto.Parameters;
using SharpCompress.Converter;
namespace SharpCompress.Crypto
{
@@ -68,7 +69,7 @@ namespace SharpCompress.Crypto
private byte[] Hash()
{
byte[] array = UIntToOctet(block);
byte[] array = DataConverter.BigEndian.GetBytes(block);
ICipherParameters param = new KeyParameter(password);
hMac.Init(param);
@@ -96,24 +97,6 @@ namespace SharpCompress.Crypto
block += 1u;
return array3;
}
internal static byte[] UIntToOctet(uint i)
{
byte[] bytes = BitConverter.GetBytes(i);
byte[] result = new[]
{
bytes[3],
bytes[2],
bytes[1],
bytes[0]
};
if (!BitConverter.IsLittleEndian)
{
return bytes;
}
return result;
}
}
}

32
SharpCompress/IO/MarkingBinaryReader.cs
View File

@@ -1,6 +1,7 @@
using System;
using System.IO;
using System.Linq;
using SharpCompress.Converter;
namespace SharpCompress.IO
{
@@ -36,7 +37,7 @@ namespace SharpCompress.IO
public override bool ReadBoolean()
{
return BitConverter.ToBoolean(ReadBytes(1), 0);
return ReadBytes(1).Single() != 0;
}
public override byte ReadByte()
@@ -68,39 +69,28 @@ namespace SharpCompress.IO
#if !PORTABLE
public override decimal ReadDecimal()
{
return ByteArrayToDecimal(ReadBytes(16), 0);
}
private decimal ByteArrayToDecimal(byte[] src, int offset)
{
//http://stackoverflow.com/a/16984356/385387
var i1 = BitConverter.ToInt32(src, offset);
var i2 = BitConverter.ToInt32(src, offset + 4);
var i3 = BitConverter.ToInt32(src, offset + 8);
var i4 = BitConverter.ToInt32(src, offset + 12);
return new decimal(new[] { i1, i2, i3, i4 });
throw new NotSupportedException();
}
#endif
public override double ReadDouble()
{
return BitConverter.ToDouble(ReadBytes(8), 0);
throw new NotSupportedException();
}
public override short ReadInt16()
{
return BitConverter.ToInt16(ReadBytes(2), 0);
return DataConverter.LittleEndian.GetInt16(ReadBytes(2), 0);
}
public override int ReadInt32()
{
return BitConverter.ToInt32(ReadBytes(4), 0);
return DataConverter.LittleEndian.GetInt32(ReadBytes(4), 0);
}
public override long ReadInt64()
{
return BitConverter.ToInt64(ReadBytes(8), 0);
return DataConverter.LittleEndian.GetInt64(ReadBytes(8), 0);
}
public override sbyte ReadSByte()
@@ -110,7 +100,7 @@ namespace SharpCompress.IO
public override float ReadSingle()
{
return BitConverter.ToSingle(ReadBytes(4), 0);
throw new NotSupportedException();
}
public override string ReadString()
@@ -120,17 +110,17 @@ namespace SharpCompress.IO
public override ushort ReadUInt16()
{
return BitConverter.ToUInt16(ReadBytes(2), 0);
return DataConverter.LittleEndian.GetUInt16(ReadBytes(2), 0);
}
public override uint ReadUInt32()
{
return BitConverter.ToUInt32(ReadBytes(4), 0);
return DataConverter.LittleEndian.GetUInt32(ReadBytes(4), 0);
}
public override ulong ReadUInt64()
{
return BitConverter.ToUInt64(ReadBytes(8), 0);
return DataConverter.LittleEndian.GetUInt64(ReadBytes(8), 0);
}
}
}

1
SharpCompress/SharpCompress.Portable.csproj
View File

@@ -270,6 +270,7 @@
<Compile Include="Compressor\Rar\VM\VMPreparedProgram.cs" />
<Compile Include="Compressor\Rar\VM\VMStandardFilters.cs" />
<Compile Include="Compressor\Rar\VM\VMStandardFilterSignature.cs" />
<Compile Include="Converter\DataConverter.Portable.cs" />
<Compile Include="Crypto\BufferedBlockCipher.cs" />
<Compile Include="Crypto\BufferedCipherBase.cs" />
<Compile Include="Crypto\CryptoException.cs" />

1
SharpCompress/SharpCompress.PortableTest.csproj
View File

@@ -240,6 +240,7 @@
<Compile Include="Compressor\PPMd\PpmdProperties.cs" />
<Compile Include="Compressor\PPMd\PpmdStream.cs" />
<Compile Include="Compressor\Rar\RarStream.cs" />
<Compile Include="Converter\DataConverter.Portable.cs" />
<Compile Include="Crypto\BigInteger.cs" />
<Compile Include="Crypto\BufferedBlockCipher.cs" />
<Compile Include="Crypto\BufferedCipherBase.cs" />

1
SharpCompress/SharpCompress.Unsigned.csproj
View File

@@ -244,6 +244,7 @@
<Compile Include="Compressor\PPMd\PpmdProperties.cs" />
<Compile Include="Compressor\PPMd\PpmdStream.cs" />
<Compile Include="Compressor\Rar\RarStream.cs" />
<Compile Include="Converter\DataConverter.cs" />
<Compile Include="IO\CountingWritableSubStream.cs" />
<Compile Include="Common\EntryStream.cs">
<SubType>Code</SubType>

1
SharpCompress/SharpCompress.WindowsStore.csproj
View File

@@ -256,6 +256,7 @@
<Compile Include="Compressor\Rar\VM\VMPreparedProgram.cs" />
<Compile Include="Compressor\Rar\VM\VMStandardFilters.cs" />
<Compile Include="Compressor\Rar\VM\VMStandardFilterSignature.cs" />
<Compile Include="Converter\DataConverter.Portable.cs" />
<Compile Include="Crypto\BigInteger.cs" />
<Compile Include="Crypto\BufferedBlockCipher.cs" />
<Compile Include="Crypto\BufferedCipherBase.cs" />

1
SharpCompress/SharpCompress.csproj
View File

@@ -244,6 +244,7 @@
<Compile Include="Compressor\PPMd\PpmdProperties.cs" />
<Compile Include="Compressor\PPMd\PpmdStream.cs" />
<Compile Include="Compressor\Rar\RarStream.cs" />
<Compile Include="Converter\DataConverter.cs" />
<Compile Include="IO\CountingWritableSubStream.cs" />
<Compile Include="Common\EntryStream.cs">
<SubType>Code</SubType>

197
SharpCompress/Utility.cs
View File

@@ -2,9 +2,6 @@ using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using SharpCompress.Archive;
using SharpCompress.Common;
using SharpCompress.IO;
namespace SharpCompress
{
@@ -29,17 +26,6 @@ namespace SharpCompress
return (number >> bits) + (2 << ~bits);
}
/// <summary>
/// Performs an unsigned bitwise right shift with the specified number
/// </summary>
/// <param name="number">Number to operate on</param>
/// <param name="bits">Ammount of bits to shift</param>
/// <returns>The resulting number from the shift operation</returns>
public static int URShift(int number, long bits)
{
return URShift(number, (int)bits);
}
/// <summary>
/// Performs an unsigned bitwise right shift with the specified number
/// </summary>
@@ -54,17 +40,6 @@ namespace SharpCompress
return (number >> bits) + (2L << ~bits);
}
/// <summary>
/// Performs an unsigned bitwise right shift with the specified number
/// </summary>
/// <param name="number">Number to operate on</param>
/// <param name="bits">Ammount of bits to shift</param>
/// <returns>The resulting number from the shift operation</returns>
public static long URShift(long number, long bits)
{
return URShift(number, (int)bits);
}
/// <summary>
/// Fills the array with an specific value from an specific index to an specific index.
/// </summary>
@@ -120,139 +95,6 @@ namespace SharpCompress
}
}
/// <summary> Read a int value from the byte array at the given position (Big Endian)
///
/// </summary>
/// <param name="array">the array to read from
/// </param>
/// <param name="pos">the offset
/// </param>
/// <returns> the value
/// </returns>
public static int readIntBigEndian(byte[] array, int pos)
{
int temp = 0;
temp |= array[pos] & 0xff;
temp <<= 8;
temp |= array[pos + 1] & 0xff;
temp <<= 8;
temp |= array[pos + 2] & 0xff;
temp <<= 8;
temp |= array[pos + 3] & 0xff;
return temp;
}
/// <summary> Read a short value from the byte array at the given position (little
/// Endian)
///
/// </summary>
/// <param name="array">the array to read from
/// </param>
/// <param name="pos">the offset
/// </param>
/// <returns> the value
/// </returns>
public static short readShortLittleEndian(byte[] array, int pos)
{
return BitConverter.ToInt16(array, pos);
}
/// <summary> Read an int value from the byte array at the given position (little
/// Endian)
///
/// </summary>
/// <param name="array">the array to read from
/// </param>
/// <param name="pos">the offset
/// </param>
/// <returns> the value
/// </returns>
public static int readIntLittleEndian(byte[] array, int pos)
{
return BitConverter.ToInt32(array, pos);
}
/// <summary> Write an int value into the byte array at the given position (Big endian)
///
/// </summary>
/// <param name="array">the array
/// </param>
/// <param name="pos">the offset
/// </param>
/// <param name="value">the value to write
/// </param>
public static void writeIntBigEndian(byte[] array, int pos, int value)
{
array[pos] = (byte)((Utility.URShift(value, 24)) & 0xff);
array[pos + 1] = (byte)((Utility.URShift(value, 16)) & 0xff);
array[pos + 2] = (byte)((Utility.URShift(value, 8)) & 0xff);
array[pos + 3] = (byte)((value) & 0xff);
}
/// <summary> Write a short value into the byte array at the given position (little
/// endian)
///
/// </summary>
/// <param name="array">the array
/// </param>
/// <param name="pos">the offset
/// </param>
/// <param name="value">the value to write
/// </param>
public static void WriteLittleEndian(byte[] array, int pos, short value)
{
byte[] newBytes = BitConverter.GetBytes(value);
if (!BitConverter.IsLittleEndian)
Array.Reverse(newBytes);
Array.Copy(newBytes, 0, array, pos, newBytes.Length);
}
/// <summary> Increment a short value at the specified position by the specified amount
/// (little endian).
/// </summary>
public static void incShortLittleEndian(byte[] array, int pos, short incrementValue)
{
short existingValue = BitConverter.ToInt16(array, pos);
existingValue += incrementValue;
WriteLittleEndian(array, pos, existingValue);
//int c = Utility.URShift(((array[pos] & 0xff) + (dv & 0xff)), 8);
//array[pos] = (byte)(array[pos] + (dv & 0xff));
//if ((c > 0) || ((dv & 0xff00) != 0))
//{
// array[pos + 1] = (byte)(array[pos + 1] + ((Utility.URShift(dv, 8)) & 0xff) + c);
//}
}
/// <summary> Write an int value into the byte array at the given position (little
/// endian)
///
/// </summary>
/// <param name="array">the array
/// </param>
/// <param name="pos">the offset
/// </param>
/// <param name="value">the value to write
/// </param>
public static void WriteLittleEndian(byte[] array, int pos, int value)
{
byte[] newBytes = BitConverter.GetBytes(value);
if (!BitConverter.IsLittleEndian)
Array.Reverse(newBytes);
Array.Copy(newBytes, 0, array, pos, newBytes.Length);
}
public static void Initialize<T>(this T[] array, Func<T> func)
{
for (int i = 0; i < array.Length; i++)
{
array[i] = func();
}
}
public static void AddRange<T>(this ICollection<T> destination, IEnumerable<T> source)
{
foreach (T item in source)
@@ -324,18 +166,6 @@ namespace SharpCompress
} while (source.Read(buffer, 0, buffer.Length) == buffer.Length);
}
public static byte[] UInt32ToBigEndianBytes(uint x)
{
return new byte[]
{
(byte) ((x >> 24) & 0xff),
(byte) ((x >> 16) & 0xff),
(byte) ((x >> 8) & 0xff),
(byte) (x & 0xff)
};
}
public static DateTime DosDateToDateTime(UInt16 iDate, UInt16 iTime)
{
int year = iDate / 512 + 1980;
@@ -450,33 +280,6 @@ namespace SharpCompress
{
Array.Copy(array, 0, destination, index, array.Length);
}
public static long HostToNetworkOrder(long host)
{
return (int)((long)HostToNetworkOrder((int)host)
& unchecked((long)(unchecked((ulong)-1))) << 32
| ((long)HostToNetworkOrder((int)((int)host >> 32)) & unchecked((long)(unchecked((ulong)-1)))));
}
public static int HostToNetworkOrder(int host)
{
return (int)((int)(HostToNetworkOrder((short)host) & -1) << 16 | (HostToNetworkOrder((short)(host >> 16)) & -1));
}
public static short HostToNetworkOrder(short host)
{
return (short)((int)(host & 255) << 8 | ((int)host >> 8 & 255));
}
public static long NetworkToHostOrder(long network)
{
return HostToNetworkOrder(network);
}
public static int NetworkToHostOrder(int network)
{
return HostToNetworkOrder(network);
}
public static short NetworkToHostOrder(short network)
{
return HostToNetworkOrder(network);
}
#endif
}
}

29
SharpCompress/Writer/Zip/ZipCentralDirectoryEntry.cs
View File

@@ -3,6 +3,7 @@ using System.IO;
using System.Text;
using SharpCompress.Common.Zip;
using SharpCompress.Common.Zip.Headers;
using SharpCompress.Converter;
namespace SharpCompress.Writer.Zip
{
@@ -32,23 +33,23 @@ namespace SharpCompress.Writer.Zip
flags |= HeaderFlags.Bit1; // eos marker
}
}
outputStream.Write(BitConverter.GetBytes((ushort) flags), 0, 2);
outputStream.Write(BitConverter.GetBytes((ushort) compression), 0, 2); // zipping method
outputStream.Write(BitConverter.GetBytes(ModificationTime.DateTimeToDosTime()), 0, 4);
outputStream.Write(DataConverter.LittleEndian.GetBytes((ushort) flags), 0, 2);
outputStream.Write(DataConverter.LittleEndian.GetBytes((ushort) compression), 0, 2); // zipping method
outputStream.Write(DataConverter.LittleEndian.GetBytes(ModificationTime.DateTimeToDosTime()), 0, 4);
// zipping date and time
outputStream.Write(BitConverter.GetBytes(Crc), 0, 4); // file CRC
outputStream.Write(BitConverter.GetBytes(Compressed), 0, 4); // compressed file size
outputStream.Write(BitConverter.GetBytes(Decompressed), 0, 4); // uncompressed file size
outputStream.Write(BitConverter.GetBytes((ushort) encodedFilename.Length), 0, 2); // Filename in zip
outputStream.Write(BitConverter.GetBytes((ushort) 0), 0, 2); // extra length
outputStream.Write(BitConverter.GetBytes((ushort) encodedComment.Length), 0, 2);
outputStream.Write(DataConverter.LittleEndian.GetBytes(Crc), 0, 4); // file CRC
outputStream.Write(DataConverter.LittleEndian.GetBytes(Compressed), 0, 4); // compressed file size
outputStream.Write(DataConverter.LittleEndian.GetBytes(Decompressed), 0, 4); // uncompressed file size
outputStream.Write(DataConverter.LittleEndian.GetBytes((ushort) encodedFilename.Length), 0, 2); // Filename in zip
outputStream.Write(DataConverter.LittleEndian.GetBytes((ushort) 0), 0, 2); // extra length
outputStream.Write(DataConverter.LittleEndian.GetBytes((ushort) encodedComment.Length), 0, 2);
outputStream.Write(BitConverter.GetBytes((ushort) 0), 0, 2); // disk=0
outputStream.Write(BitConverter.GetBytes((ushort) 0), 0, 2); // file type: binary
outputStream.Write(BitConverter.GetBytes((ushort) 0), 0, 2); // Internal file attributes
outputStream.Write(BitConverter.GetBytes((ushort) 0x8100), 0, 2);
outputStream.Write(DataConverter.LittleEndian.GetBytes((ushort) 0), 0, 2); // disk=0
outputStream.Write(DataConverter.LittleEndian.GetBytes((ushort) 0), 0, 2); // file type: binary
outputStream.Write(DataConverter.LittleEndian.GetBytes((ushort) 0), 0, 2); // Internal file attributes
outputStream.Write(DataConverter.LittleEndian.GetBytes((ushort) 0x8100), 0, 2);
// External file attributes (normal/readable)
outputStream.Write(BitConverter.GetBytes(HeaderOffset), 0, 4); // Offset of header
outputStream.Write(DataConverter.LittleEndian.GetBytes(HeaderOffset), 0, 4); // Offset of header
outputStream.Write(encodedFilename, 0, encodedFilename.Length);
outputStream.Write(encodedComment, 0, encodedComment.Length);

31
SharpCompress/Writer/Zip/ZipWriter.cs
View File

@@ -10,6 +10,7 @@ using SharpCompress.Compressor.BZip2;
using SharpCompress.Compressor.Deflate;
using SharpCompress.Compressor.LZMA;
using SharpCompress.Compressor.PPMd;
using SharpCompress.Converter;
using SharpCompress.IO;
using DeflateStream = SharpCompress.Compressor.Deflate.DeflateStream;
@@ -93,7 +94,7 @@ namespace SharpCompress.Writer.Zip
var explicitZipCompressionInfo = compressionInfo != null ? new ZipCompressionInfo(compressionInfo) : this.zipCompressionInfo;
byte[] encodedFilename = ArchiveEncoding.Default.GetBytes(filename);
OutputStream.Write(BitConverter.GetBytes(ZipHeaderFactory.ENTRY_HEADER_BYTES), 0, 4);
OutputStream.Write(DataConverter.LittleEndian.GetBytes(ZipHeaderFactory.ENTRY_HEADER_BYTES), 0, 4);
if (explicitZipCompressionInfo.Compression == ZipCompressionMethod.Deflate)
{
OutputStream.Write(new byte[] {20, 0}, 0, 2); //older version which is more compatible
@@ -111,14 +112,14 @@ namespace SharpCompress.Writer.Zip
flags |= HeaderFlags.Bit1; // eos marker
}
}
OutputStream.Write(BitConverter.GetBytes((ushort) flags), 0, 2);
OutputStream.Write(BitConverter.GetBytes((ushort)explicitZipCompressionInfo.Compression), 0, 2); // zipping method
OutputStream.Write(BitConverter.GetBytes(modificationTime.DateTimeToDosTime()), 0, 4);
OutputStream.Write(DataConverter.LittleEndian.GetBytes((ushort) flags), 0, 2);
OutputStream.Write(DataConverter.LittleEndian.GetBytes((ushort)explicitZipCompressionInfo.Compression), 0, 2); // zipping method
OutputStream.Write(DataConverter.LittleEndian.GetBytes(modificationTime.DateTimeToDosTime()), 0, 4);
// zipping date and time
OutputStream.Write(new byte[] {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, 0, 12);
// unused CRC, un/compressed size, updated later
OutputStream.Write(BitConverter.GetBytes((ushort) encodedFilename.Length), 0, 2); // filename length
OutputStream.Write(BitConverter.GetBytes((ushort) 0), 0, 2); // extra length
OutputStream.Write(DataConverter.LittleEndian.GetBytes((ushort) encodedFilename.Length), 0, 2); // filename length
OutputStream.Write(DataConverter.LittleEndian.GetBytes((ushort) 0), 0, 2); // extra length
OutputStream.Write(encodedFilename, 0, encodedFilename.Length);
return 6 + 2 + 2 + 4 + 12 + 2 + 2 + encodedFilename.Length;
@@ -126,9 +127,9 @@ namespace SharpCompress.Writer.Zip
private void WriteFooter(uint crc, uint compressed, uint uncompressed)
{
OutputStream.Write(BitConverter.GetBytes(crc), 0, 4);
OutputStream.Write(BitConverter.GetBytes(compressed), 0, 4);
OutputStream.Write(BitConverter.GetBytes(uncompressed), 0, 4);
OutputStream.Write(DataConverter.LittleEndian.GetBytes(crc), 0, 4);
OutputStream.Write(DataConverter.LittleEndian.GetBytes(compressed), 0, 4);
OutputStream.Write(DataConverter.LittleEndian.GetBytes(uncompressed), 0, 4);
}
private void WriteEndRecord(uint size)
@@ -136,11 +137,11 @@ namespace SharpCompress.Writer.Zip
byte[] encodedComment = ArchiveEncoding.Default.GetBytes(zipComment);
OutputStream.Write(new byte[] {80, 75, 5, 6, 0, 0, 0, 0}, 0, 8);
OutputStream.Write(BitConverter.GetBytes((ushort) entries.Count), 0, 2);
OutputStream.Write(BitConverter.GetBytes((ushort) entries.Count), 0, 2);
OutputStream.Write(BitConverter.GetBytes(size), 0, 4);
OutputStream.Write(BitConverter.GetBytes((uint) streamPosition), 0, 4);
OutputStream.Write(BitConverter.GetBytes((ushort) encodedComment.Length), 0, 2);
OutputStream.Write(DataConverter.LittleEndian.GetBytes((ushort) entries.Count), 0, 2);
OutputStream.Write(DataConverter.LittleEndian.GetBytes((ushort) entries.Count), 0, 2);
OutputStream.Write(DataConverter.LittleEndian.GetBytes(size), 0, 4);
OutputStream.Write(DataConverter.LittleEndian.GetBytes((uint) streamPosition), 0, 4);
OutputStream.Write(DataConverter.LittleEndian.GetBytes((ushort) encodedComment.Length), 0, 2);
OutputStream.Write(encodedComment, 0, encodedComment.Length);
}
@@ -254,7 +255,7 @@ namespace SharpCompress.Writer.Zip
}
else
{
originalStream.Write(BitConverter.GetBytes(ZipHeaderFactory.POST_DATA_DESCRIPTOR), 0, 4);
originalStream.Write(DataConverter.LittleEndian.GetBytes(ZipHeaderFactory.POST_DATA_DESCRIPTOR), 0, 4);
writer.WriteFooter(entry.Crc, counting.Count, decompressed);
writer.streamPosition += entry.Compressed + 16;
}