Response DeserializeResponse(ref MessagePackReader reader, MessagePackSerializerOptions options) => new Response { MsgId = reader.ReadInt32(), Result = reader.ReadBytes().ToArray().AsSequence(), Error = reader.ReadBytes().ToArray().AsSequence() };
private static (bool IsOdd, Version ProtocolVersion) DeserializeHandshake(ReadOnlySpan <byte> localRandomNumber, ReadOnlySequence <byte> handshakeSequence, Options options) { var reader = new MessagePackReader(handshakeSequence); int elementCount = reader.ReadArrayHeader(); if (elementCount < 2) { throw new MultiplexingProtocolException("Unexpected handshake."); } int versionElementCount = reader.ReadArrayHeader(); int versionMajor = reader.ReadInt32(); int versionMinor = reader.ReadInt32(); var remoteVersion = new Version(versionMajor, versionMinor); Discard(ref reader, versionElementCount - 2); if (remoteVersion.Major != ProtocolVersion.Major) { throw new MultiplexingProtocolException($"Incompatible version. Local version: {ProtocolVersion}. Remote version: {remoteVersion}."); } byte[]? remoteRandomNumber = reader.ReadBytes()?.ToArray(); if (remoteRandomNumber is null) { throw new MultiplexingProtocolException("Missing random number."); } bool isOdd = IsOdd(localRandomNumber, remoteRandomNumber); Discard(ref reader, elementCount - 2); return(isOdd, remoteVersion); }
public T Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options) { var objectType = typeof(T); var tracker = (T)Activator.CreateInstance(objectType); var length = reader.ReadArrayHeader(); List <string> list = new List <string>(); for (var i = 0; i < length; i++) { list.Add(reader.ReadString()); } for (var i = 0; i < length; i++) { var pi = objectType.GetProperty(list[i]); if (reader.TryReadNil()) { pi.SetValue(tracker, null, null); } else { var data = reader.ReadBytes(); var method = SerializeMethodCache.GetDeserializeMethod(pi.PropertyType); var value = method.Invoke(null, new object[] { data.Value, options, null }); pi.SetValue(tracker, value, null); } } return(tracker); }
Request DeserializeRequest(ref MessagePackReader reader, MessagePackSerializerOptions options) => new Request { MsgId = reader.ReadInt32(), Method = reader.ReadString(), Params = reader.ReadBytes().ToArray().AsSequence() };
public static IPocoTracker <T> Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options) { var tracker = new TrackablePocoTracker <T>(); var length = reader.ReadArrayHeader(); List <string> list = new List <string>(); for (var i = 0; i < length; i++) { list.Add(reader.ReadString()); } var objectType = typeof(T); for (var i = 0; i < length; i++) { var pi = objectType.GetProperty(list[i]); if (reader.TryReadNil()) { tracker.TrackSet(pi, null, null); } else { var data = reader.ReadBytes(); var method = SerializeMethodCache.GetDeserializeMethod(pi.PropertyType); var value = method.Invoke(null, new object[] { data.Value, options, null }); tracker.TrackSet(pi, null, value); } } return(tracker); }
public byte[] Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options) { if (reader.NextMessagePackType == MessagePackType.Array) { int len = reader.ReadArrayHeader(); if (len == 0) { return(Array.Empty <byte>()); } byte[] array = new byte[len]; options.Security.DepthStep(ref reader); try { for (int i = 0; i < len; i++) { reader.CancellationToken.ThrowIfCancellationRequested(); array[i] = reader.ReadByte(); } } finally { reader.Depth--; } return(array); } else { return(reader.ReadBytes()?.ToArray()); } }
public void ArrayHeaderTest(uint target, int length) { (MemoryStream stream, MsgPack.Packer packer) = this.CreateReferencePacker(); var sequence = new Sequence <byte>(); var writer = new MessagePackWriter(sequence); writer.WriteArrayHeader(target); writer.Flush(); sequence.Length.Is(length); packer.PackArrayHeader((int)target).Position.Is(sequence.Length); stream.ToArray().SequenceEqual(sequence.AsReadOnlySequence.ToArray()).IsTrue(); // Expand sequence enough that ReadArrayHeader doesn't throw due to its security check. writer.Write(new byte[target]); writer.Flush(); var sequenceReader = new MessagePackReader(sequence.AsReadOnlySequence); sequenceReader.ReadArrayHeader().Is((int)target); sequenceReader.ReadBytes(); // read the padding we added sequenceReader.End.IsTrue(); var ms = new MemoryStream(sequence.AsReadOnlySequence.ToArray()); var unpacker = MsgPack.Unpacker.Create(ms); long len; unpacker.ReadArrayLength(out len).IsTrue(); len.Is(target); }
public System.Numerics.BigInteger Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options) { ReadOnlySequence <byte> bytes = reader.ReadBytes().Value; #if NETCOREAPP if (bytes.IsSingleSegment) { return(new System.Numerics.BigInteger(bytes.First.Span)); } else { byte[] bytesArray = ArrayPool <byte> .Shared.Rent((int)bytes.Length); try { bytes.CopyTo(bytesArray); return(new System.Numerics.BigInteger(bytesArray.AsSpan(0, (int)bytes.Length))); } finally { ArrayPool <byte> .Shared.Return(bytesArray); } } #else return(new System.Numerics.BigInteger(bytes.ToArray())); #endif }
public System.Numerics.BigInteger Deserialize(ref MessagePackReader reader, IFormatterResolver resolver) { var bytes = reader.ReadBytes(); #if NETCOREAPP2_1 if (bytes.IsSingleSegment) { return(new System.Numerics.BigInteger(bytes.First.Span)); } else { byte[] bytesArray = ArrayPool <byte> .Shared.Rent((int)bytes.Length); try { bytes.CopyTo(bytesArray); return(new System.Numerics.BigInteger(bytesArray.AsSpan(0, (int)bytes.Length))); } finally { ArrayPool <byte> .Shared.Return(bytesArray); } } #else return(new System.Numerics.BigInteger(bytes.ToArray())); #endif }
public T Deserialize(ref MessagePackReader reader, IFormatterResolver formatterResolver) { var serializedObject = reader.ReadBytes(); if (null == serializedObject) { return(default);
private static (FrameHeader Header, ReadOnlySequence <byte> Payload) DeserializeFrame(ReadOnlySequence <byte> frameSequence) { var reader = new MessagePackReader(frameSequence); int headerElementCount = reader.ReadArrayHeader(); var header = default(FrameHeader); if (headerElementCount < 1) { throw new MultiplexingProtocolException("Not enough elements in frame header."); } header.Code = (ControlCode)reader.ReadInt32(); if (headerElementCount > 1) { if (reader.IsNil) { reader.ReadNil(); } else { header.ChannelId = reader.ReadInt32(); } if (headerElementCount > 2) { var payload = reader.ReadBytes() ?? default; return(header, payload); } } return(header, default); }
protected override object DeserializeObject(ref MessagePackReader reader, Type type, string field) { try { if (type == typeof(string)) { return(ReadString(ref reader, "argument")); } else if (type == typeof(bool)) { return(reader.ReadBoolean()); } else if (type == typeof(int)) { return(reader.ReadInt32()); } else if (type == typeof(long)) { return(reader.ReadInt64()); } else if (type == typeof(float)) { return(reader.ReadSingle()); } else if (type == typeof(byte[])) { var bytes = reader.ReadBytes(); if (!bytes.HasValue) { return(null); } else if (bytes.Value.Length == 0) { return(Array.Empty <byte>()); } return(bytes.Value.ToArray()); } else if (type == typeof(JsonElement)) { var bytes = reader.ReadBytes(); if (bytes is null) { return(default);
static byte[] ReadStringBytes(ref MessagePackReader reader) { if (reader.IsNil) { reader.Skip(); return(null); } return(reader.ReadBytes()?.ToArray()); }
public byte[] Deserialize(ref MessagePackReader reader, IFormatterResolver resolver) { if (reader.TryReadNil()) { return(null); } else { return(reader.ReadBytes().ToArray()); } }
public byte[] Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options) { if (reader.TryReadNil()) { return(null); } else { return(reader.ReadBytes().ToArray()); } }
private static byte[] ReadBytes(ref MessagePackReader reader, string field) { try { return(reader.ReadBytes()?.ToArray() ?? Array.Empty <byte>()); } catch (Exception ex) { throw new InvalidDataException($"Reading '{field}' as Byte[] failed.", ex); } }
public void Write_ByteArray() { var sequence = new Sequence <byte>(); var writer = new MessagePackWriter(sequence); var buffer = new byte[] { 1, 2, 3 }; writer.Write(buffer); writer.Flush(); var reader = new MessagePackReader(sequence.AsReadOnlySequence); Assert.Equal(buffer, reader.ReadBytes().Value.ToArray()); }
public static RedisCompletion ReadCompletion(ReadOnlyMemory <byte> data) { // See WriteCompletionMessage for the format var reader = new MessagePackReader(data); ValidateArraySize(ref reader, 2, "CompletionMessage"); var protocolName = reader.ReadString(); var ros = reader.ReadBytes(); return(new RedisCompletion(protocolName, ros ?? new ReadOnlySequence <byte>())); }
public void WriteBinHeader() { var sequence = new Sequence <byte>(); var writer = new MessagePackWriter(sequence); writer.WriteBinHeader(5); writer.WriteRaw(new byte[] { 1, 2, 3, 4, 5 }); writer.Flush(); var reader = new MessagePackReader(sequence); Assert.Equal(new byte[] { 1, 2, 3, 4, 5 }, reader.ReadBytes().Value.ToArray()); }
public PublicKey Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options) { options.Security.DepthStep(ref reader); var bytes = reader.ReadBytes(); if (bytes is null) { throw new NullReferenceException($"ReadBytes from serialized {nameof(PublicKey)} is null."); } return(new PublicKey(bytes.Value.ToArray())); }
public FungibleAssetValue Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options) { options.Security.DepthStep(ref reader); var bytes = reader.ReadBytes(); if (bytes is null) { throw new NullReferenceException($"ReadBytes from serialized {nameof(FungibleAssetValue)} is null."); } return(new Codec().Decode(bytes.Value.ToArray()).ToFungibleAssetValue()); }
T IMessagePackFormatter <T> .Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options) { options.Security.DepthStep(ref reader); var bytes = reader.ReadBytes(); if (bytes is null) { throw new NullReferenceException($"ReadBytes from serialized {typeof(T).Name} is null."); } return((T) new Codec().Decode(bytes.Value.ToArray())); }
public IAccountStateDelta Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options) { options.Security.DepthStep(ref reader); var bytes = reader.ReadBytes(); if (bytes is null) { throw new NullReferenceException($"ReadBytes from serialized {nameof(IAccountStateDelta)} is null."); } return(new ActionBase.AccountStateDelta(new Codec().Decode(bytes.Value.ToArray()))); }
public static SerializedHubMessage ReadSerializedHubMessage(ref MessagePackReader reader) { var count = reader.ReadMapHeader(); var serializations = new SerializedMessage[count]; for (var i = 0; i < count; i++) { var protocol = reader.ReadString(); var serialized = reader.ReadBytes()?.ToArray() ?? Array.Empty <byte>(); serializations[i] = new SerializedMessage(protocol, serialized); } return(new SerializedHubMessage(serializations)); }
public IPAddress Deserialize(ref MessagePackReader reader, IFormatterResolver formatterResolver) { if (reader.IsNil()) { return(null); } #if NETCOREAPP var addressBytes = reader.ReadSpan(); return(new IPAddress(addressBytes)); #else var addressBytes = reader.ReadBytes(); return(new IPAddress(addressBytes)); #endif }
public PolymorphicAction <ActionBase> Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options) { var bytes = reader.ReadBytes(); if (bytes is null) { return(null); } IValue value = new Codec().Decode(bytes.Value.ToArray()); var plainValue = (Dictionary)value; var typeStr = plainValue["type_id"]; var innerAction = (ActionBase)Activator.CreateInstance(Types[(Text)typeStr]); innerAction.LoadPlainValue(plainValue["values"]); return(new NCAction(innerAction)); }
T IMessagePackFormatter <T> .Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options) { if (reader.TryReadNil()) { return(null); } options.Security.DepthStep(ref reader); var formatter = new BinaryFormatter(); byte[] bytes = reader.ReadBytes()?.ToArray(); using (var stream = new MemoryStream(bytes)) { return((T)formatter.Deserialize(stream)); } }
protected override object DeserializeObject(ref MessagePackReader reader, Type type, string field) { try { if (type == typeof(string)) { return(ReadString(ref reader, "argument")); } else if (type == typeof(bool)) { return(reader.ReadBoolean()); } else if (type == typeof(int)) { return(reader.ReadInt32()); } else if (type == typeof(long)) { return(reader.ReadInt64()); } else if (type == typeof(float)) { return(reader.ReadSingle()); } else if (type == typeof(byte[])) { var bytes = reader.ReadBytes(); if (!bytes.HasValue) { return(null); } else if (bytes.Value.Length == 0) { return(Array.Empty <byte>()); } return(bytes.Value.ToArray()); } } catch (Exception ex) { throw new InvalidDataException($"Deserializing object of the `{type.Name}` type for '{field}' failed.", ex); } throw new FormatException($"Type {type} is not supported"); }
public global::CoreLibrary.Models.Crypto.CryptoKeyProtector Deserialize(ref MessagePackReader reader, global::MessagePack.MessagePackSerializerOptions options) { if (reader.TryReadNil()) { return(null); } options.Security.DepthStep(ref reader); IFormatterResolver formatterResolver = options.Resolver; var length = reader.ReadArrayHeader(); var __ProtectorKey__ = default(byte[]); var __ProtectorState__ = default(object[]); var __ProtectorName__ = default(string); for (int i = 0; i < length; i++) { switch (i) { case 0: __ProtectorKey__ = reader.ReadBytes()?.ToArray(); break; case 1: __ProtectorState__ = formatterResolver.GetFormatterWithVerify <object[]>().Deserialize(ref reader, options); break; case 2: __ProtectorName__ = formatterResolver.GetFormatterWithVerify <string>().Deserialize(ref reader, options); break; default: reader.Skip(); break; } } var ____result = new global::CoreLibrary.Models.Crypto.CryptoKeyProtector(); ____result.ProtectorKey = __ProtectorKey__; ____result.ProtectorState = __ProtectorState__; ____result.ProtectorName = __ProtectorName__; ____result.OnAfterDeserialize(); reader.Depth--; return(____result); }
public unsafe Decimal Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options) { if (!BitConverter.IsLittleEndian) { throw new InvalidOperationException("NativeDecimalFormatter only allows on little endian env."); } ReadOnlySequence <byte> valueSequence = reader.ReadBytes().Value; if (valueSequence.Length != sizeof(decimal)) { throw new MessagePackSerializationException("Invalid decimal Size."); } decimal result; var resultSpan = new Span <byte>(&result, sizeof(decimal)); valueSequence.CopyTo(resultSpan); return(result); }