We need you! We're working hard on the next version of Developer Fusion - Let us know what you think we should be up to!

The Labs \ Source Viewer \ SSCLI \ System.Runtime.Remoting.Channels \ ChannelServices

SSCLI

// ==++==
//
//
//
// The use and distribution terms for this software are contained in the file
// named license.txt, which can be found in the root of this distribution.
// By using this software in any fashion, you are agreeing to be bound by the
// terms of this license.
//
// You must not remove this notice, or any other, from this software.
//
//
// ==--==
//* File: Channel.cs
//*
//*
//*
//* Purpose: Defines the general purpose remoting proxy
//*
//* Date: May 27, 1999
//*
namespace System.Runtime.Remoting.Channels
{
using System;
using System.Collections;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Remoting;
using System.Runtime.Remoting.Activation;
using System.Runtime.Remoting.Messaging;
using System.Runtime.Remoting.Metadata;
using System.Runtime.Remoting.Proxies;
using System.Threading;
using System.Security.Permissions;
using System.Globalization;
// ChannelServices
[System.Runtime.InteropServices.StructLayout(LayoutKind.Sequential)]
internal struct Perf_Contexts
{
internal int cRemoteCalls;
internal int cChannels;
}
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class ChannelServices
{
// This gets refreshed when a channel is registered/unregistered.
private static object[] s_currentChannelData = null;
static internal object[] CurrentChannelData {
get {
if (s_currentChannelData == null)
RefreshChannelData();
return s_currentChannelData;
}
}
// CurrentChannelData
// hide the default constructor
private ChannelServices()
{
}
// list of registered channels and a lock to take when adding or removing channels
private static object s_channelLock = new object();
private static RegisteredChannelList s_registeredChannels = new RegisteredChannelList();
// Private member variables
// These have all been converted to getters and setters to get the effect of
// per-AppDomain statics (note: statics are per-AppDomain now, so these members
// could just be declared as statics on ChannelServices).
private static long remoteCalls {
get { return Thread.GetDomain().RemotingData.ChannelServicesData.remoteCalls; }
set { Thread.GetDomain().RemotingData.ChannelServicesData.remoteCalls = value; }
}
private static IMessageSink xCtxChannel;
[MethodImplAttribute(MethodImplOptions.InternalCall)]
unsafe static extern Perf_Contexts* GetPrivateContextsPerfCounters();
unsafe private static Perf_Contexts* perf_Contexts = GetPrivateContextsPerfCounters();
[SecurityPermissionAttribute(SecurityAction.Demand, Flags = SecurityPermissionFlag.RemotingConfiguration)]
public static void RegisterChannel(IChannel chnl, bool ensureSecurity)
{
RegisterChannelInternal(chnl, ensureSecurity);
}
[SecurityPermissionAttribute(SecurityAction.Demand, Flags = SecurityPermissionFlag.RemotingConfiguration)]
[Obsolete("Use System.Runtime.Remoting.ChannelServices.RegisterChannel(IChannel chnl, bool ensureSecurity) instead.", false)]
public static void RegisterChannel(IChannel chnl)
{
/*ensureSecurity*/ RegisterChannelInternal(chnl, false);
}
static bool unloadHandlerRegistered = false;
unsafe static internal void RegisterChannelInternal(IChannel chnl, bool ensureSecurity)
{
// Validate arguments
if (null == chnl) {
throw new ArgumentNullException("chnl");
}
bool fLocked = false;
RuntimeHelpers.PrepareConstrainedRegions();
try {
Monitor.ReliableEnter(s_channelLock, ref fLocked);
string chnlName = chnl.ChannelName;
RegisteredChannelList regChnlList = s_registeredChannels;
// Check to make sure that the channel has not been registered
if ((chnlName == null) || (chnlName.Length == 0) || (-1 == regChnlList.FindChannelIndex(chnl.ChannelName))) {
if (ensureSecurity) {
ISecurableChannel securableChannel = chnl as ISecurableChannel;
if (securableChannel != null)
securableChannel.IsSecured = ensureSecurity;
else
throw new RemotingException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Remoting_Channel_CannotBeSecured"), chnl.ChannelName ?? chnl.ToString()));
}
RegisteredChannel[] oldList = regChnlList.RegisteredChannels;
RegisteredChannel[] newList = null;
if (oldList == null) {
newList = new RegisteredChannel[1];
}
else
newList = new RegisteredChannel[oldList.Length + 1];
if (!unloadHandlerRegistered && !(chnl is CrossAppDomainChannel)) {
// Register a unload handler only once and if the channel being registered
// is not the x-domain channel. x-domain channel does nothing inside its
// StopListening implementation
AppDomain.CurrentDomain.DomainUnload += new EventHandler(UnloadHandler);
unloadHandlerRegistered = true;
}
// Add the interface to the array in priority order
int priority = chnl.ChannelPriority;
int current = 0;
// Find the place in the array to insert
while (current < oldList.Length) {
RegisteredChannel oldChannel = oldList[current];
if (priority > oldChannel.Channel.ChannelPriority) {
newList[current] = new RegisteredChannel(chnl);
break;
}
else {
newList[current] = oldChannel;
current++;
}
}
if (current == oldList.Length) {
// chnl has lower priority than all old channels, so we insert
// it at the end of the list.
newList[oldList.Length] = new RegisteredChannel(chnl);
}
else {
// finish copying rest of the old channels
while (current < oldList.Length) {
newList[current + 1] = oldList[current];
current++;
}
}
if (perf_Contexts != null) {
perf_Contexts->cChannels++;
}
s_registeredChannels = new RegisteredChannelList(newList);
}
else {
throw new RemotingException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Remoting_ChannelNameAlreadyRegistered"), chnl.ChannelName));
}
RefreshChannelData();
}
// lock (s_channelLock)
finally {
if (fLocked) {
Monitor.Exit(s_channelLock);
}
}
}
// RegisterChannelInternal
[SecurityPermissionAttribute(SecurityAction.Demand, Flags = SecurityPermissionFlag.RemotingConfiguration)]
unsafe public static void UnregisterChannel(IChannel chnl)
{
// we allow null to be passed in, so we can use this api to trigger the
// refresh of the channel data
bool fLocked = false;
RuntimeHelpers.PrepareConstrainedRegions();
try {
Monitor.ReliableEnter(s_channelLock, ref fLocked);
if (chnl != null) {
RegisteredChannelList regChnlList = s_registeredChannels;
// Check to make sure that the channel has been registered
int matchingIdx = regChnlList.FindChannelIndex(chnl);
if (-1 == matchingIdx) {
throw new RemotingException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Remoting_ChannelNotRegistered"), chnl.ChannelName));
}
RegisteredChannel[] oldList = regChnlList.RegisteredChannels;
RegisteredChannel[] newList = null;
BCLDebug.Assert((oldList != null) && (oldList.Length != 0), "channel list should not be empty");
newList = new RegisteredChannel[oldList.Length - 1];
// Call stop listening on the channel if it is a receiver.
IChannelReceiver srvChannel = chnl as IChannelReceiver;
if (srvChannel != null)
srvChannel.StopListening(null);
int current = 0;
int oldPos = 0;
while (oldPos < oldList.Length) {
if (oldPos == matchingIdx) {
oldPos++;
}
else {
newList[current] = oldList[oldPos];
current++;
oldPos++;
}
}
if (perf_Contexts != null) {
perf_Contexts->cChannels--;
}
s_registeredChannels = new RegisteredChannelList(newList);
}
RefreshChannelData();
}
// lock (s_channelLock)
finally {
if (fLocked) {
Monitor.Exit(s_channelLock);
}
}
}
// UnregisterChannel
public static IChannel[] RegisteredChannels {
[SecurityPermissionAttribute(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.Infrastructure)]
get {
RegisteredChannelList regChnlList = s_registeredChannels;
int count = regChnlList.Count;
if (0 == count) {
return new IChannel[0];
}
else {
// we hide the CrossAppDomainChannel, so the number of visible
// channels is one less than the number of registered channels.
int visibleChannels = count - 1;
// Copy the array of visible channels into a new array
// and return
int co = 0;
IChannel[] temp = new IChannel[visibleChannels];
for (int i = 0; i < count; i++) {
IChannel channel = regChnlList.GetChannel(i);
// add the channel to the array if it is not the CrossAppDomainChannel
if (!(channel is CrossAppDomainChannel))
temp[co++] = channel;
}
return temp;
}
}
}
// RegisteredChannels
static internal IMessageSink CreateMessageSink(string url, object data, out string objectURI)
{
BCLDebug.Trace("REMOTE", "ChannelServices::CreateMessageSink for url " + url + "\n");
IMessageSink msgSink = null;
objectURI = null;
RegisteredChannelList regChnlList = s_registeredChannels;
int count = regChnlList.Count;
for (int i = 0; i < count; i++) {
if (regChnlList.IsSender(i)) {
IChannelSender chnl = (IChannelSender)regChnlList.GetChannel(i);
msgSink = chnl.CreateMessageSink(url, data, out objectURI);
if (msgSink != null)
break;
}
}
// If the object uri has not been set, set it to the url as
// default value
if (null == objectURI) {
objectURI = url;
}
return msgSink;
}
// CreateMessageSink
static internal IMessageSink CreateMessageSink(object data)
{
string objectUri;
return CreateMessageSink(null, data, out objectUri);
}
// CreateMessageSink
[SecurityPermissionAttribute(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.Infrastructure)]
public static IChannel GetChannel(string name)
{
RegisteredChannelList regChnlList = s_registeredChannels;
int matchingIdx = regChnlList.FindChannelIndex(name);
if (0 <= matchingIdx) {
IChannel channel = regChnlList.GetChannel(matchingIdx);
if ((channel is CrossAppDomainChannel) || (channel is CrossContextChannel))
return null;
else
return channel;
}
else {
return null;
}
}
// GetChannel
[SecurityPermissionAttribute(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.Infrastructure)]
public static string[] GetUrlsForObject(MarshalByRefObject obj)
{
if (null == obj) {
return null;
}
RegisteredChannelList regChnlList = s_registeredChannels;
int count = regChnlList.Count;
Hashtable table = new Hashtable();
bool fServer;
Identity id = MarshalByRefObject.GetIdentity(obj, out fServer);
if (null != id) {
string uri = id.ObjURI;
if (null != uri) {
for (int i = 0; i < count; i++) {
if (regChnlList.IsReceiver(i)) {
try {
string[] urls = ((IChannelReceiver)regChnlList.GetChannel(i)).GetUrlsForUri(uri);
// Add the strings to the table
for (int j = 0; j < urls.Length; j++) {
table.Add(urls[j], urls[j]);
}
}
catch (NotSupportedException) {
// We do not count the channels that do not
// support this method
}
}
}
}
}
// copy url's into string array
ICollection keys = table.Keys;
string[] urlList = new string[keys.Count];
int co = 0;
foreach (string key in keys) {
urlList[co++] = key;
}
return urlList;
}
// Find the channel message sink associated with a given proxy
static internal IMessageSink GetChannelSinkForProxy(object obj)
{
IMessageSink sink = null;
if (RemotingServices.IsTransparentProxy(obj)) {
RealProxy rp = RemotingServices.GetRealProxy(obj);
RemotingProxy remProxy = rp as RemotingProxy;
if (null != remProxy) {
Identity idObj = remProxy.IdentityObject;
BCLDebug.Assert(null != idObj, "null != idObj");
sink = idObj.ChannelSink;
}
}
return sink;
}
// GetChannelSinkForProxy
// Get the message sink dictionary of properties for a given proxy
[SecurityPermissionAttribute(SecurityAction.Demand, Flags = SecurityPermissionFlag.RemotingConfiguration)]
public static IDictionary GetChannelSinkProperties(object obj)
{
IMessageSink sink = GetChannelSinkForProxy(obj);
IClientChannelSink chnlSink = sink as IClientChannelSink;
if (null != chnlSink) {
// collect dictionaries for all channel sinks and return
// aggregate dictionary
ArrayList dictionaries = new ArrayList();
do {
IDictionary dict = chnlSink.Properties;
if (dict != null)
dictionaries.Add(dict);
chnlSink = chnlSink.NextChannelSink;
}
while (chnlSink != null);
return new AggregateDictionary(dictionaries);
}
else {
IDictionary dict = sink as IDictionary;
if (null != dict) {
return dict;
}
else {
return null;
}
}
}
// GetChannelSinkProperties
static internal IMessageSink GetCrossContextChannelSink()
{
if (null == xCtxChannel) {
xCtxChannel = CrossContextChannel.MessageSink;
}
return xCtxChannel;
}
// GetCrossContextChannelSink
#if DEBUG
// A few methods to count the number of calls made across appdomains,
// processes and machines
static internal long GetNumberOfRemoteCalls()
{
return remoteCalls;
}
// GetNumberOfRemoteCalls
#endif //DEBUG
unsafe static internal void IncrementRemoteCalls(long cCalls)
{
remoteCalls += cCalls;
if (perf_Contexts != null)
perf_Contexts->cRemoteCalls += (int)cCalls;
}
// IncrementRemoteCalls
static internal void IncrementRemoteCalls()
{
IncrementRemoteCalls(1);
}
// IncrementRemoteCalls
static internal void RefreshChannelData()
{
bool fLocked = false;
RuntimeHelpers.PrepareConstrainedRegions();
try {
Monitor.ReliableEnter(s_channelLock, ref fLocked);
s_currentChannelData = CollectChannelDataFromChannels();
}
finally {
if (fLocked) {
Monitor.Exit(s_channelLock);
}
}
}
// RefreshChannelData
private static object[] CollectChannelDataFromChannels()
{
// Ensure that our native cross-context & cross-domain channels
// are registered
RemotingServices.RegisterWellKnownChannels();
RegisteredChannelList regChnlList = s_registeredChannels;
int count = regChnlList.Count;
// Compute the number of channels that implement IChannelReceiver
int numChnls = regChnlList.ReceiverCount;
// Allocate array for channel data
object[] data = new object[numChnls];
// we need to remove null entries
int nonNullDataCount = 0;
// Set the channel data, names and mime types
for (int i = 0int j = 0; i < count; i++) {
IChannel chnl = regChnlList.GetChannel(i);
if (null == chnl) {
throw new RemotingException(String.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Remoting_ChannelNotRegistered"), ""));
}
if (regChnlList.IsReceiver(i)) {
BCLDebug.Trace("REMOTE", "Setting info for receiver " + j + "\n");
// Extract the data
object channelData = ((IChannelReceiver)chnl).ChannelData;
data[j] = channelData;
if (channelData != null)
nonNullDataCount++;
// Increment the counter
j++;
}
}
if (nonNullDataCount != numChnls) {
// there were null entries, so remove them.
object[] nonNullData = new object[nonNullDataCount];
int nonNullCounter = 0;
for (int co = 0; co < numChnls; co++) {
object channelData = data[co];
if (channelData != null)
nonNullData[nonNullCounter++] = channelData;
}
data = nonNullData;
}
return data;
}
// CollectChannelDataFromChannels
// Checks to make sure the remote method being invoked is callable
static bool IsMethodReallyPublic(MethodInfo mi)
{
if (!mi.IsPublic || mi.IsStatic)
return false;
if (!mi.IsGenericMethod)
return true;
foreach (Type t in mi.GetGenericArguments())
if (!t.IsVisible)
return false;
return true;
}
//--------------------------------------------------------------------
//----------------------- Dispatch Support ------------------------
//--------------------------------------------------------------------
[SecurityPermissionAttribute(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.Infrastructure)]
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);
/*
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;
if (!srvId.ServerType.IsContextful) {
object[] args = new object[] {msg, srvId.ServerContext};
&nbs