public void Serialization() { var dict = new Dictionary <Type, ushort> { { typeof(string), 0 }, { typeof(int), 1 } }; TypeMap map = new TypeMap(dict); byte[] buffer = new byte[20480]; var writer = new BufferValueWriter(buffer); map.Serialize(null, writer); writer.Flush(); var reader = new BufferValueReader(buffer); map = new TypeMap(); map.Deserialize(null, reader); Type type; Assert.IsTrue(map.TryGetType(0, out type)); Assert.AreEqual(typeof(string), type); Assert.IsTrue(map.TryGetType(1, out type)); Assert.AreEqual(typeof(int), type); ushort id; Assert.IsFalse(map.GetTypeId(typeof(string), out id)); Assert.AreEqual(0, id); Assert.IsFalse(map.GetTypeId(typeof(int), out id)); Assert.AreEqual(1, id); }
public void ISerializable() { byte[] buffer = new byte[20480]; var writer = new BufferValueWriter(buffer); SerializableTester tester = new SerializableTester { Name = "MONKEY!", Numbers = new[] { 1, 2, 4, 8, 16, 32 } }; var test = new AsyncTest(); tester.SerializeCalled += test.PassHandler; writer.Write(context, tester); writer.Flush(); var reader = new BufferValueReader(buffer); var serialized = SerializerExtensions.Read <SerializableTester> (reader, context); Assert.IsNotNull(serialized); Assert.AreEqual(tester.Name, serialized.Name); Assert.IsTrue(tester.Numbers.SequenceEqual(serialized.Numbers), "Numbers does not match"); test.Assert(1000); }
public void Serialize() { var crypto = new RSACryptoServiceProvider(); var p = new RSAAsymmetricKey(crypto.ExportCspBlob(true)); byte[] buffer = new byte[20480]; var writer = new BufferValueWriter(buffer); p.Serialize(null, writer); int len = writer.Length; writer.Flush(); var reader = new BufferValueReader(buffer); var key = new RSAAsymmetricKey(null, reader); Assert.AreEqual(len, reader.Position); Assert.IsNull(key.D); Assert.IsNull(key.DP); Assert.IsNull(key.DQ); AssertArrayMatches(p.Exponent, key.Exponent); Assert.IsNull(key.InverseQ); AssertArrayMatches(p.Modulus, key.Modulus); Assert.IsNull(key.P); Assert.IsNull(key.Q); Assert.IsNotNull(key.PublicSignature); }
public void Serialize() { var person = new Person("first"); var person2 = new Person("second"); list.Add(person); server.DequeueAndAssertMessage <BuddyListMessage>(); list.Add(person2); server.DequeueAndAssertMessage <BuddyListMessage>(); var writer = new BufferValueWriter(new byte[1024]); list.Serialize(clientContext, writer); server.AssertNoMessage(); var reader = new BufferValueReader(writer.Buffer); list.Deserialize(clientContext, reader); Assert.AreEqual(writer.Length, reader.Position); server.AssertNoMessage(); CollectionAssert.Contains(list, person); CollectionAssert.Contains(list, person2); }
internal void DecryptMessage(MessageHeader header, ref BufferValueReader r) { int c = 0; #if TRACE c = GetNextCallId(); #endif //Trace.WriteLineIf (NTrace.TraceVerbose, "Entering", String.Format ("{0}:{2} {1}:DecryptMessage({3},{4})", this.typeName, c, connectionId, header.IV.Length, r.Position)); int payloadLength = r.ReadInt32(); AesManaged am = AES; if (am == null) { return; } ICryptoTransform decryptor; lock (am) { am.IV = header.IV; decryptor = am.CreateDecryptor(); } byte[] message = decryptor.TransformFinalBlock(r.Buffer, r.Position, payloadLength); r.Position += payloadLength; // Advance original reader position r = new BufferValueReader(message); //Trace.WriteLineIf (NTrace.TraceVerbose, "Exiting", String.Format ("{0}:{2} {1}:DecryptMessage({3},{4},{5})", this.typeName, c, connectionId, header.IV.Length, r.Position, message.Length)); }
public List <Message> BufferMessages(byte[] buffer) { int offset = 0; int moffset = 0; int remaining = buffer.Length; MessageHeader header = null; var reader = new BufferValueReader(buffer); return(BufferMessages(ref buffer, ref offset, ref moffset, ref remaining, ref header, ref reader)); }
public void Enum() { byte[] buffer = new byte[1024]; var writer = new BufferValueWriter (buffer); writer.Write (context, TestEnum.High); int len = writer.Length; writer.Flush(); var reader = new BufferValueReader (buffer); Assert.AreEqual (TestEnum.High, reader.Read<TestEnum> (context)); Assert.AreEqual (len, reader.Position); }
public void ReadWriteLongSet() { var writer = new BufferValueWriter (new byte[1]); for (int i = 0; i < 20480; ++i) writer.WriteInt32(i); writer.Flush(); var reader = new BufferValueReader (writer.Buffer); for (int i = 0; i < 20480; ++i) Assert.AreEqual(i, reader.ReadInt32()); }
public void ReadWriteUniversalDate() { byte[] buffer = new byte[20480]; var writer = new BufferValueWriter(buffer); DateTime d = DateTime.Now; writer.WriteUniversalDate(d); writer.Flush(); var reader = new BufferValueReader(buffer); Assert.AreEqual(d.ToUniversalTime(), reader.ReadUniversalDate()); }
public void ReadWriteUniversalDate() { byte[] buffer = new byte[20480]; var writer = new BufferValueWriter (buffer); DateTime d = DateTime.Now; writer.WriteUniversalDate (d); writer.Flush(); var reader = new BufferValueReader (buffer); Assert.AreEqual (d.ToUniversalTime(), reader.ReadUniversalDate()); }
public void ReadWrite7BitInt() { var writer = new BufferValueWriter (new byte[20480]); writer.Write7BitEncodedInt (Int32.MinValue); writer.Write7BitEncodedInt (0); writer.Write7BitEncodedInt (Int32.MaxValue); writer.Flush(); var reader = new BufferValueReader (writer.Buffer); Assert.AreEqual (Int32.MinValue, reader.Read7BitEncodedInt()); Assert.AreEqual (0, reader.Read7BitEncodedInt()); Assert.AreEqual (Int32.MaxValue, reader.Read7BitEncodedInt()); }
public void Enum() { byte[] buffer = new byte[1024]; var writer = new BufferValueWriter(buffer); writer.Write(context, TestEnum.High); int len = writer.Length; writer.Flush(); var reader = new BufferValueReader(buffer); Assert.AreEqual(TestEnum.High, reader.Read <TestEnum> (context)); Assert.AreEqual(len, reader.Position); }
public void ReadWrite7BitInt() { var writer = new BufferValueWriter(new byte[20480]); writer.Write7BitEncodedInt(Int32.MinValue); writer.Write7BitEncodedInt(0); writer.Write7BitEncodedInt(Int32.MaxValue); writer.Flush(); var reader = new BufferValueReader(writer.Buffer); Assert.AreEqual(Int32.MinValue, reader.Read7BitEncodedInt()); Assert.AreEqual(0, reader.Read7BitEncodedInt()); Assert.AreEqual(Int32.MaxValue, reader.Read7BitEncodedInt()); }
public void Serializer() { byte[] buffer = new byte[1024]; var writer = new BufferValueWriter(buffer); var c = SerializationContextTests.GetContext(MockProtocol.Instance); var p = new Protocol(42, 248); p.Serialize(c, writer); writer.Flush(); var reader = new BufferValueReader(buffer); var p2 = new Protocol(c, reader); Assert.AreEqual(p.id, p2.id); Assert.AreEqual(p.Version, p2.Version); }
public void ReadWriteLongSet() { var writer = new BufferValueWriter(new byte[1]); for (int i = 0; i < 20480; ++i) { writer.WriteInt32(i); } writer.Flush(); var reader = new BufferValueReader(writer.Buffer); for (int i = 0; i < 20480; ++i) { Assert.AreEqual(i, reader.ReadInt32()); } }
public void Serialize() { var person = new Person ("foobar") { Nickname = "MyNickname", Avatar = "MyAvatar", Status = Status.Away }; byte[] buffer = new byte[2048]; var bufferWriter = new BufferValueWriter (buffer); person.Serialize (null, bufferWriter); var bufferReader = new BufferValueReader (buffer); var person2 = new Person (null, bufferReader); Assert.AreEqual (person.Identity, person2.Identity); Assert.AreEqual (person.Nickname, person2.Nickname); Assert.AreEqual (person.Avatar, person2.Avatar); Assert.AreEqual (person.Status, person2.Status); }
private void Receive(object sender, SocketAsyncEventArgs args) { var cnd = (Tuple <Socket, BufferValueReader>)args.UserToken; Socket socket = cnd.Item1; BufferValueReader reader = cnd.Item2; if (args.BytesTransferred == 0 || args.SocketError != SocketError.Success) { reader.Dispose(); args.Dispose(); Interlocked.Decrement(ref this.pendingAsync); return; } int offset = args.Offset; reader.Position = offset; MessageHeader header = null; // We don't currently support partial messages, so an incomplete message is a bad one. if (!this.connectionlessSerializer.TryGetHeader(reader, args.BytesTransferred, ref header) || header.Message == null) { Interlocked.Decrement(ref this.pendingAsync); StartReceive(socket, args, reader); return; } if (header.ConnectionId == 0) { HandleConnectionlessMessage(args, header, ref reader); } else { HandleConnectionMessage(args, header, ref reader); } Interlocked.Decrement(ref this.pendingAsync); StartReceive(socket, args, reader); }
public void Serialize() { var person = new Person("foobar") { Nickname = "MyNickname", Avatar = "MyAvatar", Status = Status.Away }; byte[] buffer = new byte[2048]; var bufferWriter = new BufferValueWriter(buffer); person.Serialize(null, bufferWriter); var bufferReader = new BufferValueReader(buffer); var person2 = new Person(null, bufferReader); Assert.AreEqual(person.Identity, person2.Identity); Assert.AreEqual(person.Nickname, person2.Nickname); Assert.AreEqual(person.Avatar, person2.Avatar); Assert.AreEqual(person.Status, person2.Status); }
private void StartReceive(Socket socket, SocketAsyncEventArgs args, BufferValueReader reader) { if (!this.running) { return; } Interlocked.Increment(ref this.pendingAsync); try { args.SetBuffer(0, args.Buffer.Length); while (!socket.ReceiveFromAsync(args)) { Receive(this, args); } } catch (ObjectDisposedException) // Socket is disposed, we're done. { Interlocked.Decrement(ref this.pendingAsync); } }
// [Test] Testing core APIs that now have NETFX_CORE turned on everywhere public void Serializable() { var inner = new Exception("Inner exception"); var ex = new InvalidOperationException("Don't do this, fool.", inner); byte[] buffer = new byte[20480]; var writer = new BufferValueWriter(buffer); writer.Write(context, ex); writer.Flush(); var reader = new BufferValueReader(buffer); InvalidOperationException ioex = SerializerExtensions.Read <InvalidOperationException> (reader, context); Assert.IsNotNull(ioex); Assert.AreEqual(ex.Message, ioex.Message); Assert.AreEqual(ex.StackTrace, ioex.StackTrace); Assert.IsNotNull(ioex.InnerException); Assert.AreEqual(inner.Message, ioex.InnerException.Message); Assert.AreEqual(inner.StackTrace, ioex.InnerException.StackTrace); }
internal void Receive(MessageEventArgs e) { var context = new SerializationContext(); var writer = new BufferValueWriter(new byte[1024]); e.Message.WritePayload(context, writer); var reader = new BufferValueReader(writer.Buffer); var message = e.Message.Protocol.Create(e.Message.MessageType); message.ReadPayload(context, reader); message.Header = e.Message.Header; var tmessage = (e.Message as TempestMessage); if (tmessage == null) { OnMessageReceived(new MessageEventArgs(e.Connection, message)); } else { OnTempestMessageReceived(new MessageEventArgs(e.Connection, message)); } }
public void Serialization() { var dict = new Dictionary<Type, ushort> { { typeof (string), 0 }, { typeof (int), 1 } }; TypeMap map = new TypeMap (dict); byte[] buffer = new byte[20480]; var writer = new BufferValueWriter (buffer); map.Serialize (null, writer); writer.Flush(); var reader = new BufferValueReader (buffer); map = new TypeMap(); map.Deserialize (null, reader); Type type; Assert.IsTrue (map.TryGetType (0, out type)); Assert.AreEqual (typeof (string), type); Assert.IsTrue (map.TryGetType (1, out type)); Assert.AreEqual (typeof (int), type); ushort id; Assert.IsFalse (map.GetTypeId (typeof (string), out id)); Assert.AreEqual (0, id); Assert.IsFalse (map.GetTypeId (typeof (int), out id)); Assert.AreEqual (1, id); }
public void ValueReaderCtor() { byte[] buffer = new byte[20480]; var writer = new BufferValueWriter (buffer); ValueReaderTester test = new ValueReaderTester ("TheName"); writer.Write (context, test); writer.Flush(); var reader = new BufferValueReader (buffer); var serialized = SerializerExtensions.Read<ValueReaderTester> (reader, context); Assert.AreEqual (test.Name, serialized.Name); }
public void SerializableTypeContainingNonSerializableField() { byte[] buffer = new byte[20480]; var writer = new BufferValueWriter (buffer); ObjectSerializer serializer = ObjectSerializer.GetSerializer (typeof (SerializableWithNonSerializableField)); var test = new SerializableWithNonSerializableField (2, 3, "hi"); serializer.Serialize (context, writer, test); writer.Flush(); var reader = new BufferValueReader (buffer); var serialized = (SerializableWithNonSerializableField)serializer.Deserialize (context, reader); Assert.AreEqual (2, serialized.X); Assert.AreEqual (3, serialized.Y); Assert.AreEqual ("hi", serialized.Content); }
public void PrimitiveAsObject() { byte[] buffer = new byte[1024]; var writer = new BufferValueWriter (buffer); writer.Write (context, (object)20f); writer.Flush(); var reader = new BufferValueReader (buffer); object value = SerializerExtensions.Read<object> (reader, context); Assert.IsNotNull (value); Assert.AreEqual (20f, value); }
protected virtual void HandleConnectionMessage (SocketAsyncEventArgs args, MessageHeader header, ref BufferValueReader reader) { UdpConnection connection; if (!TryGetConnection (header.ConnectionId, out connection)) return; byte[] buffer = args.Buffer; int offset = args.Offset; int moffset = offset; int remaining = args.BytesTransferred; MessageSerializer serializer = connection.serializer; if (serializer == null) return; if (header.State == HeaderState.IV) { serializer.DecryptMessage (header, ref reader); header.IsStillEncrypted = false; if (!serializer.TryGetHeader (reader, args.BytesTransferred, ref header)) return; } List<Message> messages = serializer.BufferMessages (ref buffer, ref offset, ref moffset, ref remaining, ref header, ref reader); if (messages != null) { foreach (Message message in messages) connection.Receive (message); } reader.Position = 0; }
public bool TryGetHeader(BufferValueReader reader, int remaining, ref MessageHeader header) { string callCategory = null; #if TRACE int c = GetNextCallId(); callCategory = String.Format("{0} {1}:TryGetHeader({2},{3})", this.connectionType, c, reader.Position, remaining); #endif Trace.WriteLineIf(NTrace.TraceVerbose, String.Format("Entering {0}", (header == null) ? "without existing header" : "with existing header"), callCategory); int mlen; bool isContinued; Message msg = null; Protocol p; int headerLength = BaseHeaderLength; if (header == null) { header = new MessageHeader(); } else if (header.State == HeaderState.Complete) { return(true); } else if (header.HeaderLength > 0) { headerLength = header.HeaderLength; } try { if (header.State >= HeaderState.Protocol) { p = header.Protocol; } else { byte pid = reader.ReadByte(); if (!this.protocols.TryGetValue(pid, out p)) { Trace.WriteLineIf(NTrace.TraceWarning, "Exiting (Protocol " + pid + " not found)", callCategory); return(true); } header.Protocol = p; header.State = HeaderState.Protocol; if (this.serializationContext == null) { if (this.connection != null) { this.serializationContext = new SerializationContext(this.connection, this.protocols); } else { this.serializationContext = new SerializationContext(this.protocols); } } header.SerializationContext = this.serializationContext; } if (header.State < HeaderState.CID) { header.ConnectionId = reader.ReadInt32(); header.State = HeaderState.CID; } if (header.State >= HeaderState.Type) { msg = header.Message; } else { ushort type = reader.ReadUInt16(); msg = header.Message = p.Create(type); header.State = HeaderState.Type; if (msg == null) { Trace.WriteLineIf(NTrace.TraceWarning, "Exiting (Message " + type + " not found)", callCategory); return(true); } msg.Header = header; if (msg.Encrypted) { header.IsStillEncrypted = true; } Trace.WriteLineIf(NTrace.TraceVerbose, String.Format("Have " + msg.GetType().Name), callCategory); } if (header.State >= HeaderState.Length) { mlen = header.MessageLength; } else { mlen = reader.ReadInt32(); if (mlen <= 0) { Trace.WriteLineIf(NTrace.TraceWarning, "Exiting (length invalid)", callCategory); return(true); } header.MessageLength = mlen; header.State = HeaderState.Length; Trace.WriteLineIf(NTrace.TraceVerbose, String.Format("Have message of length: {0}", mlen), callCategory); } if (header.State == HeaderState.IV) { if (header.IsStillEncrypted) { Trace.WriteLineIf(NTrace.TraceVerbose, "Exiting (message not buffered)", callCategory); return(!(remaining < mlen)); } else if (header.Message.Encrypted) { reader.Position = 0; } } else if (msg.Encrypted) // && AES != null) { int ivLength = reader.ReadInt32(); //AES.IV.Length; headerLength += ivLength + sizeof(int); if (remaining < headerLength) { reader.Position -= sizeof(int); Trace.WriteLineIf(NTrace.TraceVerbose, "Exiting (header not buffered (IV))", callCategory); return(false); } byte[] iv = reader.ReadBytes(ivLength); header.HeaderLength = headerLength; header.State = HeaderState.IV; header.IV = iv; if (remaining < mlen) { Trace.WriteLineIf(NTrace.TraceVerbose, "Exiting (message not buffered)", callCategory); return(false); } Trace.WriteLineIf(NTrace.TraceVerbose, "Exiting (need to decrypt)", callCategory); return(true); } if (header.State < HeaderState.MessageId) { int identV = reader.ReadInt32(); header.MessageId = identV & ~ResponseFlag; header.IsResponse = (identV & ResponseFlag) == ResponseFlag; header.State = (header.IsResponse) ? HeaderState.MessageId : HeaderState.Complete; Trace.WriteLineIf(NTrace.TraceVerbose, "Have message ID: " + header.MessageId, callCategory); } if (header.State < HeaderState.ResponseMessageId) { header.ResponseMessageId = reader.ReadInt32(); header.State = HeaderState.Complete; Trace.WriteLineIf(NTrace.TraceVerbose, "Have message in resoponse to ID: " + header.ResponseMessageId); } Trace.WriteLineIf(NTrace.TraceVerbose, "Exiting", callCategory); return(true); } catch (Exception ex) { Trace.WriteLineIf(NTrace.TraceError, "Exiting (error): " + ex, callCategory); header = null; return(true); } }
private void StartReceive (Socket socket, SocketAsyncEventArgs args, BufferValueReader reader) { if (!this.running) return; Interlocked.Increment (ref this.pendingAsync); try { args.SetBuffer (0, args.Buffer.Length); while (!socket.ReceiveFromAsync (args)) Receive (this, args); } catch (ObjectDisposedException) // Socket is disposed, we're done. { Interlocked.Decrement (ref this.pendingAsync); } }
protected virtual void HandleConnectionMessage(SocketAsyncEventArgs args, MessageHeader header, ref BufferValueReader reader) { UdpConnection connection; if (!TryGetConnection(header.ConnectionId, out connection)) { return; } byte[] buffer = args.Buffer; int offset = args.Offset; int moffset = offset; int remaining = args.BytesTransferred; MessageSerializer serializer = connection.serializer; if (serializer == null) { return; } if (header.State == HeaderState.IV) { serializer.DecryptMessage(header, ref reader); header.IsStillEncrypted = false; if (!serializer.TryGetHeader(reader, args.BytesTransferred, ref header)) { return; } } List <Message> messages = serializer.BufferMessages(ref buffer, ref offset, ref moffset, ref remaining, ref header, ref reader); if (messages != null) { foreach (Message message in messages) { connection.Receive(message); } } reader.Position = 0; }
private void HandleConnectionlessMessage (SocketAsyncEventArgs args, MessageHeader header, ref BufferValueReader reader) { byte[] buffer = args.Buffer; int bufferOffset = 0; int messageOffset = 0; int remaining = args.BytesTransferred; List<Message> messages = this.connectionlessSerializer.BufferMessages (ref buffer, ref bufferOffset, ref messageOffset, ref remaining, ref header, ref reader); if (messages == null) return; foreach (Message m in messages) { var tempestMessage = m as TempestMessage; if (tempestMessage != null) OnConnectionlessTempestMessage (tempestMessage, args.RemoteEndPoint.ToTarget()); else OnConnectionlessMessageReceived (new ConnectionlessMessageEventArgs (m, args.RemoteEndPoint.ToTarget(), this)); } }
public void Contracted() { byte[] buffer = new byte[20480]; var writer = new BufferValueWriter (buffer); ISerializableTester test = new SerializableTester { Name = "MONKEY!", Numbers = new[] { 1, 2, 4, 8, 16, 32 } }; writer.Write (context, test); writer.Flush(); var reader = new BufferValueReader (buffer); var serialized = SerializerExtensions.Read<ISerializableTester> (reader, context); Assert.IsNotNull (serialized); Assert.AreEqual (test.Name, serialized.Name); Assert.IsTrue (test.Numbers.SequenceEqual (serialized.Numbers), "Numbers does not match"); }
private void HandleConnectionlessMessage(SocketAsyncEventArgs args, MessageHeader header, ref BufferValueReader reader) { byte[] buffer = args.Buffer; int bufferOffset = 0; int messageOffset = 0; int remaining = args.BytesTransferred; List <Message> messages = this.connectionlessSerializer.BufferMessages(ref buffer, ref bufferOffset, ref messageOffset, ref remaining, ref header, ref reader); if (messages == null) { return; } foreach (Message m in messages) { var tempestMessage = m as TempestMessage; if (tempestMessage != null) { OnConnectionlessTempestMessage(tempestMessage, args.RemoteEndPoint.ToTarget()); } else { OnConnectionlessMessageReceived(new ConnectionlessMessageEventArgs(m, args.RemoteEndPoint.ToTarget(), this)); } } }
public void Serializer() { byte[] buffer = new byte[1024]; var writer = new BufferValueWriter (buffer); var c = SerializationContextTests.GetContext (MockProtocol.Instance); var p = new Protocol (42, 248); p.Serialize (c, writer); writer.Flush(); var reader = new BufferValueReader (buffer); var p2 = new Protocol (c, reader); Assert.AreEqual (p.id, p2.id); Assert.AreEqual (p.Version, p2.Version); }
// [Test] Testing core APIs that now have NETFX_CORE turned on everywhere public void Serializable() { var inner = new Exception ("Inner exception"); var ex = new InvalidOperationException ("Don't do this, fool.", inner); byte[] buffer = new byte[20480]; var writer = new BufferValueWriter (buffer); writer.Write (context, ex); writer.Flush(); var reader = new BufferValueReader (buffer); InvalidOperationException ioex = SerializerExtensions.Read<InvalidOperationException> (reader, context); Assert.IsNotNull (ioex); Assert.AreEqual (ex.Message, ioex.Message); Assert.AreEqual (ex.StackTrace, ioex.StackTrace); Assert.IsNotNull (ioex.InnerException); Assert.AreEqual (inner.Message, ioex.InnerException.Message); Assert.AreEqual (inner.StackTrace, ioex.InnerException.StackTrace); }
List <Message> BufferMessages(ref byte[] buffer, ref int bufferOffset, ref int messageOffset, ref int remainingData, ref MessageHeader header, ref BufferValueReader reader, Func <MessageHeader, bool> messageIdCallback = null) { List <Message> messages = new List <Message>(); string callCategory = null; #if TRACE int c = GetNextCallId(); callCategory = String.Format("{0} {1}:BufferMessages({2},{3},{4},{5},{6})", this.connectionType, c, buffer.Length, bufferOffset, messageOffset, remainingData, reader.Position); #endif Trace.WriteLineIf(NTrace.TraceVerbose, "Entering", callCategory); BufferValueReader currentReader = reader; int length = 0; while (remainingData >= BaseHeaderLength) { if (!TryGetHeader(currentReader, remainingData, ref header)) { Trace.WriteLineIf(NTrace.TraceVerbose, "Message not ready", callCategory); break; } if (header == null || header.Message == null) { header = null; Disconnect(); Trace.WriteLineIf(NTrace.TraceVerbose, "Exiting (header not found)", callCategory); return(null); } length = header.MessageLength; if (length > MaxMessageSize) { header = null; Disconnect(); Trace.WriteLineIf(NTrace.TraceVerbose, "Exiting (bad message size)", callCategory); return(null); } if (header.State == HeaderState.IV) { DecryptMessage(header, ref currentReader); header.IsStillEncrypted = false; continue; } if (messageIdCallback != null && !messageIdCallback(header)) { header = null; Disconnect(); Trace.WriteLineIf(NTrace.TraceVerbose, "Exiting (message id callback was false)", callCategory); return(null); } if (remainingData < length) { bufferOffset += remainingData; Trace.WriteLineIf(NTrace.TraceVerbose, String.Format("Message not fully received (boffset={0})", bufferOffset), callCategory); break; } try { Trace.WriteLineIf(NTrace.TraceVerbose, String.Format("Reading payload for message {0}", header.Message), callCategory); header.Message.ReadPayload(header.SerializationContext, currentReader); if (!header.Message.Encrypted && header.Message.Authenticated) { // Zero out length for message signing comparison #if SAFE for (int i = LengthOffset + messageOffset; i < LengthOffset + sizeof(int) + messageOffset; ++i) { buffer[i] = 0; } #else fixed(byte *bptr = buffer) * ((int *)(bptr + (LengthOffset + messageOffset))) = 0; #endif int payloadLength = reader.Position; byte[] signature = reader.ReadBytes(); if (!VerifyMessage(this.signingHashAlgorithm, header.Message, signature, buffer, messageOffset, payloadLength - messageOffset)) { Disconnect(ConnectionResult.MessageAuthenticationFailed); Trace.WriteLineIf(NTrace.TraceVerbose, "Exiting (message auth failed)", callCategory); return(null); } } } catch (Exception ex) { header = null; Disconnect(); Trace.WriteLineIf(NTrace.TraceVerbose, "Exiting for error: " + ex, callCategory); return(null); } messages.Add(header.Message); currentReader = reader; header = null; if (length < buffer.Length) { messageOffset += length; bufferOffset = messageOffset; remainingData -= length; } else { messageOffset = 0; bufferOffset = 0; remainingData = 0; currentReader.Position = 0; } Trace.WriteLineIf(NTrace.TraceVerbose, String.Format("EOL: moffset={0},boffest={1},rdata={2},rpos={3}", messageOffset, bufferOffset, remainingData, reader.Position), callCategory); } if (remainingData > 0 || messageOffset + BaseHeaderLength >= buffer.Length) { Trace.WriteLineIf(NTrace.TraceVerbose, (remainingData > 0) ? String.Format("Data remaining: {0:N0}", remainingData) : "Insufficient room for a header", callCategory); int knownRoomNeeded = (remainingData > BaseHeaderLength) ? remainingData : BaseHeaderLength; if (header != null && remainingData >= BaseHeaderLength) { knownRoomNeeded = header.MessageLength; } int pos = reader.Position - messageOffset; Trace.WriteLineIf(NTrace.TraceVerbose, String.Format("Room needed: {0:N0} bytes", knownRoomNeeded), callCategory); if (messageOffset + knownRoomNeeded <= buffer.Length) { // bufferOffset is only moved on complete headers, so it's still == messageOffset. bufferOffset = messageOffset + remainingData; //reader.Position = pos; Trace.WriteLineIf(NTrace.TraceVerbose, String.Format("Exiting (sufficient room; boffest={0},rpos={1})", bufferOffset, pos), callCategory); return(messages); } byte[] destinationBuffer = buffer; if (knownRoomNeeded > buffer.Length) { reader.Dispose(); destinationBuffer = new byte[header.MessageLength]; reader = new BufferValueReader(destinationBuffer); } Buffer.BlockCopy(buffer, messageOffset, destinationBuffer, 0, remainingData); reader.Position = pos; messageOffset = 0; bufferOffset = remainingData; buffer = destinationBuffer; Trace.WriteLineIf(NTrace.TraceVerbose, String.Format("Exiting (moved message to front, moffset={1},boffset={2},rpos={0})", reader.Position, messageOffset, bufferOffset), callCategory); } else { Trace.WriteLineIf(NTrace.TraceVerbose, "Exiting", callCategory); } return(messages); }
public void ISerializable() { byte[] buffer = new byte[20480]; var writer = new BufferValueWriter (buffer); SerializableTester tester = new SerializableTester { Name = "MONKEY!", Numbers = new[] { 1, 2, 4, 8, 16, 32 } }; var test = new AsyncTest(); tester.SerializeCalled += test.PassHandler; writer.Write (context, tester); writer.Flush(); var reader = new BufferValueReader (buffer); var serialized = SerializerExtensions.Read<SerializableTester> (reader, context); Assert.IsNotNull (serialized); Assert.AreEqual (tester.Name, serialized.Name); Assert.IsTrue (tester.Numbers.SequenceEqual (serialized.Numbers), "Numbers does not match"); test.Assert (1000); }
public void Serialize() { var person = new Person ("first"); var person2 = new Person ("second"); list.Add (person); server.DequeueAndAssertMessage<BuddyListMessage>(); list.Add (person2); server.DequeueAndAssertMessage<BuddyListMessage>(); var writer = new BufferValueWriter (new byte[1024]); list.Serialize (clientContext, writer); server.AssertNoMessage(); var reader = new BufferValueReader (writer.Buffer); list.Deserialize (clientContext, reader); Assert.AreEqual (writer.Length, reader.Position); server.AssertNoMessage(); CollectionAssert.Contains (list, person); CollectionAssert.Contains (list, person2); }