internal void ReadExtensionMembers(ref MessagePackReader reader)
{
int count = reader.ReadMapHeader();
for (int i = 0; i < count; i++)
{
switch (reader.ReadInt32())
{
case TracingId:
if (this is IMessageWithTracingId withTracingId)
{
withTracingId.TracingId = reader.ReadUInt64();
}
break;
case Ttl:
if (this is IHasTtl hasTtl)
{
hasTtl.Ttl = reader.ReadInt32();
}
break;
case Protocol:
if (this is IHasProtocol hasProtocol)
{
hasProtocol.Protocol = reader.ReadString();
}
break;
// todo : more optional fields
default:
break;
}
}
}
public ProjectId?Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
try
{
if (reader.TryReadNil())
{
return(null);
}
Contract.ThrowIfFalse(reader.ReadArrayHeader() == 2);
var id = GuidFormatter.Instance.Deserialize(ref reader, options);
var debugName = reader.ReadString();
var previousId = _previousProjectId;
if (previousId is not null && previousId.Id == id && previousId.DebugName == debugName)
{
return(previousId);
}
var currentId = ProjectId.CreateFromSerialized(id, debugName);
_previousProjectId = currentId;
return(currentId);
}
catch (Exception e) when(e is not MessagePackSerializationException)
{
throw new MessagePackSerializationException(e.Message, e);
}
}
public DocumentId?Deserialize(
ref MessagePackReader reader,
MessagePackSerializerOptions options
)
{
try
{
if (reader.TryReadNil())
{
return(null);
}
Contract.ThrowIfFalse(reader.ReadArrayHeader() == 3);
var projectId = ProjectIdFormatter.Instance.Deserialize(ref reader, options);
Contract.ThrowIfNull(projectId);
var id = GuidFormatter.Instance.Deserialize(ref reader, options);
var debugName = reader.ReadString();
return(DocumentId.CreateFromSerialized(projectId, id, debugName));
}
catch (Exception e) when(e is not MessagePackSerializationException)
{
throw new MessagePackSerializationException(e.Message, e);
}
}
public static RedisInvocation ReadInvocation(ReadOnlyMemory <byte> data)
{
// See WriteInvocation for the format
var reader = new MessagePackReader(data);
ValidateArraySize(ref reader, 2, "Invocation");
// Read excluded Ids
IReadOnlyList <string>?excludedConnectionIds = null;
var idCount = reader.ReadArrayHeader();
if (idCount > 0)
{
var ids = new string[idCount];
for (var i = 0; i < idCount; i++)
{
ids[i] = reader.ReadString();
}
excludedConnectionIds = ids;
}
// Read payload
var message = ReadSerializedHubMessage(ref reader);
return(new RedisInvocation(message, excludedConnectionIds));
}
protected override PackageVulnerabilityMetadataContextInfo?DeserializeCore(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
Uri?advisoryUrl = null;
int severity = 0;
int propertyCount = reader.ReadMapHeader();
for (int propertyIndex = 0; propertyIndex < propertyCount; propertyIndex++)
{
switch (reader.ReadString())
{
case AdvisoryUrlPropertyName:
advisoryUrl = options.Resolver.GetFormatter <Uri>().Deserialize(ref reader, options);
break;
case SeverityPropertyName:
severity = reader.ReadInt32();
break;
default:
reader.Skip();
break;
}
}
Assumes.NotNull(advisoryUrl);
return(new PackageVulnerabilityMetadataContextInfo(advisoryUrl, severity));
}
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 object Deserialize(int id, ref MessagePackReader reader, MessagePackSerializerOptions options)
{
if (id == 0)
{
return(reader.ReadString());
}
if (id == 1)
{
return(reader.ReadInt32());
}
if (id == 2)
{
return(reader.ReadByte());
}
if (id == 4)
{
return(options.Resolver.GetFormatterWithVerify <Vector3>().Deserialize(ref reader, options));
}
if (id == 5)
{
return(reader.ReadSingle());
}
return(null);
}
protected override SearchResultContextInfo?DeserializeCore(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
Guid?operationId = null;
bool hasMoreItems = false;
IReadOnlyCollection <PackageSearchMetadataContextInfo>?packageSearchItems = null;
IReadOnlyDictionary <string, LoadingStatus>? sourceLoadingStatus = null;
int propertyCount = reader.ReadMapHeader();
for (int propertyIndex = 0; propertyIndex < propertyCount; propertyIndex++)
{
switch (reader.ReadString())
{
case HasMoreItemsPropertyName:
hasMoreItems = reader.ReadBoolean();
break;
case PackageSearchItemsPropertyName:
packageSearchItems = options.Resolver.GetFormatter <IReadOnlyCollection <PackageSearchMetadataContextInfo> >().Deserialize(ref reader, options);
break;
case SourceLoadingStatusPropertyName:
sourceLoadingStatus = options.Resolver.GetFormatter <IReadOnlyDictionary <string, LoadingStatus> >().Deserialize(ref reader, options);
break;
case OperationIdPropertyName:
if (!reader.TryReadNil())
{
string guidString = reader.ReadString();
if (Guid.TryParse(guidString, out Guid operationIdGuid))
{
operationId = operationIdGuid;
}
}
break;
default:
reader.Skip();
break;
}
}
Assumes.NotNull(packageSearchItems);
Assumes.NotNull(sourceLoadingStatus);
return(new SearchResultContextInfo(packageSearchItems, sourceLoadingStatus, hasMoreItems, operationId));
}
public RequestHeader Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
// debugging...
var x = reader.ReadArrayHeader();
Console.WriteLine(x);
if (x != 3)
{
throw new MessagePack.MessagePackSerializationException("Array length is invalid. Length:" + x);
}
var id = reader.ReadInt32();
var req = reader.ReadString();
var res = reader.ReadString();
return(new RequestHeader(id, req, res));
}
public Uri Deserialize(ref MessagePackReader reader, IFormatterResolver formatterResolver)
{
if (reader.IsNil())
{
return(null);
}
return(new Uri(reader.ReadString(), UriKind.RelativeOrAbsolute));
}
public Version Deserialize(ref MessagePackReader reader, IFormatterResolver formatterResolver)
{
if (reader.IsNil())
{
return(null);
}
return(new Version(reader.ReadString()));
}
private string ReadErrorMessage()
{
_reader.ReadDictionaryLength();
_reader.ReadUint();
var message = _reader.ReadString(Encoding.UTF8);
return(message);
}
public StringBuilder Deserialize(ref MessagePackReader reader, IFormatterResolver formatterResolver)
{
if (reader.IsNil())
{
return(null);
}
return(new StringBuilder(reader.ReadString()));
}
public EventDocumentAckResult Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
reader.ReadArrayHeader();
StatusCode status = (StatusCode)reader.ReadInt32();
string notification = reader.ReadString();
reader.ReadMapHeader();
return(new EventDocumentAckResult(status, notification));
}
public T Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
if (reader.TryReadNil())
{
return(null);
}
return((T)Type.GetType(reader.ReadString(), throwOnError: true));
}
public override TestTarget Deserialize(ref MessagePackReader reader)
{
if (!reader.TryReadNil())
{
var value = new TestTarget();
int count = reader.ReadMapHeader();
for (int i = 0; i < count; i++)
{
ArraySegment<byte> segment = reader.ReadStringSegment();
if (m_nameToKey.TryGetValue(segment.Array, segment.Offset, segment.Count, out int key))
{
switch (key)
{
case 0:
{
value.BoolValue = reader.ReadBoolean();
break;
}
case 1:
{
value.IntValue = reader.ReadInt32();
break;
}
case 2:
{
value.FloatValue = reader.ReadSingle();
break;
}
case 3:
{
value.StringValue = reader.ReadString();
break;
}
case 4:
{
value.EnumValue = m_formatterTypeCode.Deserialize(ref reader);
break;
}
default:
{
reader.ReadNextBlock();
break;
}
}
}
else
{
reader.ReadNextBlock();
}
}
}
return default;
}
public PackageDependencyInfo?Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
if (reader.TryReadNil())
{
return(null);
}
// stack overflow mitigation - see https://github.com/neuecc/MessagePack-CSharp/security/advisories/GHSA-7q36-4xx7-xcxf
options.Security.DepthStep(ref reader);
try
{
PackageIdentity? packageIdentity = null;
List <PackageDependency>?packageDependencies = null;
int propertyCount = reader.ReadMapHeader();
for (var propertyIndex = 0; propertyIndex < propertyCount; ++propertyIndex)
{
switch (reader.ReadString())
{
case PackageIdentityPropertyName:
packageIdentity = PackageIdentityFormatter.Instance.Deserialize(ref reader, options);
break;
case PackageDependenciesPropertyName:
packageDependencies = new List <PackageDependency>();
int dependenciesCount = reader.ReadArrayHeader();
for (var i = 0; i < dependenciesCount; ++i)
{
PackageDependency?packageDependency = PackageDependencyFormatter.Instance.Deserialize(ref reader, options);
Assumes.NotNull(packageDependency);
packageDependencies.Add(packageDependency);
}
break;
default:
reader.Skip();
break;
}
}
Assumes.NotNull(packageIdentity);
return(new PackageDependencyInfo(packageIdentity, packageDependencies));
}
finally
{
// stack overflow mitigation - see https://github.com/neuecc/MessagePack-CSharp/security/advisories/GHSA-7q36-4xx7-xcxf
reader.Depth--;
}
}
public ActionRequest <TReqParams, TRespData> Deserialize(ref MessagePackReader reader,
MessagePackSerializerOptions options)
{
if (!reader.TryReadMapHeader(out var elementCount))
{
throw new MessagePackSerializationException();
}
var actionSeq = ReadOnlySequence <byte> .Empty;
var paramsSeq = ReadOnlySequence <byte> .Empty;
var echo = string.Empty;
// `elementCount` shall be 2 or 3.
for (var i = 0; i < elementCount; i++)
{
if (reader.TryReadStringSpan(out var propertyName))
{
if (propertyName.SequenceEqual(ConstantsOfAction.sActionPropertyName))
{
actionSeq = reader.ReadRaw();
}
else if (propertyName.SequenceEqual(ConstantsOfAction.sParamsPropertyName))
{
paramsSeq = reader.ReadRaw();
}
else if (propertyName.SequenceEqual(ConstantsOfAction.sEchoPropertyName))
{
echo = reader.ReadString();
}
}
}
var action = MessagePackSerializer.Deserialize <ActionType>(actionSeq, options) ?? ActionType.Unknown with
{
Key = MessagePackSerializer.Deserialize <string>(actionSeq, options)
};
var param = MessagePackSerializer.Deserialize(typeof(TReqParams), paramsSeq, options);
// Full-trust `ActionType`, so `GetUninitializedObject` is safe, but it is f**king SLOW.
// var zeroObj = FormatterServices.GetUninitializedObject(action.ClassType);
// `Activator` is much (4x-6x) faster, but it depends on the constructor.
var zeroObj = Activator.CreateInstance(action.ClassType, param, echo);
if (zeroObj is ActionRequest <TReqParams, TRespData> req && param is TReqParams reqParam)
{
return(req with {
Action = action, Params = reqParam, Echo = echo
});
}
// Failed in deserialize.
throw new NotSupportedException(
$"{nameof(ActionType)} {Encoding.UTF8.GetString(actionSeq)} is not supported by {nameof(MsgPackActionRequestFormatter<TReqParams, TRespData>)}.");
}
}
protected override PackageReference?DeserializeCore(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
VersionRange? allowedVersions = null;
bool isDevelopmentDependency = false;
bool isUserInstalled = true;
bool requireReinstallation = false;
PackageIdentity?identity = null;
NuGetFramework? framework = null;
int propertyCount = reader.ReadMapHeader();
for (int propertyIndex = 0; propertyIndex < propertyCount; propertyIndex++)
{
switch (reader.ReadString())
{
case AllowedVersionsPropertyName:
allowedVersions = VersionRangeFormatter.Instance.Deserialize(ref reader, options);
break;
case IsDevelopmentDependencyPropertyName:
isDevelopmentDependency = reader.ReadBoolean();
break;
case IsUserInstalledPropertyName:
isUserInstalled = reader.ReadBoolean();
break;
case PackageIdentityPropertyName:
identity = PackageIdentityFormatter.Instance.Deserialize(ref reader, options);
break;
case RequireReinstallationPropertyName:
requireReinstallation = reader.ReadBoolean();
break;
case TargetFrameworkPropertyName:
framework = NuGetFrameworkFormatter.Instance.Deserialize(ref reader, options);
break;
default:
reader.Skip();
break;
}
}
Assumes.NotNull(identity);
Assumes.NotNull(framework);
return(new PackageReference(
identity,
framework,
isUserInstalled,
isDevelopmentDependency,
requireReinstallation,
allowedVersions));
}
protected static string ReadString(ref MessagePackReader reader, IInvocationBinder binder, string field)
{
try
{
#if NETCOREAPP
if (reader.TryReadStringSpan(out var span))
{
return(binder.GetTarget(span) ?? Encoding.UTF8.GetString(span));
}
return(reader.ReadString());
#else
return(reader.ReadString());
#endif
}
catch (Exception ex)
{
throw new InvalidDataException($"Reading '{field}' as String failed.", ex);
}
}
private Message ReadCompletion(ref MessagePackReader reader)
{
// https://github.com/aspnet/AspNetCore/blob/master/src/SignalR/docs/specs/HubProtocol.md#completion-message-encoding-1
ReadHeaders(ref reader);
string invocationId = reader.ReadString();
byte resultKind = reader.ReadByte();
switch (resultKind)
{
// 1 - Error result - Result contains a String with the error message
case 1:
string error = reader.ReadString();
return(new Message
{
type = MessageTypes.Completion,
invocationId = invocationId,
error = error
});
// 2 - Void result - Result is absent
case 2:
return(new Message
{
type = MessageTypes.Completion,
invocationId = invocationId
});
// 3 - Non-Void result - Result contains the value returned by the server
case 3:
object item = ReadItem(ref reader, invocationId);
return(new Message
{
type = MessageTypes.Completion,
invocationId = invocationId,
item = item,
result = item
});
default:
throw new NotImplementedException("Unknown resultKind: " + resultKind);
}
}
public NuGetFramework?Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
if (reader.TryReadNil())
{
return(null);
}
// stack overflow mitigation - see https://github.com/neuecc/MessagePack-CSharp/security/advisories/GHSA-7q36-4xx7-xcxf
options.Security.DepthStep(ref reader);
try
{
string?frameworkName = null;
string?platformName = null;
int propertyCount = reader.ReadMapHeader();
for (int propertyIndex = 0; propertyIndex < propertyCount; propertyIndex++)
{
switch (reader.ReadString())
{
case DotNetFrameworkNamePropertyName:
frameworkName = reader.ReadString();
break;
case DotNetPlatformNamePropertyName:
platformName = reader.ReadString();
break;
default:
reader.Skip();
break;
}
}
return(NuGetFramework.ParseComponents(frameworkName, platformName));
}
finally
{
// stack overflow mitigation - see https://github.com/neuecc/MessagePack-CSharp/security/advisories/GHSA-7q36-4xx7-xcxf
reader.Depth--;
}
}
public override TestTarget Deserialize(ref MessagePackReader reader)
{
if (!reader.TryReadNil())
{
var value = new TestTarget();
int count = reader.ReadArrayHeader();
for (int i = 0; i < count; i++)
{
int key = reader.ReadInt32();
switch (key)
{
case 0:
{
value.BoolValue = reader.ReadBoolean();
break;
}
case 1:
{
value.IntValue = reader.ReadInt32();
break;
}
case 2:
{
value.FloatValue = reader.ReadSingle();
break;
}
case 3:
{
value.StringValue = reader.ReadString();
break;
}
case 4:
{
value.EnumValue = m_formatterTypeCode.Deserialize(ref reader);
break;
}
default:
{
reader.ReadNextBlock();
break;
}
}
}
return(value);
}
return(default);
public PackageIdentity?Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
if (reader.TryReadNil())
{
return(null);
}
// stack overflow mitigation - see https://github.com/neuecc/MessagePack-CSharp/security/advisories/GHSA-7q36-4xx7-xcxf
options.Security.DepthStep(ref reader);
try
{
string? id = null;
NuGetVersion?version = null;
int propertyCount = reader.ReadMapHeader();
for (int propertyIndex = 0; propertyIndex < propertyCount; propertyIndex++)
{
switch (reader.ReadString())
{
case IdPropertyName:
id = reader.ReadString();
break;
case NuGetVersionPropertyName:
version = NuGetVersionFormatter.Instance.Deserialize(ref reader, options);
break;
default:
reader.Skip();
break;
}
}
return(new PackageIdentity(id, version));
}
finally
{
// stack overflow mitigation - see https://github.com/neuecc/MessagePack-CSharp/security/advisories/GHSA-7q36-4xx7-xcxf
reader.Depth--;
}
}
protected static string ReadString(ref MessagePackReader reader, string field)
{
try
{
return(reader.ReadString());
}
catch (Exception ex)
{
throw new InvalidDataException($"Reading '{field}' as String failed.", ex);
}
}
public StringBuilder Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
if (reader.TryReadNil())
{
return(null);
}
else
{
return(new StringBuilder(reader.ReadString()));
}
}
public Uri Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
if (reader.TryReadNil())
{
return(null);
}
else
{
return(new Uri(reader.ReadString(), UriKind.RelativeOrAbsolute));
}
}
public RequestId Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
if (reader.NextMessagePackType == MessagePackType.Integer)
{
return(new RequestId(reader.ReadInt64()));
}
else
{
return(new RequestId(reader.ReadString()));
}
}
public void ReadString_HandlesMultipleSegments()
{
ReadOnlySequence <byte> seq = this.BuildSequence(
new[] { (byte)(MessagePackCode.MinFixStr + 2), (byte)'A' },
new[] { (byte)'B' });
var reader = new MessagePackReader(seq);
var result = reader.ReadString();
Assert.Equal("AB", result);
}
public Type Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions options)
{
if (reader.IsNil)
{
throw new InvalidOperationException("typecode is null, struct not supported");
}
var assemblyQualifiedName = reader.ReadString();
return(Type.GetType(assemblyQualifiedName));
}