public IMethodCallMessage DeserializeRequest(Stream serializationStream, string uri)
{
if (serializationStream == null)
{
throw new ArgumentNullException("serializationStream is null");
}
Type svr_type = RemotingServices.GetServerTypeForUri(uri);
if (svr_type == null)
{
throw new RemotingException("no registered server for uri " + uri);
}
BinaryReader reader = new BinaryReader(serializationStream);
string method_name = reader.ReadString();
int arg_count = reader.ReadInt32();
object [] args = new object [arg_count];
for (int i = 0; i < arg_count; i++)
{
args [i] = DeserializeObject(reader);
}
MonoMethodMessage msg = new MonoMethodMessage(svr_type, method_name, args);
msg.Uri = uri;
return(msg);
}
internal object LoadRemoteFieldNew(IntPtr classPtr, IntPtr fieldPtr)
{
Mono.RuntimeClassHandle classHandle = new Mono.RuntimeClassHandle(classPtr);
RuntimeFieldHandle fieldHandle = new RuntimeFieldHandle(fieldPtr);
RuntimeTypeHandle typeHandle = classHandle.GetTypeHandle();
FieldInfo field = FieldInfo.GetFieldFromHandle(fieldHandle);
if (InCurrentContext())
{
object o = _rp._server;
return(field.GetValue(o));
}
object[] inArgs = new object[] { Type.GetTypeFromHandle(typeHandle).FullName,
field.Name };
object[] outArgsMsg = new object[1];
MethodInfo minfo = typeof(object).GetMethod("FieldGetter", BindingFlags.NonPublic | BindingFlags.Instance);
if (minfo == null)
{
throw new MissingMethodException("System.Object", "FieldGetter");
}
MonoMethodMessage msg = new MonoMethodMessage(minfo, inArgs, outArgsMsg);
object[] outArgs;
Exception exc;
RealProxy.PrivateInvoke(_rp, msg, out exc, out outArgs);
if (exc != null)
{
throw exc;
}
return(outArgs[0]);
}
public override IMessage Invoke(IMessage request)
{
IMethodCallMessage methodCallMessage = request as IMethodCallMessage;
if (methodCallMessage != null)
{
if (methodCallMessage.MethodBase == RemotingProxy._cache_GetHashCodeMethod)
{
return(new MethodResponse(base.ObjectIdentity.GetHashCode(), null, null, methodCallMessage));
}
if (methodCallMessage.MethodBase == RemotingProxy._cache_GetTypeMethod)
{
return(new MethodResponse(base.GetProxiedType(), null, null, methodCallMessage));
}
}
IInternalMessage internalMessage = request as IInternalMessage;
if (internalMessage != null)
{
if (internalMessage.Uri == null)
{
internalMessage.Uri = this._targetUri;
}
internalMessage.TargetIdentity = this._objectIdentity;
}
this._objectIdentity.NotifyClientDynamicSinks(true, request, true, false);
IMessageSink messageSink;
if (Thread.CurrentContext.HasExitSinks && !this._hasEnvoySink)
{
messageSink = Thread.CurrentContext.GetClientContextSinkChain();
}
else
{
messageSink = this._sink;
}
MonoMethodMessage monoMethodMessage = request as MonoMethodMessage;
IMessage result;
if (monoMethodMessage == null || monoMethodMessage.CallType == CallType.Sync)
{
result = messageSink.SyncProcessMessage(request);
}
else
{
AsyncResult asyncResult = monoMethodMessage.AsyncResult;
IMessageCtrl messageCtrl = messageSink.AsyncProcessMessage(request, asyncResult);
if (asyncResult != null)
{
asyncResult.SetMessageCtrl(messageCtrl);
}
result = new ReturnMessage(null, new object[0], 0, null, monoMethodMessage);
}
this._objectIdentity.NotifyClientDynamicSinks(false, request, true, false);
return(result);
}
static object[] ProcessResponse(IMethodReturnMessage mrm, MonoMethodMessage call)
{
// Check return type
MethodInfo mi = (MethodInfo)call.MethodBase;
if (mrm.ReturnValue != null && !mi.ReturnType.IsInstanceOfType(mrm.ReturnValue))
{
throw new InvalidCastException("Return value has an invalid type");
}
// Check out parameters
int no;
if (call.NeedsOutProcessing(out no))
{
ParameterInfo[] parameters = mi.GetParameters();
object[] outArgs = new object [no];
int narg = 0;
foreach (ParameterInfo par in parameters)
{
if (par.IsOut && !par.ParameterType.IsByRef)
{
// Special marshalling required
object outArg = par.Position < mrm.ArgCount ? mrm.GetArg(par.Position) : null;
if (outArg != null)
{
object local = call.GetArg(par.Position);
if (local == null)
{
throw new RemotingException("Unexpected null value in local out parameter '" + par.Name + "'");
}
RemotingServices.UpdateOutArgObject(par, local, outArg);
}
}
else if (par.ParameterType.IsByRef)
{
object outArg = par.Position < mrm.ArgCount ? mrm.GetArg(par.Position) : null;
if (outArg != null && !par.ParameterType.GetElementType().IsInstanceOfType(outArg))
{
throw new InvalidCastException("Return argument '" + par.Name + "' has an invalid type");
}
outArgs [narg++] = outArg;
}
}
return(outArgs);
}
else
{
return(new object [0]);
}
}
private static object[] ProcessResponse(IMethodReturnMessage mrm, MonoMethodMessage call)
{
MethodInfo methodInfo = (MethodInfo)call.MethodBase;
if (mrm.ReturnValue != null && !methodInfo.ReturnType.IsInstanceOfType(mrm.ReturnValue))
{
throw new InvalidCastException("Return value has an invalid type");
}
int num;
if (call.NeedsOutProcessing(out num))
{
ParameterInfo[] parameters = methodInfo.GetParameters();
object[] array = new object[num];
int num2 = 0;
foreach (ParameterInfo parameterInfo in parameters)
{
if (parameterInfo.IsOut && !parameterInfo.ParameterType.IsByRef)
{
object obj = (parameterInfo.Position >= mrm.ArgCount) ? null : mrm.GetArg(parameterInfo.Position);
if (obj != null)
{
object arg = call.GetArg(parameterInfo.Position);
if (arg == null)
{
throw new RemotingException("Unexpected null value in local out parameter '" + parameterInfo.Name + "'");
}
RemotingServices.UpdateOutArgObject(parameterInfo, arg, obj);
}
}
else if (parameterInfo.ParameterType.IsByRef)
{
object obj2 = (parameterInfo.Position >= mrm.ArgCount) ? null : mrm.GetArg(parameterInfo.Position);
if (obj2 != null && !parameterInfo.ParameterType.GetElementType().IsInstanceOfType(obj2))
{
throw new InvalidCastException("Return argument '" + parameterInfo.Name + "' has an invalid type");
}
array[num2++] = obj2;
}
}
return(array);
}
return(new object[0]);
}
internal void StoreRemoteField(IntPtr classPtr, IntPtr fieldPtr, object arg)
{
Mono.RuntimeClassHandle classHandle = new Mono.RuntimeClassHandle(classPtr);
RuntimeFieldHandle fieldHandle = new RuntimeFieldHandle(fieldPtr);
RuntimeTypeHandle typeHandle = classHandle.GetTypeHandle();
FieldInfo field = FieldInfo.GetFieldFromHandle(fieldHandle);
if (InCurrentContext())
{
object o = _rp._server;
field.SetValue(o, arg);
return;
}
string typeName = Type.GetTypeFromHandle(typeHandle).FullName;
string fieldName = field.Name;
object [] inArgs = new object[] { typeName,
fieldName,
arg };
MethodInfo minfo = typeof(object).GetMethod("FieldSetter", BindingFlags.NonPublic | BindingFlags.Instance);
if (minfo == null)
{
throw new MissingMethodException("System.Object", "FieldSetter");
}
MonoMethodMessage msg = new MonoMethodMessage(minfo, inArgs, null);
object [] outArgs;
Exception exc;
RealProxy.PrivateInvoke(_rp, msg, out exc, out outArgs);
if (exc != null)
{
throw exc;
}
}
/* this is called from unmanaged code */
internal static object PrivateInvoke(RealProxy rp, IMessage msg, out Exception exc,
out object [] out_args)
{
MonoMethodMessage mMsg = (MonoMethodMessage)msg;
mMsg.LogicalCallContext = CallContext.CreateLogicalCallContext(true);
CallType call_type = mMsg.CallType;
bool is_remproxy = (rp is RemotingProxy);
out_args = null;
IMethodReturnMessage res_msg = null;
if (call_type == CallType.BeginInvoke)
{
// todo: set CallMessage in runtime instead
mMsg.AsyncResult.CallMessage = mMsg;
}
if (call_type == CallType.EndInvoke)
{
res_msg = (IMethodReturnMessage)mMsg.AsyncResult.EndInvoke();
}
// Check for constructor msg
if (mMsg.MethodBase.IsConstructor)
{
if (is_remproxy)
{
res_msg = (IMethodReturnMessage)(rp as RemotingProxy).ActivateRemoteObject((IMethodMessage)msg);
}
else
{
msg = new ConstructionCall(rp.GetProxiedType());
}
}
if (null == res_msg)
{
bool failed = false;
try {
res_msg = (IMethodReturnMessage)rp.Invoke(msg);
} catch (Exception ex) {
failed = true;
if (call_type == CallType.BeginInvoke)
{
// If async dispatch crashes, don't propagate the exception.
// The exception will be raised when calling EndInvoke.
mMsg.AsyncResult.SyncProcessMessage(new ReturnMessage(ex, msg as IMethodCallMessage));
res_msg = new ReturnMessage(null, null, 0, null, msg as IMethodCallMessage);
}
else
{
throw;
}
}
// Note, from begining this code used AsyncResult.IsCompleted for
// checking if it was a remoting or custom proxy, but in some
// cases the remoting proxy finish before the call returns
// causing this method to be called, therefore causing all kind of bugs.
if ((!is_remproxy) && call_type == CallType.BeginInvoke && !failed)
{
IMessage asyncMsg = null;
// allow calltype EndInvoke to finish
asyncMsg = mMsg.AsyncResult.SyncProcessMessage(res_msg as IMessage);
out_args = res_msg.OutArgs;
res_msg = new ReturnMessage(asyncMsg, null, 0, null, res_msg as IMethodCallMessage);
}
}
if (res_msg.LogicalCallContext != null && res_msg.LogicalCallContext.HasInfo)
{
CallContext.UpdateCurrentCallContext(res_msg.LogicalCallContext);
}
exc = res_msg.Exception;
// todo: remove throw exception from the runtime invoke
if (null != exc)
{
out_args = null;
throw exc.FixRemotingException();
}
else if (res_msg is IConstructionReturnMessage)
{
if (out_args == null)
{
out_args = res_msg.OutArgs;
}
}
else if (mMsg.CallType == CallType.BeginInvoke)
{
// We don't have OutArgs in this case.
}
else if (mMsg.CallType == CallType.Sync)
{
out_args = ProcessResponse(res_msg, mMsg);
}
else if (mMsg.CallType == CallType.EndInvoke)
{
out_args = ProcessResponse(res_msg, mMsg.AsyncResult.CallMessage);
}
else
{
if (out_args == null)
{
out_args = res_msg.OutArgs;
}
}
return(res_msg.ReturnValue);
}
public override IMessage Invoke(IMessage request)
{
IMethodCallMessage mm = request as IMethodCallMessage;
if (mm != null)
{
if (mm.MethodBase == _cache_GetHashCodeMethod)
{
return(new MethodResponse(ObjectIdentity.GetHashCode(), null, null, mm));
}
if (mm.MethodBase == _cache_GetTypeMethod)
{
return(new MethodResponse(GetProxiedType(), null, null, mm));
}
}
IInternalMessage im = request as IInternalMessage;
if (im != null)
{
if (im.Uri == null)
{
im.Uri = _targetUri;
}
im.TargetIdentity = _objectIdentity;
}
_objectIdentity.NotifyClientDynamicSinks(true, request, true, false);
IMessage response;
IMessageSink sink;
// Needs to go through the client context sink?
if (Thread.CurrentContext.HasExitSinks && !_hasEnvoySink)
{
sink = Thread.CurrentContext.GetClientContextSinkChain();
}
else
{
sink = _sink;
}
MonoMethodMessage mMsg = request as MonoMethodMessage;
if (mMsg == null || mMsg.CallType == CallType.Sync)
{
response = sink.SyncProcessMessage(request);
}
else
{
AsyncResult ares = mMsg.AsyncResult;
IMessageCtrl mctrl = sink.AsyncProcessMessage(request, ares);
if (ares != null)
{
ares.SetMessageCtrl(mctrl);
}
response = new ReturnMessage(null, new object[0], 0, null, mMsg);
}
_objectIdentity.NotifyClientDynamicSinks(false, request, true, false);
return(response);
}
internal static object PrivateInvoke(RealProxy rp, IMessage msg, out Exception exc, out object[] out_args)
{
MonoMethodMessage monoMethodMessage = (MonoMethodMessage)msg;
monoMethodMessage.LogicalCallContext = CallContext.CreateLogicalCallContext(true);
CallType callType = monoMethodMessage.CallType;
bool flag = rp is RemotingProxy;
out_args = null;
IMethodReturnMessage methodReturnMessage = null;
if (callType == CallType.BeginInvoke)
{
monoMethodMessage.AsyncResult.CallMessage = monoMethodMessage;
}
if (callType == CallType.EndInvoke)
{
methodReturnMessage = (IMethodReturnMessage)monoMethodMessage.AsyncResult.EndInvoke();
}
if (monoMethodMessage.MethodBase.IsConstructor)
{
if (flag)
{
methodReturnMessage = (IMethodReturnMessage)(rp as RemotingProxy).ActivateRemoteObject((IMethodMessage)msg);
}
else
{
msg = new ConstructionCall(rp.GetProxiedType());
}
}
if (methodReturnMessage == null)
{
bool flag2 = false;
try
{
methodReturnMessage = (IMethodReturnMessage)rp.Invoke(msg);
}
catch (Exception e)
{
flag2 = true;
if (callType != CallType.BeginInvoke)
{
throw;
}
monoMethodMessage.AsyncResult.SyncProcessMessage(new ReturnMessage(e, msg as IMethodCallMessage));
methodReturnMessage = new ReturnMessage(null, null, 0, null, msg as IMethodCallMessage);
}
if (!flag && callType == CallType.BeginInvoke && !flag2)
{
IMessage ret = monoMethodMessage.AsyncResult.SyncProcessMessage(methodReturnMessage);
out_args = methodReturnMessage.OutArgs;
methodReturnMessage = new ReturnMessage(ret, null, 0, null, methodReturnMessage as IMethodCallMessage);
}
}
if (methodReturnMessage.LogicalCallContext != null && methodReturnMessage.LogicalCallContext.HasInfo)
{
CallContext.UpdateCurrentCallContext(methodReturnMessage.LogicalCallContext);
}
exc = methodReturnMessage.Exception;
if (exc != null)
{
out_args = null;
throw exc.FixRemotingException();
}
if (methodReturnMessage is IConstructionReturnMessage)
{
if (out_args == null)
{
out_args = methodReturnMessage.OutArgs;
}
}
else if (monoMethodMessage.CallType != CallType.BeginInvoke)
{
if (monoMethodMessage.CallType == CallType.Sync)
{
out_args = RealProxy.ProcessResponse(methodReturnMessage, monoMethodMessage);
}
else if (monoMethodMessage.CallType == CallType.EndInvoke)
{
out_args = RealProxy.ProcessResponse(methodReturnMessage, monoMethodMessage.AsyncResult.CallMessage);
}
else if (out_args == null)
{
out_args = methodReturnMessage.OutArgs;
}
}
return(methodReturnMessage.ReturnValue);
}
