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;
}
private void _Invoke(ref object RetObject, params object[] args)
{
if (args.Length < ArgumentTypes.Length) //check if a argument is using "params x[] args"
{
throw new Exception("missing arguments");
}
List <int> usedDelegates = new List <int>();
PayloadWriter pw = new PayloadWriter();
SmartSerializer serializer = new SmartSerializer();
for (int i = 0; i < args.Length; i++)
{
object obj = ArgumentTypes[i].IsByRef ? null : args[i];
if (DelegateIndex.ContainsKey(i))
{
obj = null;
}
byte[] SerializedObj = serializer.Serialize(obj);
pw.WriteInteger(SerializedObj.Length);
pw.WriteBytes(SerializedObj);
}
for (int i = 0; i < DelegateIndex.Count; i++)
{
Delegate del = args[DelegateIndex.Keys[i]] as Delegate;
if (del != null)
{
if (del.Method == null)
{
throw new Exception("Target delegate is NULL");
}
int id = rnd.Next();
while (Delegates.ContainsKey(id))
{
id = rnd.Next();
}
pw.WriteBool(true);
SharedDelegate sharedDel = new SharedDelegate(del.Method, sharedClass, del.GetType(), id, del, this.MethodId);
sharedDel.sharedMethod.Unchecked = this.Unchecked; //DelegateIndex.Values[i].isUnchecked;
sharedDel.sharedMethod.usePacketQueue = this.usePacketQueue; //DelegateIndex.Values[i].UsePacketQueue;
sharedDel.sharedMethod.useUdp = this.useUdp; //DelegateIndex.Values[i].UseUDP;
pw.WriteObject(sharedDel);
if (!isDelegate)
{
Delegates.Add(id, sharedDel);
}
continue;
}
pw.WriteBool(false);
}
try
{
if (Unchecked || useUdp)
{
//just execute the method and don't wait for response
sharedClass.Client.Send(new MsgExecuteMethod(0, pw.ToByteArray(), false, sharedClass.SharedId, MethodId, this.DelegateId, this.sharedClass.SharedId));
}
else
{
SyncObject syncObject = null;
Random rnd = new Random();
int RequestId = rnd.Next();
lock (sharedClass.Client.Requests)
{
while (sharedClass.Client.Requests.ContainsKey(RequestId))
{
RequestId = rnd.Next();
}
syncObject = new SyncObject(sharedClass.Client);
sharedClass.Client.Requests.Add(RequestId, syncObject);
sharedClass.Client.Send(new MsgExecuteMethod(RequestId, pw.ToByteArray(), true, sharedClass.SharedId, MethodId, this.DelegateId, this.sharedClass.SharedId));
}
RetObject = syncObject.Wait <ReturnResult>(null, TimeOutLength);
if (syncObject.TimedOut)
{
//copying the object in memory, maybe a strange way todo it but it works
RetObject = new ReturnResult(serializer.Deserialize(serializer.Serialize(this.TimeOutValue)), false);
}
}
}
catch
{
//client most likely disconnected and was unable to send the message
RetObject = null;
}
/*if (callback != null)
* {
* sharedClass.connection.BeginSendRequest(pw, callback, true, this.usePacketQueue);
* }
* else
* {
* if (Unchecked || useUdp)
* {
* //just don't wait till we received something back since it's a VOID anyway
* sharedClass.connection.BeginSendRequest(pw, (object obj) => { }, false, this.usePacketQueue);
* }
* else
* {
* RetObject = sharedClass.connection.SendRequest(pw, this.usePacketQueue);
* }
* }*/
serializer = null;
}
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 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);
}
