public static Command Parse(Payload payload)
{
if (payload.Length < 2)
{
throw new ArgumentOutOfRangeException(nameof(payload), "payload must have at least 2 bytes");
}
var commandClass = (CommandClass)payload[0];
var commandID = payload[1];
using (var reader = new PayloadReader(payload))
{
switch (commandClass)
{
case CommandClass.Crc16Encap when Crc16Command.EncapCommandID == commandID:
return(reader.ReadObject <Crc16Command>());
case CommandClass.MultiChannel when MultiChannelCommand.EncapCommandID == commandID:
return(reader.ReadObject <MultiChannelCommand>());
default:
return(reader.ReadObject <Command>());
}
}
}
protected override void Read(PayloadReader reader)
{
CommandClass = (CommandClass)reader.ReadByte();
CommandID = reader.ReadByte();
SourceEndpointID = reader.ReadByte();
TargetEndpointID = reader.ReadByte();
Payload = reader.ReadObject <Payload>();
}
public void ReadUdpPacket(IMessage message, PayloadReader pr)
{
FieldInfo[] fields = message.GetType().GetFields();
for (int i = 0; i < fields.Length; i++)
{
fields[i].SetValue(message, pr.ReadObject());
}
}
public void ReadPacket(IMessage message, PayloadReader pr, MessageHandler handler)
{
bool isCached = false;
IMessage CachedMsg = null;
//handler.ReceiveCache.DeCacheMessage(message, pr, ref isCached, ref CachedMsg, handler);
//pr.ReadBool();
//if (!isCached && CachedMsg != null)
{
FieldInfo[] fields = message.GetType().GetFields();
//FieldInfo[] cachedFields = CachedMsg.GetType().GetFields();
for (int i = 0; i < fields.Length; i++)
{
//de-serialize objects
fields[i].SetValue(message, pr.ReadObject());
}
}
}
public object onRequest(AClient connection, PayloadReader pr)
{
ReturnResult result = new ReturnResult(null, false);
bool isDelegate = false;
bool ReadFullHeader = false;
try
{
int SharedClassId = pr.ReadInteger();
int MethodId = pr.ReadInteger();
isDelegate = pr.ReadByte() == 1;
int DelegateId = isDelegate ? pr.ReadInteger() : 0;
int DelegateClassId = isDelegate ? pr.ReadInteger() : 0;
ReadFullHeader = true;
if (connection.RemoteSharedClasses.ContainsKey(SharedClassId) ||
(isDelegate && connection.LocalSharedClasses.ContainsKey(DelegateClassId)))
{
SharedClass sClass = isDelegate ? connection.LocalSharedClasses[SharedClassId] : connection.RemoteSharedClasses[SharedClassId];
SharedMethod sharedMethod = sClass.GetMethod(MethodId);
if (sharedMethod != null)
{
List <object> args = new List <object>();
List <Type> types = new List <Type>();
SortedList <int, SharedDelegate> SharedDelegates = new SortedList <int, SharedDelegate>();
SmartSerializer serializer = new SmartSerializer();
lock (sharedMethod.Delegates)
{
if (sharedMethod.Delegates.ContainsKey(DelegateId))
{
for (int i = 0; i < sharedMethod.Delegates[DelegateId].sharedMethod.ArgumentTypes.Length; i++)
{
args.Add(serializer.Deserialize(pr.ReadBytes(pr.ReadInteger())));
}
}
else
{
for (int i = 0; i < sharedMethod.ArgumentTypes.Length; i++)
{
args.Add(serializer.Deserialize(pr.ReadBytes(pr.ReadInteger())));
}
}
}
if (!isDelegate) //atm no support yet for delegate inside another delegate
{
for (int i = 0; i < sharedMethod.DelegateIndex.Count; i++)
{
if (pr.ReadByte() == 1)
{
SharedDelegate del = pr.ReadObject <SharedDelegate>();
del.sharedMethod.sharedClass = sClass;
args[sharedMethod.DelegateIndex.Keys[i]] = DynamicDelegateCreator.CreateDelegate(del);
SharedDelegates.Add(del.sharedMethod.DelegateId, del);
}
}
}
if (isDelegate)
{
//only show the result and not the actual ReturnResult type
return(sharedMethod.Delegates[DelegateId].Delegate.DynamicInvoke(args.ToArray()));
}
else
{
MethodInfo m = sClass.InitializedClass.GetType().GetMethod(sharedMethod.Name, sharedMethod.ArgumentTypes);
if (m.GetCustomAttributes(typeof(RemoteExecutionAttribute), false).Length == 0 &&
m.GetCustomAttributes(typeof(UncheckedRemoteExecutionAttribute), false).Length == 0)
{
return(null);
}
result.ReturnValue = m.Invoke(sClass.InitializedClass, args.ToArray());
}
}
}
} catch (Exception ex)
{
if (isDelegate && ReadFullHeader)
{
throw ex;
}
result.exceptionMessage = ex.InnerException != null ? ex.InnerException.Message : ex.Message;
result.ExceptionOccured = true;
}
return(result);
}
public object onRequest(AClient connection, PayloadReader pr)
{
ReturnResult result = new ReturnResult(null, false);
bool isDelegate = false;
bool ReadFullHeader = false;
try
{
int SharedClassId = pr.ReadInteger();
int MethodId = pr.ReadInteger();
isDelegate = pr.ReadByte() == 1;
int DelegateId = isDelegate ? pr.ReadInteger() : 0;
int DelegateClassId = isDelegate ? pr.ReadInteger() : 0;
ReadFullHeader = true;
if (connection.RemoteSharedClasses.ContainsKey(SharedClassId) ||
(isDelegate && connection.LocalSharedClasses.ContainsKey(DelegateClassId)))
{
SharedClass sClass = isDelegate ? connection.LocalSharedClasses[SharedClassId] : connection.RemoteSharedClasses[SharedClassId];
SharedMethod sharedMethod = sClass.GetMethod(MethodId);
if (sharedMethod != null)
{
List<object> args = new List<object>();
List<Type> types = new List<Type>();
SortedList<int, SharedDelegate> SharedDelegates = new SortedList<int, SharedDelegate>();
SmartSerializer serializer = new SmartSerializer();
lock(sharedMethod.Delegates)
{
if(sharedMethod.Delegates.ContainsKey(DelegateId))
{
for (int i = 0; i < sharedMethod.Delegates[DelegateId].sharedMethod.ArgumentTypes.Length; i++)
{
args.Add(serializer.Deserialize(pr.ReadBytes(pr.ReadInteger())));
}
}
else
{
for (int i = 0; i < sharedMethod.ArgumentTypes.Length; i++)
{
args.Add(serializer.Deserialize(pr.ReadBytes(pr.ReadInteger())));
}
}
}
if (!isDelegate) //atm no support yet for delegate inside another delegate
{
for (int i = 0; i < sharedMethod.DelegateIndex.Count; i++)
{
if (pr.ReadByte() == 1)
{
SharedDelegate del = pr.ReadObject<SharedDelegate>();
del.sharedMethod.sharedClass = sClass;
args[sharedMethod.DelegateIndex.Keys[i]] = DynamicDelegateCreator.CreateDelegate(del);
SharedDelegates.Add(del.sharedMethod.DelegateId, del);
}
}
}
if (isDelegate)
{
//only show the result and not the actual ReturnResult type
return sharedMethod.Delegates[DelegateId].Delegate.DynamicInvoke(args.ToArray());
}
else
{
MethodInfo m = sClass.InitializedClass.GetType().GetMethod(sharedMethod.Name, sharedMethod.ArgumentTypes);
if (m.GetCustomAttributes(typeof(RemoteExecutionAttribute), false).Length == 0 &&
m.GetCustomAttributes(typeof(UncheckedRemoteExecutionAttribute), false).Length == 0)
{
return null;
}
result.ReturnValue = m.Invoke(sClass.InitializedClass, args.ToArray());
}
}
}
} catch (Exception ex)
{
if (isDelegate && ReadFullHeader)
throw ex;
result.exceptionMessage = ex.InnerException != null ? ex.InnerException.Message : ex.Message;
result.ExceptionOccured = true;
}
return result;
}
public override void ProcessPayload(SSPClient client, OperationalSocket OpSocket)
{
ReturnResult result = new ReturnResult(null, false);
LiteCodeClient Client = OpSocket as LiteCodeClient;
try
{
PayloadReader pr = new PayloadReader(Data);
SharedClass sClass = null;
if (Client.InitializedClasses.TryGetValue(SharedClassId, out sClass))
{
SharedMethod sharedMethod = sClass.GetMethod(MethodId);
if (sharedMethod != null)
{
List <object> args = new List <object>();
List <Type> types = new List <Type>();
SortedList <int, SharedDelegate> SharedDelegates = new SortedList <int, SharedDelegate>();
SmartSerializer serializer = new SmartSerializer();
lock (sharedMethod.Delegates)
{
SharedDelegate sharedDel = null;
if (sharedMethod.Delegates.TryGetValue(DelegateId, out sharedDel))
{
for (int i = 0; i < sharedDel.sharedMethod.ArgumentTypes.Length; i++)
{
args.Add(serializer.Deserialize(pr.ReadBytes(pr.ReadInteger())));
}
}
else
{
for (int i = 0; i < sharedMethod.ArgumentTypes.Length; i++)
{
args.Add(serializer.Deserialize(pr.ReadBytes(pr.ReadInteger())));
}
}
}
if (!isDelegate) //atm no support yet for delegate inside another delegate
{
for (int i = 0; i < sharedMethod.DelegateIndex.Count; i++)
{
if (pr.ReadByte() == 1)
{
SharedDelegate del = pr.ReadObject <SharedDelegate>();
del.sharedMethod.sharedClass = sClass;
args[sharedMethod.DelegateIndex.Keys[i]] = DynamicDelegateCreator.CreateDelegate(del);
SharedDelegates.Add(del.sharedMethod.DelegateId, del);
}
}
}
if (isDelegate)
{
result.ReturnValue = sharedMethod.Delegates[DelegateId].Delegate.DynamicInvoke(args.ToArray());
}
else
{
if (sharedMethod.CallCache == null)
{
MethodInfo methodInf = sClass.InitializedClass.GetType().GetMethod(sharedMethod.Name, sharedMethod.ArgumentTypes);
sharedMethod.CallCache = methodInf.Bind();
}
result.ReturnValue = sharedMethod.CallCache(sClass.InitializedClass, args.ToArray());
/*MethodInfo methodInf = sClass.InitializedClass.GetType().GetMethod(sharedMethod.Name, sharedMethod.ArgumentTypes);
* result.ReturnValue = methodInf.Invoke(sClass.InitializedClass, args.ToArray());*/
}
}
}
}
catch (Exception ex)
{
result.exceptionMessage = ex.InnerException != null ? ex.InnerException.Message : ex.Message;
result.ExceptionOccured = true;
client.onException(ex.InnerException != null ? ex.InnerException : ex, ErrorType.UserLand);
}
if (RequireResultBack)
{
Client.Send(new MsgExecuteMethodResponse(RequestId, result));
}
}
public IMessage DeCacheMessage(IMessage message, PayloadReader pr, ref bool isCached, ref IMessage CachedMessage, MessageHandler msgHandler)
{
lock (Messages)
{
uint Id = msgHandler.GetMessageId(message.GetType());
isCached = pr.ReadBool();
if (!Messages.TryGetValue(Id, out CachedMessage) && !isCached)
{
CachedMessage = (IMessage)Activator.CreateInstance(message.GetType());
Messages.Add(Id, (IMessage)Activator.CreateInstance(message.GetType()));
FieldInfo[] _fields = message.GetType().GetFields();
FieldInfo[] _cachedFields = CachedMessage.GetType().GetFields();
for (int i = 0; i < _fields.Length; i++)
{
//de-serialize objects
int oldPos = pr.Offset;
_fields[i].SetValue(message, pr.ReadObject());
pr.Offset = oldPos;
_fields[i].SetValue(Messages[Id], pr.ReadObject());
}
return(message);
}
FieldInfo[] fields = message.GetType().GetFields();
FieldInfo[] cacheFields = CachedMessage.GetType().GetFields();
for (int i = 0; i < fields.Length; i++)
{
MessageCacheType CacheType = (MessageCacheType)pr.ReadByte();
object NewValue = null;
switch (CacheType)
{
case MessageCacheType.Bool:
{
NewValue = pr.ReadBool();
break;
}
case MessageCacheType.Byte:
{
NewValue = pr.ReadByte();
break;
}
case MessageCacheType.ByteArray:
{
uint size = pr.ReadUInteger();
NewValue = pr.ReadBytes((int)size);
break;
}
case MessageCacheType.Decimal:
{
NewValue = pr.ReadDecimal();
break;
}
case MessageCacheType.Double:
{
NewValue = pr.ReadDouble();
break;
}
case MessageCacheType.Float:
{
NewValue = pr.ReadFloat();
break;
}
case MessageCacheType.Long:
{
NewValue = pr.ReadLong();
break;
}
case MessageCacheType.NULL:
{
NewValue = null;
break;
}
case MessageCacheType.OtherObject:
{
NewValue = pr.ReadObject();
break;
}
case MessageCacheType.Short:
{
NewValue = pr.ReadShort();
break;
}
case MessageCacheType.String:
{
NewValue = pr.ReadString();
break;
}
case MessageCacheType.Integer:
{
NewValue = pr.ReadInteger();
break;
}
case MessageCacheType.UInteger:
{
NewValue = pr.ReadUInteger();
break;
}
case MessageCacheType.ULong:
{
NewValue = pr.ReadULong();
break;
}
case MessageCacheType.UShort:
{
NewValue = pr.ReadUShort();
break;
}
case MessageCacheType.NotUpdated:
{
NewValue = cacheFields[i].GetValue(CachedMessage);
break;
}
}
fields[i].SetValue(message, NewValue);
}
}
return(message);
}
public override void ProcessPayload(IClient client, IPlugin plugin = null)
{
ReturnResult result = new ReturnResult(null, false);
bool isDelegate = false;
bool ReadFullHeader = false;
SSPClient Client = client as SSPClient;
try
{
PayloadReader pr = new PayloadReader(Data);
int SharedClassId = pr.ReadInteger();
int MethodId = pr.ReadInteger();
isDelegate = pr.ReadByte() == 1;
int DelegateId = isDelegate ? pr.ReadInteger() : 0;
int DelegateClassId = isDelegate ? pr.ReadInteger() : 0;
ReadFullHeader = true;
if (Client.Connection.InitializedClasses.ContainsKey(SharedClassId))
{
SharedClass sClass = Client.Connection.InitializedClasses[SharedClassId];
SharedMethod sharedMethod = sClass.GetMethod(MethodId);
if (sharedMethod != null)
{
List <object> args = new List <object>();
List <Type> types = new List <Type>();
SortedList <int, SharedDelegate> SharedDelegates = new SortedList <int, SharedDelegate>();
SmartSerializer serializer = new SmartSerializer();
lock (sharedMethod.Delegates)
{
if (sharedMethod.Delegates.ContainsKey(DelegateId))
{
for (int i = 0; i < sharedMethod.Delegates[DelegateId].sharedMethod.ArgumentTypes.Length; i++)
{
args.Add(serializer.Deserialize(pr.ReadBytes(pr.ReadInteger())));
}
}
else
{
for (int i = 0; i < sharedMethod.ArgumentTypes.Length; i++)
{
args.Add(serializer.Deserialize(pr.ReadBytes(pr.ReadInteger())));
}
}
}
if (!isDelegate) //atm no support yet for delegate inside another delegate
{
for (int i = 0; i < sharedMethod.DelegateIndex.Count; i++)
{
if (pr.ReadByte() == 1)
{
SharedDelegate del = pr.ReadObject <SharedDelegate>();
del.sharedMethod.sharedClass = sClass;
args[sharedMethod.DelegateIndex.Keys[i]] = DynamicDelegateCreator.CreateDelegate(del);
SharedDelegates.Add(del.sharedMethod.DelegateId, del);
}
}
}
if (isDelegate)
{
result.ReturnValue = sharedMethod.Delegates[DelegateId].Delegate.DynamicInvoke(args.ToArray());
}
else
{
MethodInfo methodInf = sClass.InitializedClass.GetType().GetMethod(sharedMethod.Name, sharedMethod.ArgumentTypes);
if (methodInf.GetCustomAttributes(typeof(RemoteExecutionAttribute), false).Length == 0 &&
methodInf.GetCustomAttributes(typeof(UncheckedRemoteExecutionAttribute), false).Length == 0)
{
//return null;
}
result.ReturnValue = methodInf.Invoke(sClass.InitializedClass, args.ToArray());
}
}
}
}
catch (Exception ex)
{
//if (isDelegate && ReadFullHeader)
// throw ex;
result.exceptionMessage = ex.InnerException != null ? ex.InnerException.Message : ex.Message;
result.ExceptionOccured = true;
client.onException(ex.InnerException != null ? ex.InnerException : ex, ErrorType.UserLand);
}
if (RequireResultBack)
{
Client.Connection.SendMessage(new MsgExecuteMethodResponse(RequestId, result), PacketId.LiteCodeResponse);
}
base.ProcessPayload(client, plugin);
}
