public ImapReplayCommand(string command, string resource) { string tag = null; Command = command; if (command.StartsWith("A00000", StringComparison.Ordinal)) { tag = command.Substring(0, 9); } using (var stream = GetType().Assembly.GetManifestResourceStream("UnitTests.Net.Imap.Resources." + resource)) { using (var memory = new MemoryBlockStream()) { using (var filtered = new FilteredStream(memory)) { if (tag != null) { filtered.Add(new ImapReplayFilter("A########", tag)); } filtered.Add(new Unix2DosFilter()); stream.CopyTo(filtered, 4096); filtered.Flush(); } Response = memory.ToArray(); } } }
public ImapReplayCommand(string tag, string command, string resource, bool compressed = false) { CommandBuffer = Latin1.GetBytes(command); Compressed = compressed; Command = command; using (var stream = GetType().Assembly.GetManifestResourceStream("UnitTests.Net.Imap.Resources." + resource)) { using (var memory = new MemoryBlockStream()) { using (Stream compress = new CompressedStream(memory)) { using (var filtered = new FilteredStream(compressed ? compress : memory)) { filtered.Add(new ImapReplayFilter("A########", tag)); filtered.Add(new Unix2DosFilter()); stream.CopyTo(filtered, 4096); filtered.Flush(); } Response = memory.ToArray(); } } } if (compressed) { using (var memory = new MemoryStream()) { using (var compress = new CompressedStream(memory)) { compress.Write(CommandBuffer, 0, CommandBuffer.Length); compress.Flush(); CommandBuffer = memory.ToArray(); } } } }
/// <summary> /// Parses a MimeEntity and returns as lambda to caller. /// </summary> /// <param name="node">Node containing the MIME message as value, /// and also where the lambda structure representing the parsed message will be placed.</param> /// <param name="entity">MimeEntity to parse.</param> public static void Parse(Node node, MimeEntity entity) { node.Value = entity.ContentType.MimeType; ProcessHeaders(node, entity); if (entity is Multipart multi) { // Multipart content. foreach (var idx in multi) { var idxNode = new Node("entity"); Parse(idxNode, idx); node.Add(idxNode); } } else if (entity is TextPart text) { // Test type of entity. node.Add(new Node("content", text.GetText(out var _))); } else if (entity is MimePart part) { using (var stream = new MemoryBlockStream()) { // Decoding content to memory. part.Content.DecodeTo(stream); // Resetting position and setting up a buffer object to hold content. stream.Position = 0; // Putting content into return node for MimeEntity. node.Add(new Node("content", stream.ToArray())); } } }
private static void ParseImplementation(Node node, MimeEntity entity) { var tmp = new Node("entity", entity.ContentType.MimeType); ProcessHeaders(tmp, entity); if (entity is MultipartSigned signed) { // Multipart content. var signatures = new Node("signatures"); foreach (var idx in signed.Verify()) { if (!idx.Verify()) { throw new SecurityException("Signature of MIME message was not valid"); } signatures.Add(new Node("fingerprint", idx.SignerCertificate.Fingerprint.ToLower())); } tmp.Add(signatures); // Then traversing content of multipart/signed message. foreach (var idx in signed) { ParseImplementation(tmp, idx); } } else if (entity is MultipartEncrypted) { throw new ArgumentException("Magic currently does not support decrypting MIME messages"); } else if (entity is Multipart multi) { // Multipart content. foreach (var idx in multi) { ParseImplementation(tmp, idx); } } else if (entity is TextPart text) { // Singular content type. // Notice! We don't really care about the encoding the text was encoded with. tmp.Add(new Node("content", text.GetText(out var encoding))); } else if (entity is MimePart part) { using (var stream = new MemoryBlockStream()) { // Decoding content to memory. part.Content.DecodeTo(stream); // Resetting position and setting up a buffer object to hold content. stream.Position = 0; // Putting content into return node for MimeEntity. tmp.Add(new Node("content", stream.ToArray())); } } node.Add(tmp); }
private void CompareState(MemoryStream ms, MemoryBlockStream ms2) { // Compare byte content. byte[] buff1 = ms.ToArray(); byte[] buff2 = ms2.ToArray(); // Compare read/write position. Assert.Equal(buff1, buff2); Assert.Equal(ms.Position, ms2.Position); }
/* * Returns a MimePart as inline content to caller. */ void ProcessMimePartInline(MimePart part, Node entityNode) { // Checking if MIME entity is a simple "text" part. var txtPart = part as TextPart; if (txtPart != null) { // Part is text part. entityNode.Add("content", txtPart.Text); } else if (part.ContentType.MediaType == "application" && part.ContentType.MediaSubtype == "x-hyperlambda") { /* * Current part is inline Hyperlambda content. * * Creating a stream to decode our entity to. */ using (var stream = new MemoryBlockStream()) { // Decoding content to memory. part.Content.DecodeTo(stream); // Resetting position and setting up a buffer object to hold content. stream.Position = 0; // Getting content as text. using (var reader = new StreamReader(stream)) { // Reading content is string. var content = reader.ReadToEnd(); // Putting content into return node for MimeEntity. entityNode.Add("content").LastChild.AddRange(_context.RaiseEvent("hyper2lambda", new Node("", content)).Children); } } } else { /* * Part is not text part, and is not Hyperlambda content, hence we * make sure we add it to returned [content] node as binary data. * * First creating a stream to decode our entity to. */ using (var stream = new MemoryBlockStream()) { // Decoding content to memory. part.Content.DecodeTo(stream); // Resetting position and setting up a buffer object to hold content. stream.Position = 0; // Putting content into return node for MimeEntity. entityNode.Add("content", stream.ToArray()); } } }
public void TestToArray() { var masterArray = master.ToArray(); var array = blocks.ToArray(); Assert.AreEqual(masterArray.Length, array.Length, "ToArray() length does not match"); for (int i = 0; i < array.Length; i++) { Assert.AreEqual(masterArray[i], array[i], "The bytes do not match"); } }
static byte[] ReadAllBytes (Stream stream) { if (stream is MemoryBlockStream) return ((MemoryBlockStream) stream).ToArray (); if (stream is MemoryStream) return ((MemoryStream) stream).ToArray (); using (var memory = new MemoryBlockStream ()) { stream.CopyTo (memory, 4096); return memory.ToArray (); } }
public ImapReplayCommand(string command, string resource) { Command = command; using (var stream = GetType().Assembly.GetManifestResourceStream("UnitTests.Net.Imap.Resources." + resource)) { var memory = new MemoryBlockStream(); using (var filtered = new FilteredStream(memory)) { filtered.Add(new Unix2DosFilter()); stream.CopyTo(filtered, 4096); } Response = memory.ToArray(); } }
public void WriteZeroBytes() { byte[] buf = Array.Empty<byte>(); MemoryBlockStream ms = new MemoryBlockStream(); ms.Write(buf, 0, 0); Assert.Equal(0, ms.Length); IRandomSource rng = RandomDefaults.CreateRandomSource(1234567); byte[] buf2 = new byte[100]; rng.NextBytes(buf2); ms.Write(buf2); Assert.Equal(ms.ToArray(), buf2); ms.Write(buf, 0, 0); Assert.Equal(ms.Length, buf2.Length); }
private void CompareState(MemoryStream ms, MemoryBlockStream ms2) { // Compare byte content. byte[] buff1 = ms.ToArray(); byte[] buff2 = ms2.ToArray(); if (!Utils.AreEqual(buff1, buff2)) { throw new Exception("State mismatch"); } // Compare read/write position. if (ms.Position != ms2.Position) { throw new Exception("Position mismatch"); } }
public ImapReplayCommand(Encoding encoding, string command, string resource, bool compressed = false) { string tag = null; CommandBuffer = encoding.GetBytes(command); Compressed = compressed; Encoding = encoding; Command = command; if (command.StartsWith("A00000", StringComparison.Ordinal)) { tag = command.Substring(0, 9); } using (var stream = GetType().Assembly.GetManifestResourceStream("UnitTests.Net.Imap.Resources." + resource)) { using (var memory = new MemoryBlockStream()) { using (Stream compress = new CompressedStream(memory)) { using (var filtered = new FilteredStream(compressed ? compress : memory)) { if (tag != null) { filtered.Add(new ImapReplayFilter("A########", tag)); } filtered.Add(new Unix2DosFilter()); stream.CopyTo(filtered, 4096); filtered.Flush(); } Response = memory.ToArray(); } } } if (compressed) { using (var memory = new MemoryStream()) { using (var compress = new CompressedStream(memory)) { compress.Write(CommandBuffer, 0, CommandBuffer.Length); compress.Flush(); CommandBuffer = memory.ToArray(); } } } }
static async Task <byte[]> ReadAllBytesAsync(Stream stream, CancellationToken cancellationToken) { if (stream is MemoryBlockStream) { return(((MemoryBlockStream)stream).ToArray()); } if (stream is MemoryStream) { return(((MemoryStream)stream).ToArray()); } using (var memory = new MemoryBlockStream()) { await stream.CopyToAsync(memory, 4096, cancellationToken).ConfigureAwait(false); return(memory.ToArray()); } }
public void TestWriteZeroBytes() { byte[] buf = new byte[0]; MemoryBlockStream ms = new MemoryBlockStream(); ms.Write(buf, 0, 0); Assert.AreEqual(ms.Length, 0); XorShiftRandom rng = new XorShiftRandom(1234567); byte[] buf2 = new byte[100]; rng.NextBytes(buf2); ms.Write(buf2, 0, buf2.Length); if (!Utils.AreEqual(ms.ToArray(), buf2)) { Assert.Fail(); } ms.Write(buf, 0, 0); Assert.AreEqual(ms.Length, buf2.Length); }
public void TestWriteZeroBytes() { byte[] buf = new byte[0]; MemoryBlockStream ms = new MemoryBlockStream(); ms.Write(buf, 0, 0); Assert.AreEqual(ms.Length, 0); IRandomSource rng = RandomDefaults.CreateRandomSource(1234567); byte[] buf2 = new byte[100]; rng.NextBytes(buf2); ms.Write(buf2, 0, buf2.Length); if (!Utils.AreEqual(ms.ToArray(), buf2)) { Assert.Fail(); } ms.Write(buf, 0, 0); Assert.AreEqual(ms.Length, buf2.Length); }
public void Validate(YEncHeader header, MemoryBlockStream decodedPartStream) { if (!MatchesPart(header)) { throw new YEncException($"Part mismatch. Expected {header.Part}, but got {Part}."); } if (Size != decodedPartStream.Length) { throw new YEncException($"Size mismatch. Expected {Size}, but got {decodedPartStream.Length}."); } var crc32 = Crc33 ?? PartCrc32; if (crc32.HasValue) { var calculatedCrc32 = Crc32.CalculateChecksum(decodedPartStream.ToArray()); if (calculatedCrc32 != crc32.Value) { throw new YEncException($"Checksum mismatch. Expected {crc32.Value}, but got {calculatedCrc32}."); } } }
public string ReadText(int MaxLength, TextEncodings TEncoding, ref int ReadedLength, bool DetectEncoding) { if (MaxLength <= 0) { return(""); } long Pos = this.FS.Position; // store current position MemoryBlockStream MStream = new MemoryBlockStream(); if (DetectEncoding && MaxLength >= 3) { byte[] Buffer = new byte[3]; FS.Read(Buffer, 0, Buffer.Length); if (Buffer[0] == 0xFF && Buffer[1] == 0xFE) { // FF FE TEncoding = TextEncodings.UTF_16; // UTF-16 (LE) this.FS.Position--; MaxLength -= 2; } else if (Buffer[0] == 0xFE && Buffer[1] == 0xFF) { // FE FF TEncoding = TextEncodings.UTF_16BE; this.FS.Position--; MaxLength -= 2; } else if (Buffer[0] == 0xEF && Buffer[1] == 0xBB && Buffer[2] == 0xBF) { // EF BB BF TEncoding = TextEncodings.UTF8; MaxLength -= 3; } else { this.FS.Position -= 3; } } // Indicate text seprator type for current string encoding bool Is2ByteSeprator = (TEncoding == TextEncodings.UTF_16 || TEncoding == TextEncodings.UTF_16BE); byte Buf, Buf2; while (MaxLength > 0) { if (Is2ByteSeprator) { Buf = ReadByte(FS); Buf2 = ReadByte(FS); if (Buf == 0 && Buf2 == 0) { break; } else { MStream.WriteByte(Buf); MStream.WriteByte(Buf2); } MaxLength--; } else { Buf = ReadByte(FS); // Read First/Next byte from stream if (Buf == 0) { break; } else { MStream.WriteByte(Buf); } } MaxLength--; } if (MaxLength < 0) { this.FS.Position += MaxLength; } ReadedLength -= Convert.ToInt32(this.FS.Position - Pos); return(StaticMethods.GetEncoding(TEncoding).GetString(MStream.ToArray())); }