internal ControllerMessage Decode(Message message, bool hasCallbackID)
{
if (message == null)
{
throw new ArgumentNullException(nameof(message));
}
// create reader to deserialize the request
using (var reader = new PayloadReader(message.Payload))
{
// read the function
var function = (Function)reader.ReadByte();
var callbackID = hasCallbackID ? reader.ReadByte() : default(byte?);
// read the payload
var payload = new Payload(reader.ReadBytes(reader.Length - reader.Position));
if (message is ResponseMessage)
{
return(new ControllerResponse(function, callbackID, payload));
}
if (message is EventMessage)
{
return(new ControllerEvent(function, callbackID, payload));
}
throw new InvalidOperationException("Unknown message type");
}
}
protected override void Read(PayloadReader reader)
{
EndpointID = (byte)(reader.ReadByte() & 0x7F);
GenericType = (GenericType)reader.ReadByte();
SpecificType = reader.ReadSpecificType(GenericType);
SupportedCommandClasses = reader.ReadBytes(reader.Length - reader.Position).Select(element => (CommandClass)element).ToArray();
}
protected virtual void Read(PayloadReader reader)
{
if (reader == null)
{
throw new ArgumentNullException(nameof(reader));
}
CommandClass = (CommandClass)reader.ReadByte();
CommandID = reader.ReadByte();
Payload = new Payload(reader.ReadBytes(reader.Length - reader.Position));
}
protected override void Read(PayloadReader reader)
{
if (reader == null)
{
throw new ArgumentNullException(nameof(reader));
}
GroupID = reader.ReadByte();
MaxNodesSupported = reader.ReadByte();
ReportsToFollow = reader.ReadByte();
Nodes = reader.ReadBytes(reader.Length - reader.Position);
}
public object Deserialize(byte[] data)
{
PayloadReader pr = new PayloadReader(data);
ObjectTypes Id = (ObjectTypes)pr.ReadByte();
switch (Id)
{
case ObjectTypes.Null: return null;
case ObjectTypes.Other:
{
BinaryFormatter bf = new BinaryFormatter();
bf.Binder = new DeserializationBinder();
return bf.Deserialize(new MemoryStream(pr.ReadBytes(pr.Length - pr.Position)));
}
case ObjectTypes.Byte: return pr.ReadByte();
case ObjectTypes.Short: return pr.ReadShort();
case ObjectTypes.UShort: return pr.ReadUShort();
case ObjectTypes.Int: return pr.ReadInteger();
case ObjectTypes.UINT: return pr.ReadUInteger();
case ObjectTypes.Long: return pr.ReadLong();
case ObjectTypes.Bool: return pr.ReadByte() == 1;
case ObjectTypes.String: return pr.ReadString();
case ObjectTypes.SolidBrush: return new SolidBrush(Color.FromArgb(pr.ReadByte(), pr.ReadByte(), pr.ReadByte(), pr.ReadByte()));
case ObjectTypes.Rectangle: return new Rectangle(pr.ReadInteger(), pr.ReadInteger(), pr.ReadInteger(), pr.ReadInteger());
case ObjectTypes.Size: return new Size(pr.ReadInteger(), pr.ReadInteger());
case ObjectTypes.ByteArray: return pr.ReadBytes(pr.ReadInteger());
case ObjectTypes.Bitmap:
{
using (MemoryStream stream = new MemoryStream(pr.Buffer, pr.Position, pr.Length - pr.Position))
{
long oldPos = stream.Position;
Bitmap bmp = (Bitmap)Bitmap.FromStream(stream);
pr.Position += (int)(stream.Position - oldPos);
return bmp;
}
}
default: throw new Exception("Error deserializing");
}
}
protected override void Read(PayloadReader reader)
{
CommandClass = (CommandClass)reader.ReadByte();
CommandID = reader.ReadByte();
Payload = new Payload(reader.ReadBytes(reader.Length - reader.Position - 2));
var actualChecksum = reader.ReadInt16();
var expectedChecksum = new byte[] { (byte)CommandClass, CommandID }.Concat(Payload.ToArray()).CalculateCrc16Checksum();
if (actualChecksum != expectedChecksum)
{
throw new ChecksumException("CRC-16 encapsulated command checksum failure");
}
}
void IPayloadSerializable.Read(PayloadReader reader)
{
if (reader == null)
{
throw new ArgumentNullException(nameof(reader));
}
var status = reader.ReadByte();
Status = ReceiveStatus.None;
if ((status & 0x01) > 0)
{
Status |= ReceiveStatus.RoutedBusy;
}
if ((status & 0x02) > 0)
{
Status |= ReceiveStatus.LowPower;
}
if ((status & 0x0C) == 0x00)
{
Status |= ReceiveStatus.TypeSingle;
}
if ((status & 0x0C) == 0x01)
{
Status |= ReceiveStatus.TypeBroad;
}
if ((status & 0x0C) == 0x10)
{
Status |= ReceiveStatus.TypeMulti;
}
if ((status & 0x10) > 0)
{
Status |= ReceiveStatus.TypeExplore;
}
if ((status & 0x40) > 0)
{
Status |= ReceiveStatus.ForeignFrame;
}
NodeID = reader.ReadByte();
var commandLength = reader.ReadByte();
var commandBytes = reader.ReadBytes(commandLength);
Command = Command.Parse(new Payload(commandBytes));
}
protected override void Read(PayloadReader reader)
{
GroupID = reader.ReadByte();
MaxNodesSupported = reader.ReadByte();
ReportsToFollow = reader.ReadByte();
var payload = reader.ReadBytes(reader.Length - reader.Position);
Nodes = payload.TakeWhile(element => element != MultiChannelAssociationReportMarker).ToArray();
var endpointsPayload = payload.SkipWhile(element => element != MultiChannelAssociationReportMarker).Skip(1).ToArray();
Endpoints = new EndpointAssociation[endpointsPayload.Length / 2];
for (int i = 0, j = 0; i < Endpoints.Length; i++, j += 2)
{
Endpoints[i] = new EndpointAssociation(endpointsPayload[j], endpointsPayload[j + 1]);
}
}
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);
}
