private static void AssertReadWriteRoundtrip(byte[] originalBytes, Action <PEFile> modifyPEFile)
{
var pe = new PEFile();
var stream = new MemoryStream(originalBytes);
var reader = new BinaryStreamReader(stream, new byte[32]);
pe.ReadFrom(reader);
int pos = (int)reader.Position;
if (modifyPEFile != null)
{
modifyPEFile(pe);
}
var buf = new MemoryStream();
var writer = new BinaryStreamWriter(buf);
pe.WriteTo(writer);
buf.Write(originalBytes, pos, originalBytes.Length - pos);
byte[] outputBytes = buf.ToArray();
Assert.AreEqual(originalBytes.Length, outputBytes.Length, "outputBytes.Length");
for (int i = 0; i < outputBytes.Length; i++)
{
Assert.AreEqual(originalBytes[i], outputBytes[i], "outputBytes[" + i + "]");
}
}
public ImageDebugHeader GetDebugHeader()
{
writer.Dispose();
ImageDebugDirectory imageDebugDirectory = default(ImageDebugDirectory);
imageDebugDirectory.Type = ImageDebugType.EmbeddedPortablePdb;
ImageDebugDirectory directory = imageDebugDirectory;
MemoryStream memoryStream = new MemoryStream();
BinaryStreamWriter binaryStreamWriter = new BinaryStreamWriter(memoryStream);
binaryStreamWriter.WriteByte(77);
binaryStreamWriter.WriteByte(80);
binaryStreamWriter.WriteByte(68);
binaryStreamWriter.WriteByte(66);
binaryStreamWriter.WriteInt32((int)stream.Length);
stream.Position = 0L;
using (DeflateStream destination = new DeflateStream(memoryStream, CompressionMode.Compress, true))
{
stream.CopyTo(destination);
}
directory.SizeOfData = (int)memoryStream.Length;
return(new ImageDebugHeader(new ImageDebugHeaderEntry[2]
{
writer.GetDebugHeader().Entries[0],
new ImageDebugHeaderEntry(directory, memoryStream.ToArray())
}));
}
private long SerializeInternal(WireMessage[] messages, Stream stream)
{
if (messages == null)
{
stream.WriteByte(NullFlag);
return(1L);
}
var previousPos = stream.Position;
using (var writer = new BinaryStreamWriter(stream))
{
writer.Write(NotNullFlag);
var length = messages.Length;
writer.Write(length);
if (length > 0)
{
for (var i = 0; i < length; i++)
{
Write(writer, messages[i]);
}
}
}
return(Math.Max(-1L, stream.Position - previousPos));
}
public static void WriteCompressedInteger(this BinaryStreamWriter writer, uint?value)
{
if (value == null)
{
writer.WriteByte(0xFF);
return;
}
if (value <= 0x7F)
{
writer.WriteByte((byte)value);
}
else if (value <= 0x3FFF)
{
writer.WriteByte((byte)(0x80 | (value >> 8)));
writer.WriteByte((byte)value);
}
else
{
writer.WriteByte((byte)(0xC0 | (value >> 24)));
writer.WriteByte((byte)(value >> 16));
writer.WriteByte((byte)(value >> 8));
writer.WriteByte((byte)value);
}
}
void DefineAsyncCustomMetadata(MethodDebugInformation info)
{
if (!info.HasCustomDebugInformations)
{
return;
}
foreach (var custom_info in info.CustomDebugInformations)
{
var async_debug_info = custom_info as AsyncMethodBodyDebugInformation;
if (async_debug_info == null)
{
continue;
}
using (var stream = new MemoryStream()) {
var async_metadata = new BinaryStreamWriter(stream);
async_metadata.WriteUInt32(info.StateMachineKickOffMethod != null ? info.StateMachineKickOffMethod.MetadataToken.ToUInt32() : 0);
async_metadata.WriteUInt32((uint)async_debug_info.CatchHandler.Offset);
async_metadata.WriteUInt32((uint)async_debug_info.Resumes.Count);
for (int i = 0; i < async_debug_info.Resumes.Count; ++i)
{
async_metadata.WriteUInt32((uint)async_debug_info.Yields [i].Offset);
async_metadata.WriteUInt32(async_debug_info.resume_methods [i].MetadataToken.ToUInt32());
async_metadata.WriteUInt32((uint)async_debug_info.Resumes [i].Offset);
}
writer.DefineCustomMetadata("asyncMethodInfo", stream.ToArray());
}
}
}
private async Task PushBatch(ICollection <object[]> rows, ClickHouseType[] columnTypes, string[] columnNames, CancellationToken token)
{
var query = $"INSERT INTO {DestinationTableName} ({string.Join(", ", columnNames)}) FORMAT RowBinary";
bool useInlineQuery = await connection.SupportsInlineQuery();
using var stream = new MemoryStream()
{
Capacity = 512 * 1024
};
using (var gzipStream = new BufferedStream(new GZipStream(stream, CompressionLevel.Fastest, true), 256 * 1024))
{
if (useInlineQuery)
{
using var textWriter = new StreamWriter(gzipStream, Encoding.UTF8, 4 * 1024, true);
textWriter.WriteLine(query);
query = null; // Query was already written to POST body
}
using var writer = new ExtendedBinaryWriter(gzipStream);
using var streamer = new BinaryStreamWriter(writer);
foreach (var row in rows)
{
for (var i = 0; i < row.Length; i++)
{
streamer.Write(columnTypes[i], row[i]);
}
}
}
stream.Seek(0, SeekOrigin.Begin);
await connection.PostStreamAsync(query, stream, true, token).ConfigureAwait(false);
Interlocked.Add(ref rowsWritten, rows.Count);
}
private async Task PushBatch(ICollection <object[]> rows, ClickHouseType[] columnTypes, string[] columnNames, CancellationToken token)
{
using var stream = new MemoryStream()
{
Capacity = 512 * 1024
};
using (var gzipStream = new BufferedStream(new GZipStream(stream, CompressionLevel.Fastest, true), 256 * 1024))
{
using var writer = new ExtendedBinaryWriter(gzipStream);
using var streamer = new BinaryStreamWriter(writer);
foreach (var row in rows)
{
for (var i = 0; i < row.Length; i++)
{
streamer.WriteValue(row[i], columnTypes[i]);
}
}
}
stream.Seek(0, SeekOrigin.Begin);
var query = $"INSERT INTO {DestinationTableName} ({string.Join(", ", columnNames)}) FORMAT RowBinary";
await connection.PostBulkDataAsync(query, stream, true, token).ConfigureAwait(false);
Interlocked.Add(ref rowsWritten, rows.Count);
}
public ImageDebugHeader GetDebugHeader()
{
writer.Dispose();
var directory = new ImageDebugDirectory {
Type = ImageDebugType.EmbeddedPortablePdb,
MajorVersion = 0x0100,
MinorVersion = 0x0100,
};
var data = new MemoryStream();
var w = new BinaryStreamWriter(data);
w.WriteByte(0x4d);
w.WriteByte(0x50);
w.WriteByte(0x44);
w.WriteByte(0x42);
w.WriteInt32((int)stream.Length);
stream.Position = 0;
using (var compress_stream = new DeflateStream(data, CompressionMode.Compress, leaveOpen: true))
stream.CopyTo(compress_stream);
directory.SizeOfData = (int)data.Length;
return(new ImageDebugHeader(new [] {
writer.GetDebugHeader().Entries[0],
new ImageDebugHeaderEntry(directory, data.ToArray())
}));
}
public override MetadataStream CreateStream()
{
using (var stream = new MemoryStream())
{
var writer = new BinaryStreamWriter(stream);
writer.WriteByte(0);
var processedSignatures = new HashSet <BlobSignature>();
var agenda = new Queue <BlobSignature>(_signatureOffsetMapping.Keys);
while (agenda.Count > 0)
{
var signature = agenda.Dequeue();
if (processedSignatures.Add(signature))
{
writer.WriteCompressedUInt32(signature.GetPhysicalLength());
int count = _signatureOffsetMapping.Count;
signature.Write(_parentBuffer, writer);
// TODO: find more efficient way of adding newly created signatures to the queue.
if (count != _signatureOffsetMapping.Count)
{
foreach (var sig in _signatureOffsetMapping.Keys)
{
agenda.Enqueue(sig);
}
}
}
}
writer.WriteZeroes((int)(FileSegment.Align(_length, 4) - _length));
return(new BlobStream(new MemoryStreamReader(stream.ToArray())));
}
}
static void WriteDosHeader(DosHeader dosHeader, BinaryStreamWriter writer)
{
writer.WriteUInt16((ushort)MZSignature.MZ);
writer.WriteUInt16(dosHeader.cblp);
writer.WriteUInt16(dosHeader.cp);
writer.WriteUInt16(dosHeader.crlc);
writer.WriteUInt16(dosHeader.cparhdr);
writer.WriteUInt16(dosHeader.minalloc);
writer.WriteUInt16(dosHeader.maxalloc);
writer.WriteUInt16(dosHeader.ss);
writer.WriteUInt16(dosHeader.sp);
writer.WriteUInt16(dosHeader.csum);
writer.WriteUInt16(dosHeader.ip);
writer.WriteUInt16(dosHeader.cs);
writer.WriteUInt16(dosHeader.lfarlc);
writer.WriteUInt16(dosHeader.ovno);
writer.WriteUInt64(dosHeader.res1);
writer.WriteUInt16(dosHeader.oemid);
writer.WriteUInt16(dosHeader.oeminfo);
writer.WriteUInt32(dosHeader.ReservedNumber0);
writer.WriteUInt32(dosHeader.ReservedNumber1);
writer.WriteUInt32(dosHeader.ReservedNumber2);
writer.WriteUInt32(dosHeader.ReservedNumber3);
writer.WriteUInt32(dosHeader.ReservedNumber4);
writer.WriteUInt32(dosHeader.lfanew);
}
public static void WriteString(this BinaryStreamWriter streamWriter, string str)
{
foreach (var c in str)
{
streamWriter.WriteInt16((short)c);
}
streamWriter.WriteInt16(0);
}
private static byte[] ToBytes(ISegment segment)
{
using (var stream = new MemoryStream())
{
var writer = new BinaryStreamWriter(stream);
segment.Write(writer);
return(stream.ToArray());
}
}
public static WindowsAssembly RebuildNetAssembly(WindowsAssembly assembly)
{
var outputStream = new MemoryStream();
var writer = new BinaryStreamWriter(outputStream);
assembly.Write(new BuildingParameters(writer));
return WindowsAssembly.FromReader(new MemoryStreamReader(outputStream.ToArray()),
new ReadingParameters());
}
public ResourcesManifest CreateDirectory()
{
using (var stream = new MemoryStream())
{
var writer = new BinaryStreamWriter(stream);
Write(writer);
return(new ResourcesManifest(new MemoryStreamReader(stream.ToArray())));
}
}
public void InvalidPrimitiveOperandShouldThrow(CilCode code, object operand)
{
var stream = new MemoryStream();
var writer = new BinaryStreamWriter(stream);
var assembler = new CilAssembler(writer, new MockOperandBuilder());
Assert.ThrowsAny <ArgumentException>(() =>
assembler.WriteInstruction(new CilInstruction(code.ToOpCode(), operand)));
}
public static void Align(this BinaryStreamWriter streamWriter, int alignment)
{
var position = (int)streamWriter.BaseStream.Position;
var paddingLength = (position + alignment - 1) / alignment * alignment - position;
for (var i = 0; i < paddingLength; ++i)
{
streamWriter.Write((byte)0);
}
}
public CustomMetadataWriter(SymWriter sym_writer)
{
this.sym_writer = sym_writer;
this.stream = new MemoryStream();
this.writer = new BinaryStreamWriter(stream);
writer.WriteByte(version);
writer.WriteByte(0); // count
writer.Align(4);
}
public void TooLargeLocalShouldThrow()
{
var stream = new MemoryStream();
var writer = new BinaryStreamWriter(stream);
var assembler = new CilAssembler(writer, new MockOperandBuilder());
Assert.ThrowsAny <OverflowException>(() =>
assembler.WriteInstruction(new CilInstruction(CilOpCodes.Ldloc_S, 0x12345)));
assembler.WriteInstruction(new CilInstruction(CilOpCodes.Ldloc, 0x12345));
}
public void BranchTooFarAwayShouldThrow()
{
var stream = new MemoryStream();
var writer = new BinaryStreamWriter(stream);
var assembler = new CilAssembler(writer, new MockOperandBuilder());
Assert.ThrowsAny <OverflowException>(() =>
assembler.WriteInstruction(new CilInstruction(CilOpCodes.Br_S, new CilOffsetLabel(0x12345))));
assembler.WriteInstruction(new CilInstruction(CilOpCodes.Br, new CilOffsetLabel(0x12345)));
}
public static WindowsAssembly RebuildNetAssembly(WindowsAssembly assembly)
{
var outputStream = new MemoryStream();
var writer = new BinaryStreamWriter(outputStream);
assembly.Write(new BuildingParameters(writer));
return(WindowsAssembly.FromReader(new MemoryStreamReader(outputStream.ToArray()),
new ReadingParameters()));
}
public PdbBinaryStreamWriterSizeHelper(BinaryStreamWriter streamWriter)
{
this.streamWriter = streamWriter;
// Remember start position
this.startPosition = (uint)streamWriter.BaseStream.Position;
// Write 0 for now
streamWriter.WriteUInt32(0);
}
private static byte[] BuildRawCodeStream(IMetadataTokenProvider provider, CilMethodBody body)
{
using var codeStream = new MemoryStream();
var writer = new BinaryStreamWriter(codeStream);
var assembler = new CilAssembler(writer, new CilOperandBuilder(provider));
assembler.WriteInstructions(body.Instructions);
return(codeStream.ToArray());
}
private static byte[] BuildRawCodeStream(MethodBodySerializationContext context, CilMethodBody body)
{
using var codeStream = new MemoryStream();
var writer = new BinaryStreamWriter(codeStream);
var assembler = new CilAssembler(writer, new CilOperandBuilder(context.TokenProvider, context.DiagnosticBag));
assembler.WriteInstructions(body.Instructions);
return(codeStream.ToArray());
}
public void Reply(string[] p0)
{
var stream = new BinaryStreamWriter();
#if (DEBUG || LOG_PROTOCOL)
Log.Debug("GetMails Reply. reqId: {0}, result: {1}", _reqId, Log.ObjToString(p0));
#endif
stream.Write(2);
stream.Write(_reqId);
stream.Write(0);
stream.Write(p0);
_connection.Write(stream.Buffer, stream.Position);
}
public void Write(BinaryStreamWriter writer)
{
writer.WriteInt32(Buffs.Count);
foreach (var buff in Buffs)
{
writer.WriteString(buff.Name);
writer.WriteInt32((int)Buff.BuffCategoryAndIDFromCategoryAndAttributeID(buff.Category, buff.AttributeID));
writer.WriteInt32((int)buff.Mode);
writer.WriteInt32(buff.Value);
}
}
public void Error(int error, string msg)
{
var stream = new BinaryStreamWriter();
#if (DEBUG || LOG_PROTOCOL)
Log.Debug("GetMails Failed. reqId: {0}, errCode:{1} errMsg:{2}", _reqId, error, msg);
#endif
stream.Write(2);
stream.Write(_reqId);
stream.Write(error);
stream.Write(msg);
_connection.Write(stream.Buffer, stream.Position);
}
public static WindowsAssembly RebuildNetAssembly(WindowsAssembly assembly, string tempPath)
{
using (var outputStream = File.Create(tempPath))
{
var writer = new BinaryStreamWriter(outputStream);
assembly.Write(new BuildingParameters(writer));
}
var inputStream = new MemoryStreamReader(File.ReadAllBytes(tempPath));
return WindowsAssembly.FromReader(inputStream,
new ReadingParameters());
}
public override MetadataStream CreateStream()
{
using (var stream = new MemoryStream())
{
var writer = new BinaryStreamWriter(stream);
foreach (var guid in _guidOffsetMapping.Keys)
{
writer.WriteBytes(guid.ToByteArray());
}
return(new GuidStream(new MemoryStreamReader(stream.ToArray())));
}
}
public byte[] Serialize()
{
using (var stream = new MemoryStream())
{
var writer = new BinaryStreamWriter(stream);
writer.WriteVarInt(Data.Length + 1);
writer.WriteVarInt(PacketId);
writer.WriteByteArray(Data);
return(stream.ToArray());
}
}
public AttributeBuffSetWrapper(AttributeBuffSet other)
{
UniqueTypeName = other.UniqueTypeName;
using (var stream = new MemoryStream())
{
var writer = new BinaryStreamWriter(stream);
var reader = new BinaryStreamReader(stream);
other.Write(writer);
reader.SeekToStart();
Read(reader);
}
}
public DataSegment CreateRawMethodBody()
{
using (var stream = new MemoryStream())
{
var writer = new BinaryStreamWriter(stream);
var assembler = new X86Assembler(writer);
foreach (var instruction in Instructions)
{
assembler.Write(instruction);
}
return(new DataSegment(stream.ToArray()));
}
}
public override byte[] Serialize()
{
using (var stream = new MemoryStream())
{
var writer = new BinaryStreamWriter(stream);
writer.Write(Magic, ByteOrder.LittleEndian);
writer.Write((byte)Type);
writer.Write(Session.Id, ByteOrder.LittleEndian);
return(stream.ToArray());
}
}
private byte[] SerializeExceptionHandlers(MethodBodySerializationContext context, IList <CilExceptionHandler> exceptionHandlers, bool needsFatFormat)
{
using var sectionStream = new MemoryStream();
var writer = new BinaryStreamWriter(sectionStream);
for (int i = 0; i < exceptionHandlers.Count; i++)
{
var handler = exceptionHandlers[i];
WriteExceptionHandler(context, writer, handler, needsFatFormat);
}
return(sectionStream.ToArray());
}
private byte[] SerializeExceptionHandlers(IMetadataTokenProvider provider, IList <CilExceptionHandler> exceptionHandlers, bool needsFatFormat)
{
using var sectionStream = new MemoryStream();
var writer = new BinaryStreamWriter(sectionStream);
for (int i = 0; i < exceptionHandlers.Count; i++)
{
var handler = exceptionHandlers[i];
WriteExceptionHandler(provider, writer, handler, needsFatFormat);
}
return(sectionStream.ToArray());
}
private static void TestAssembler(IReadOnlyList<X86Instruction> instructions)
{
var path = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.Desktop), "test.bin");
using (var stream = File.Create(path))
{
var writer = new BinaryStreamWriter(stream);
var assembler = new X86Assembler(writer);
foreach (var instruction in instructions)
assembler.Write(instruction);
}
ValidateCode(instructions, File.ReadAllBytes(path));
}
