public static IMessage SyncDispatchMessage(IMessage msg)
{
IMessage msgRet = null;
bool fIsOneWay = false;
try
{
if (null == msg)
{
throw new ArgumentNullException("msg");
}
// For ContextBoundObject's,
// we must switch to the target context of the object and call the context chains etc...
// Currenly XContextChannel does exactly so. So this method is just a wrapper..
// Make sure that incoming calls are counted as a remote call. This way it
// makes more sense on a server.
IncrementRemoteCalls();
// FUTURE: transitionCall needs to implement IMethodMessage ..
if (!(msg is TransitionCall))
{
// Check if the object has been disconnected or if it is
// a well known object then we have to create it lazily.
CheckDisconnectedOrCreateWellKnownObject(msg);
MethodBase method = ((IMethodMessage)msg).MethodBase;
// Check if the method is one way. Dispatch one way calls in
// an asynchronous manner
fIsOneWay = RemotingServices.IsOneWay(method);
}
// FUTURE: for MBR objects we could skip the x-ctx channel sink
IMessageSink nextSink = ChannelServices.GetCrossContextChannelSink();
if (!fIsOneWay)
{
msgRet = nextSink.SyncProcessMessage(msg);
}
else
{
nextSink.AsyncProcessMessage(msg, null);
}
}
catch (Exception e)
{
if (!fIsOneWay)
{
try
{
IMethodCallMessage mcm =
(IMethodCallMessage)((msg != null)?msg:new ErrorMessage());
msgRet = (IMessage) new ReturnMessage(e, mcm);
if (msg != null)
{
((ReturnMessage)msgRet).SetLogicalCallContext(
mcm.LogicalCallContext);
}
}
catch (Exception)
{
// Fatal exception .. ignore
}
}
}
return(msgRet);
}
[System.Security.SecurityCritical] // auto-generated
internal static void RegisterChannel()
{
CrossAppDomainChannel adc = CrossAppDomainChannel.AppDomainChannel;
ChannelServices.RegisterChannelInternal((IChannel)adc, false /*ensureSecurity*/);
}
public IMessage SyncProcessMessage(IMessage msg)
{
return(_next.SyncProcessMessage(ChannelServices.CheckReturnMessage(_call, msg)));
}
public static ServerProcessing DispatchMessage(
IServerChannelSinkStack sinkStack,
IMessage msg,
out IMessage replyMsg)
{
ServerProcessing processing = ServerProcessing.Complete;
replyMsg = null;
try
{
if (null == msg)
{
throw new ArgumentNullException("msg");
}
BCLDebug.Trace("REMOTE", "Dispatching for URI " + InternalSink.GetURI(msg));
// we must switch to the target context of the object and call the context chains etc...
// Currenly XContextChannel does exactly so. So this method is just a wrapper..
// FUTURE: This dispatches MarshalByRef objects in the default context
// Ideally, MarshalByRef objects should be dispatched in any context.
// Make sure that incoming calls are counted as a remote call. This way it
// makes more sense on a server.
IncrementRemoteCalls();
// Check if the object has been disconnected or if it is
// a well known object then we have to create it lazily.
ServerIdentity srvId = CheckDisconnectedOrCreateWellKnownObject(msg);
// Make sure that this isn't an AppDomain object since we don't allow
// calls to the AppDomain from out of process (and x-process calls
// are always dispatched through this method)
if (srvId.ServerType == typeof(System.AppDomain))
{
throw new RemotingException(
Environment.GetResourceString(
"Remoting_AppDomainsCantBeCalledRemotely"));
}
IMethodCallMessage mcm = msg as IMethodCallMessage;
if (mcm == null)
{
// It's a plain IMessage, so just check to make sure that the
// target object implements IMessageSink and dispatch synchronously.
if (!typeof(IMessageSink).IsAssignableFrom(srvId.ServerType))
{
throw new RemotingException(
Environment.GetResourceString(
"Remoting_AppDomainsCantBeCalledRemotely"));
}
processing = ServerProcessing.Complete;
replyMsg = ChannelServices.GetCrossContextChannelSink().SyncProcessMessage(msg);
}
else
{
// It's an IMethodCallMessage.
// Check if the method is one way. Dispatch one way calls in
// an asynchronous manner
MethodInfo method = (MethodInfo)mcm.MethodBase;
// X-process / X-machine calls should be to non-static
// public methods only! Non-public or static methods can't
// be called remotely.
if ((!method.IsPublic || method.IsStatic) &&
!RemotingServices.IsMethodAllowedRemotely(method))
{
throw new RemotingException(
Environment.GetResourceString(
"Remoting_NonPublicOrStaticCantBeCalledRemotely"));
}
RemotingMethodCachedData cache = (RemotingMethodCachedData)
InternalRemotingServices.GetReflectionCachedData(method);
/*
* FUTURE:
* Dispatching asynchronously was cut from v1. We should reactivate
* the following code in v1.x or v2.
*
* // look for async method version
* MethodInfo begin;
* MethodInfo end;
* ServerChannelSinkStack serverSinkStack = sinkStack as ServerChannelSinkStack;
* if ((sinkStack != null) &&
* cache.GetAsyncMethodVersion(out begin, out end))
* {
* processing = ServerProcessing.Async;
* IMessage asyncMsg =
* new AsyncMethodCallMessageWrapper(
* (IMethodCallMessage)msg,
* begin,
* new AsyncCallback(sinkStack.ServerCallback),
* null);
* serverSinkStack.AsyncMessage = asyncMsg;
* serverSinkStack.AsyncEnd = end;
* serverSinkStack.Message = (IMethodCallMessage)msg;
* asyncMsg.Properties["__SinkStack"] = sinkStack;
*
* // We don't dispatch yet. That happens when the server transport sink
* // eventually calls sinkStack.StoreAndDispatch(...).
* }
* else
*/
if (RemotingServices.IsOneWay(method))
{
processing = ServerProcessing.OneWay;
ChannelServices.GetCrossContextChannelSink().AsyncProcessMessage(msg, null);
}
else
{
// regular processing
processing = ServerProcessing.Complete;
replyMsg = ChannelServices.GetCrossContextChannelSink().SyncProcessMessage(msg);
}
} // end of case for IMethodCallMessage
}
catch (Exception e)
{
if (processing != ServerProcessing.OneWay)
{
try
{
IMethodCallMessage mcm =
(IMethodCallMessage)((msg != null)?msg:new ErrorMessage());
replyMsg = (IMessage) new ReturnMessage(e, mcm);
if (msg != null)
{
((ReturnMessage)replyMsg).SetLogicalCallContext(
(LogicalCallContext)
msg.Properties[Message.CallContextKey]);
}
}
catch (Exception)
{
// Fatal exception .. ignore
}
}
}
return(processing);
} // DispatchMessage
public ServerProcessing ProcessMessage(IServerChannelSinkStack sinkStack, IMessage requestMsg, ITransportHeaders requestHeaders, Stream requestStream, out IMessage responseMsg, out ITransportHeaders responseHeaders, out Stream responseStream)
{
responseHeaders = null;
responseStream = null;
return(ChannelServices.DispatchMessage(sinkStack, requestMsg, out responseMsg));
}
internal static void RegisterChannel()
{
CrossAppDomainChannel adc = CrossAppDomainChannel.AppDomainChannel;
ChannelServices.RegisterChannelInternal((IChannel)adc);
}
internal static void RegisterChannel()
{
CrossAppDomainChannel appDomainChannel = CrossAppDomainChannel.AppDomainChannel;
ChannelServices.RegisterChannelInternal(appDomainChannel, false);
}
[System.Security.SecurityCritical] // auto-generated_required
public static ServerProcessing DispatchMessage(
IServerChannelSinkStack sinkStack,
IMessage msg,
out IMessage replyMsg)
{
ServerProcessing processing = ServerProcessing.Complete;
replyMsg = null;
try
{
if (null == msg)
{
throw new ArgumentNullException("msg");
}
BCLDebug.Trace("REMOTE", "Dispatching for URI " + InternalSink.GetURI(msg));
// we must switch to the target context of the object and call the context chains etc...
// Currenly XContextChannel does exactly so. So this method is just a wrapper..
// <
// Make sure that incoming calls are counted as a remote call. This way it
// makes more sense on a server.
IncrementRemoteCalls();
// Check if the object has been disconnected or if it is
// a well known object then we have to create it lazily.
ServerIdentity srvId = CheckDisconnectedOrCreateWellKnownObject(msg);
// Make sure that this isn't an AppDomain object since we don't allow
// calls to the AppDomain from out of process (and x-process calls
// are always dispatched through this method)
if (srvId.ServerType == typeof(System.AppDomain))
{
throw new RemotingException(
Environment.GetResourceString(
"Remoting_AppDomainsCantBeCalledRemotely"));
}
IMethodCallMessage mcm = msg as IMethodCallMessage;
if (mcm == null)
{
// It's a plain IMessage, so just check to make sure that the
// target object implements IMessageSink and dispatch synchronously.
if (!typeof(IMessageSink).IsAssignableFrom(srvId.ServerType))
{
throw new RemotingException(
Environment.GetResourceString(
"Remoting_AppDomainsCantBeCalledRemotely"));
}
processing = ServerProcessing.Complete;
replyMsg = ChannelServices.GetCrossContextChannelSink().SyncProcessMessage(msg);
}
else
{
// It's an IMethodCallMessage.
// Check if the method is one way. Dispatch one way calls in
// an asynchronous manner
MethodInfo method = (MethodInfo)mcm.MethodBase;
// X-process / X-machine calls should be to non-static
// public methods only! Non-public or static methods can't
// be called remotely.
if (!IsMethodReallyPublic(method) &&
!RemotingServices.IsMethodAllowedRemotely(method))
{
throw new RemotingException(
Environment.GetResourceString(
"Remoting_NonPublicOrStaticCantBeCalledRemotely"));
}
RemotingMethodCachedData cache = (RemotingMethodCachedData)
InternalRemotingServices.GetReflectionCachedData(method);
/*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*/
if (RemotingServices.IsOneWay(method))
{
processing = ServerProcessing.OneWay;
ChannelServices.GetCrossContextChannelSink().AsyncProcessMessage(msg, null);
}
else
{
// regular processing
processing = ServerProcessing.Complete;
if (!srvId.ServerType.IsContextful)
{
Object[] args = new Object[] { msg, srvId.ServerContext };
replyMsg = (IMessage)CrossContextChannel.SyncProcessMessageCallback(args);
}
else
{
replyMsg = ChannelServices.GetCrossContextChannelSink().SyncProcessMessage(msg);
}
}
} // end of case for IMethodCallMessage
}
catch (Exception e)
{
if (processing != ServerProcessing.OneWay)
{
try
{
IMethodCallMessage mcm =
(IMethodCallMessage)((msg != null)?msg:new ErrorMessage());
replyMsg = (IMessage) new ReturnMessage(e, mcm);
if (msg != null)
{
((ReturnMessage)replyMsg).SetLogicalCallContext(
(LogicalCallContext)
msg.Properties[Message.CallContextKey]);
}
}
catch (Exception)
{
// Fatal exception .. ignore
}
}
}
return(processing);
} // DispatchMessage
public static void RegisterChannel(IChannel chnl)
{
ChannelServices.RegisterChannelInternal(chnl, false);
}
internal unsafe static void RegisterChannelInternal(IChannel chnl, bool ensureSecurity)
{
if (chnl == null)
{
throw new ArgumentNullException("chnl");
}
bool flag = false;
RuntimeHelpers.PrepareConstrainedRegions();
try
{
Monitor.Enter(ChannelServices.s_channelLock, ref flag);
string channelName = chnl.ChannelName;
RegisteredChannelList registeredChannelList = ChannelServices.s_registeredChannels;
if (channelName != null && channelName.Length != 0 && -1 != registeredChannelList.FindChannelIndex(chnl.ChannelName))
{
throw new RemotingException(Environment.GetResourceString("Remoting_ChannelNameAlreadyRegistered", new object[]
{
chnl.ChannelName
}));
}
if (ensureSecurity)
{
ISecurableChannel securableChannel = chnl as ISecurableChannel;
if (securableChannel == null)
{
throw new RemotingException(Environment.GetResourceString("Remoting_Channel_CannotBeSecured", new object[]
{
chnl.ChannelName ?? chnl.ToString()
}));
}
securableChannel.IsSecured = ensureSecurity;
}
RegisteredChannel[] registeredChannels = registeredChannelList.RegisteredChannels;
RegisteredChannel[] array;
if (registeredChannels == null)
{
array = new RegisteredChannel[1];
}
else
{
array = new RegisteredChannel[registeredChannels.Length + 1];
}
if (!ChannelServices.unloadHandlerRegistered && !(chnl is CrossAppDomainChannel))
{
AppDomain.CurrentDomain.DomainUnload += ChannelServices.UnloadHandler;
ChannelServices.unloadHandlerRegistered = true;
}
int channelPriority = chnl.ChannelPriority;
int i;
for (i = 0; i < registeredChannels.Length; i++)
{
RegisteredChannel registeredChannel = registeredChannels[i];
if (channelPriority > registeredChannel.Channel.ChannelPriority)
{
array[i] = new RegisteredChannel(chnl);
break;
}
array[i] = registeredChannel;
}
if (i == registeredChannels.Length)
{
array[registeredChannels.Length] = new RegisteredChannel(chnl);
}
else
{
while (i < registeredChannels.Length)
{
array[i + 1] = registeredChannels[i];
i++;
}
}
if (ChannelServices.perf_Contexts != null)
{
ChannelServices.perf_Contexts->cChannels++;
}
ChannelServices.s_registeredChannels = new RegisteredChannelList(array);
ChannelServices.RefreshChannelData();
}
finally
{
if (flag)
{
Monitor.Exit(ChannelServices.s_channelLock);
}
}
}
internal static void UnloadHandler(object sender, EventArgs e)
{
ChannelServices.StopListeningOnAllChannels();
}
public static void RegisterChannel(IChannel chnl, bool ensureSecurity)
{
ChannelServices.RegisterChannelInternal(chnl, ensureSecurity);
}
public static ServerProcessing DispatchMessage(IServerChannelSinkStack sinkStack, IMessage msg, out IMessage replyMsg)
{
ServerProcessing serverProcessing = ServerProcessing.Complete;
replyMsg = null;
try
{
if (msg == null)
{
throw new ArgumentNullException("msg");
}
ChannelServices.IncrementRemoteCalls();
ServerIdentity serverIdentity = ChannelServices.CheckDisconnectedOrCreateWellKnownObject(msg);
if (serverIdentity.ServerType == typeof(AppDomain))
{
throw new RemotingException(Environment.GetResourceString("Remoting_AppDomainsCantBeCalledRemotely"));
}
IMethodCallMessage methodCallMessage = msg as IMethodCallMessage;
if (methodCallMessage == null)
{
if (!typeof(IMessageSink).IsAssignableFrom(serverIdentity.ServerType))
{
throw new RemotingException(Environment.GetResourceString("Remoting_AppDomainsCantBeCalledRemotely"));
}
serverProcessing = ServerProcessing.Complete;
replyMsg = ChannelServices.GetCrossContextChannelSink().SyncProcessMessage(msg);
}
else
{
MethodInfo methodInfo = (MethodInfo)methodCallMessage.MethodBase;
if (!ChannelServices.IsMethodReallyPublic(methodInfo) && !RemotingServices.IsMethodAllowedRemotely(methodInfo))
{
throw new RemotingException(Environment.GetResourceString("Remoting_NonPublicOrStaticCantBeCalledRemotely"));
}
RemotingMethodCachedData reflectionCachedData = InternalRemotingServices.GetReflectionCachedData(methodInfo);
if (RemotingServices.IsOneWay(methodInfo))
{
serverProcessing = ServerProcessing.OneWay;
ChannelServices.GetCrossContextChannelSink().AsyncProcessMessage(msg, null);
}
else
{
serverProcessing = ServerProcessing.Complete;
if (!serverIdentity.ServerType.IsContextful)
{
object[] args = new object[]
{
msg,
serverIdentity.ServerContext
};
replyMsg = (IMessage)CrossContextChannel.SyncProcessMessageCallback(args);
}
else
{
replyMsg = ChannelServices.GetCrossContextChannelSink().SyncProcessMessage(msg);
}
}
}
}
catch (Exception e)
{
if (serverProcessing != ServerProcessing.OneWay)
{
try
{
IMessage message2;
if (msg == null)
{
IMessage message = new ErrorMessage();
message2 = message;
}
else
{
message2 = msg;
}
IMethodCallMessage mcm = (IMethodCallMessage)message2;
replyMsg = new ReturnMessage(e, mcm);
if (msg != null)
{
((ReturnMessage)replyMsg).SetLogicalCallContext((LogicalCallContext)msg.Properties[Message.CallContextKey]);
}
}
catch (Exception)
{
}
}
}
return(serverProcessing);
}
internal static void IncrementRemoteCalls()
{
ChannelServices.IncrementRemoteCalls(1L);
}
internal static IMessageSink CreateMessageSink(object data)
{
string text;
return(ChannelServices.CreateMessageSink(null, data, out text));
}