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)); }