internal static ServerIdentity FindOrCreateServerIdentity(MarshalByRefObject obj, string objURI, int flags)
{
ServerIdentity idObj = null;
bool flag;
idObj = (ServerIdentity)MarshalByRefObject.GetIdentity(obj, out flag);
if (idObj == null)
{
Context serverCtx = null;
if (obj is ContextBoundObject)
{
serverCtx = Thread.CurrentContext;
}
else
{
serverCtx = DefaultContext;
}
ServerIdentity id = new ServerIdentity(obj, serverCtx);
if (flag)
{
idObj = obj.__RaceSetServerIdentity(id);
}
else
{
RealProxy realProxy = null;
realProxy = RemotingServices.GetRealProxy(obj);
realProxy.IdentityObject = id;
idObj = (ServerIdentity)realProxy.IdentityObject;
}
}
if (IdOps.bStrongIdentity(flags))
{
ReaderWriterLock tableLock = TableLock;
bool flag2 = !tableLock.IsWriterLockHeld;
RuntimeHelpers.PrepareConstrainedRegions();
try
{
if (flag2)
{
tableLock.AcquireWriterLock(0x7fffffff);
}
if ((idObj.ObjURI == null) || !idObj.IsInIDTable())
{
SetIdentity(idObj, objURI, DuplicateIdentityOption.Unique);
}
if (idObj.IsDisconnected())
{
idObj.SetFullyConnected();
}
}
finally
{
if (flag2 && tableLock.IsWriterLockHeld)
{
tableLock.ReleaseWriterLock();
}
}
}
return(idObj);
}
internal static bool RemoveDynamicProperty(MarshalByRefObject obj, String name)
{
if (RemotingServices.IsObjectOutOfContext(obj))
{
// We have to add a proxy side property, get the identity
RealProxy rp = RemotingServices.GetRealProxy(obj);
return(rp.IdentityObject.RemoveProxySideDynamicProperty(name));
}
else
{
MarshalByRefObject realObj =
(MarshalByRefObject)
RemotingServices.AlwaysUnwrap((ContextBoundObject)obj);
// This is a real object. See if we have an identity for it
ServerIdentity srvID = (ServerIdentity)MarshalByRefObject.GetIdentity(realObj);
if (srvID != null)
{
return(srvID.RemoveServerSideDynamicProperty(name));
}
else
{
// identity not found, we can't set a sink for this object.
throw new RemotingException(
Environment.GetResourceString("Remoting_NoIdentityEntry"));
}
}
}
internal MethodCall(object handlerObject, BinaryMethodCallMessage smuggledMsg)
{
if (handlerObject != null)
{
this.uri = handlerObject as string;
if (this.uri == null)
{
MarshalByRefObject obj2 = handlerObject as MarshalByRefObject;
if (obj2 != null)
{
bool flag;
this.srvID = MarshalByRefObject.GetIdentity(obj2, out flag) as ServerIdentity;
this.uri = this.srvID.URI;
}
}
}
this.typeName = smuggledMsg.TypeName;
this.methodName = smuggledMsg.MethodName;
this.methodSignature = (Type[]) smuggledMsg.MethodSignature;
this.args = smuggledMsg.Args;
this.instArgs = smuggledMsg.InstantiationArgs;
this.callContext = smuggledMsg.LogicalCallContext;
this.ResolveMethod();
if (smuggledMsg.HasProperties)
{
smuggledMsg.PopulateMessageProperties(this.Properties);
}
}
internal static IEnvoyInfo CreateEnvoyInfo(ServerIdentity serverID)
{
IEnvoyInfo info = null;
if (null != serverID)
{
// Set the envoy sink chain
if (serverID.EnvoyChain == null)
{
serverID.RaceSetEnvoyChain(
serverID.ServerContext.CreateEnvoyChain(
serverID.TPOrObject));
}
// Create an envoy info object only if necessary
IMessageSink sink = serverID.EnvoyChain as EnvoyTerminatorSink;
if (null == sink)
{
// The chain consists of more than a terminator sink
// Go ahead and create an envoy info structure, otherwise
// a null is returned and we recreate the terminator sink
// on the other side, automatically.
info = new EnvoyInfo(serverID.EnvoyChain);
}
}
return(info);
}
public void StopTrackingLifetime (ServerIdentity identity)
{
lock (_objects.SyncRoot)
{
_objects.Remove (identity);
}
}
public static bool IsObjectOutOfContext(object tp)
{
MarshalByRefObject mbr = tp as MarshalByRefObject;
if (mbr == null)
{
return(false);
}
// TODO: use internal call for better performance
Identity ident = GetObjectIdentity(mbr);
if (ident == null)
{
return(false);
}
ServerIdentity sident = ident as ServerIdentity;
if (sident != null)
{
return(sident.Context != System.Threading.Thread.CurrentContext);
}
else
{
return(true);
}
}
internal AsyncWorkItem(IMessage reqMsg, IMessageSink replySink, Context oldCtx, ServerIdentity srvID)
{
this._reqMsg = reqMsg;
this._replySink = replySink;
this._oldCtx = oldCtx;
this._callCtx = CallContext.GetLogicalCallContext();
this._srvID = srvID;
}
public void TrackLifetime (ServerIdentity identity)
{
lock (_objects.SyncRoot)
{
identity.Lease.Activate();
_objects.Add (identity);
if (_timer == null) StartManager();
}
}
public static Type GetServerTypeForUri(string URI)
{
ServerIdentity ident = GetIdentityForUri(URI) as ServerIdentity;
if (ident == null)
{
return(null);
}
return(ident.ObjectType);
}
internal static ServerIdentity FindOrCreateServerIdentity(MarshalByRefObject obj, string objURI, int flags)
{
bool fServer;
ServerIdentity serverIdentity1 = (ServerIdentity)MarshalByRefObject.GetIdentity(obj, out fServer);
if (serverIdentity1 == null)
{
Context serverCtx = !(obj is ContextBoundObject) ? IdentityHolder.DefaultContext : Thread.CurrentContext;
ServerIdentity id = new ServerIdentity(obj, serverCtx);
if (fServer)
{
serverIdentity1 = obj.__RaceSetServerIdentity(id);
}
else
{
RealProxy realProxy = RemotingServices.GetRealProxy((object)obj);
ServerIdentity serverIdentity2 = id;
realProxy.IdentityObject = (Identity)serverIdentity2;
serverIdentity1 = (ServerIdentity)realProxy.IdentityObject;
}
if (IdOps.bIsInitializing(flags))
{
serverIdentity1.IsInitializing = true;
}
}
if (IdOps.bStrongIdentity(flags))
{
ReaderWriterLock tableLock = IdentityHolder.TableLock;
bool flag = !tableLock.IsWriterLockHeld;
RuntimeHelpers.PrepareConstrainedRegions();
try
{
if (flag)
{
tableLock.AcquireWriterLock(int.MaxValue);
}
if (serverIdentity1.ObjURI == null || !serverIdentity1.IsInIDTable())
{
IdentityHolder.SetIdentity((Identity)serverIdentity1, objURI, DuplicateIdentityOption.Unique);
}
if (serverIdentity1.IsDisconnected())
{
serverIdentity1.SetFullyConnected();
}
}
finally
{
if (flag && tableLock.IsWriterLockHeld)
{
tableLock.ReleaseWriterLock();
}
}
}
return(serverIdentity1);
}
private static void RegisterServerIdentity(ServerIdentity identity)
{
lock (uri_hash)
{
if (uri_hash.ContainsKey(identity.ObjectUri))
{
throw new RemotingException("Uri already in use: " + identity.ObjectUri + ".");
}
uri_hash[identity.ObjectUri] = identity;
}
}
internal ServerIdentity __RaceSetServerIdentity(ServerIdentity id)
{
if (this.__identity == null)
{
if (!id.IsContextBound)
{
id.RaceSetTransparentProxy(this);
}
Interlocked.CompareExchange(ref this.__identity, id, null);
}
return (ServerIdentity) this.__identity;
}
internal ServerIdentity StartupWellKnownObject(string URI)
{
string str = URI.ToLower(CultureInfo.InvariantCulture);
ServerIdentity identity = null;
WellKnownServiceTypeEntry entry = (WellKnownServiceTypeEntry)this._wellKnownExportInfo[str];
if (entry != null)
{
identity = this.StartupWellKnownObject(entry.AssemblyName, entry.TypeName, entry.ObjectUri, entry.Mode);
}
return(identity);
}
internal TransitionCall(IntPtr targetCtxID, CrossContextDelegate deleg)
{
this._sourceCtxID = Thread.CurrentContext.InternalContextID;
this._targetCtxID = targetCtxID;
this._delegate = deleg;
this._targetDomainID = 0;
this._eeData = IntPtr.Zero;
this._srvID = new ServerIdentity(null, Thread.GetContextInternal(this._targetCtxID));
this._ID = this._srvID;
this._ID.RaceSetChannelSink(CrossContextChannel.MessageSink);
this._srvID.RaceSetServerObjectChain(this);
}
internal static bool RemoveDynamicProperty(MarshalByRefObject obj, string name)
{
if (RemotingServices.IsObjectOutOfContext((object)obj))
{
return(RemotingServices.GetRealProxy((object)obj).IdentityObject.RemoveProxySideDynamicProperty(name));
}
ServerIdentity serverIdentity = (ServerIdentity)MarshalByRefObject.GetIdentity((MarshalByRefObject)RemotingServices.AlwaysUnwrap((ContextBoundObject)obj));
if (serverIdentity != null)
{
return(serverIdentity.RemoveServerSideDynamicProperty(name));
}
throw new RemotingException(Environment.GetResourceString("Remoting_NoIdentityEntry"));
}
internal TransitionCall(IntPtr targetCtxID, IntPtr eeData, int targetDomainID)
{
string str;
this._sourceCtxID = Thread.CurrentContext.InternalContextID;
this._targetCtxID = targetCtxID;
this._delegate = null;
this._targetDomainID = targetDomainID;
this._eeData = eeData;
this._srvID = null;
this._ID = new Identity("TransitionCallURI", null);
CrossAppDomainData data = new CrossAppDomainData(this._targetCtxID, this._targetDomainID, Identity.ProcessGuid);
IMessageSink channelSink = CrossAppDomainChannel.AppDomainChannel.CreateMessageSink(null, data, out str);
this._ID.RaceSetChannelSink(channelSink);
}
internal static bool AddDynamicProperty(MarshalByRefObject obj, IDynamicProperty prop)
{
if (RemotingServices.IsObjectOutOfContext(obj))
{
return(RemotingServices.GetRealProxy(obj).IdentityObject.AddProxySideDynamicProperty(prop));
}
MarshalByRefObject obj2 = (MarshalByRefObject)RemotingServices.AlwaysUnwrap((ContextBoundObject)obj);
ServerIdentity identity = (ServerIdentity)MarshalByRefObject.GetIdentity(obj2);
if (identity == null)
{
throw new RemotingException(Environment.GetResourceString("Remoting_NoIdentityEntry"));
}
return(identity.AddServerSideDynamicProperty(prop));
}
internal static IEnvoyInfo CreateEnvoyInfo(ServerIdentity serverID)
{
IEnvoyInfo result = null;
if (serverID != null)
{
if (serverID.EnvoyChain == null)
{
serverID.RaceSetEnvoyChain(serverID.ServerContext.CreateEnvoyChain(serverID.TPOrObject));
}
if (!(serverID.EnvoyChain is EnvoyTerminatorSink))
{
result = new EnvoyInfo(serverID.EnvoyChain);
}
}
return(result);
}
} // DumpIdentities
internal static Identity DumpIdentity(String idUri)
{
// We don't want to take locks. This will only be called from the debugger.
// To use from cordbg:
// newstr "object-uri"
// f System.Runtime.Remoting.IdentityHolder::DumpIdentity $result
Object obj = _URITable[MakeURIKey(idUri)];
Identity id = null;
if (obj is WeakReference)
{
id = ((WeakReference)obj).Target as Identity;
}
else
{
id = obj as Identity;
}
if (id != null)
{
Console.Error.WriteLine("Identity: " + idUri);
String uri = id.URI;
ServerIdentity srvId = id as ServerIdentity;
if (srvId != null)
{
Console.Error.WriteLine("\tserver: " + srvId.ServerType + "; uri = <" + uri + ">");
}
else
{
Console.Error.WriteLine("\tclient: uri = <" + uri + ">");
}
}
else
{
Console.Error.WriteLine("No identity found: " + idUri);
}
return(id);
} // DumpIdentity
internal static IEnvoyInfo CreateEnvoyInfo(ServerIdentity serverID)
{
IEnvoyInfo envoyInfo = (IEnvoyInfo)null;
if (serverID != null)
{
if (serverID.EnvoyChain == null)
{
ServerIdentity serverIdentity = serverID;
IMessageSink envoyChain = serverIdentity.ServerContext.CreateEnvoyChain(serverID.TPOrObject);
serverIdentity.RaceSetEnvoyChain(envoyChain);
}
if ((IMessageSink)(serverID.EnvoyChain as EnvoyTerminatorSink) == null)
{
envoyInfo = (IEnvoyInfo) new EnvoyInfo(serverID.EnvoyChain);
}
}
return(envoyInfo);
}
internal static object ActivateWithMessage(Type serverType, IMessage msg, ServerIdentity srvIdToBind, out Exception e)
{
object obj2 = null;
e = null;
obj2 = RemotingServices.AllocateUninitializedObject(serverType);
object proxy = null;
if (serverType.IsContextful)
{
if (msg is ConstructorCallMessage)
{
proxy = ((ConstructorCallMessage) msg).GetThisPtr();
}
else
{
proxy = null;
}
proxy = RemotingServices.Wrap((ContextBoundObject) obj2, proxy, false);
}
else
{
if (Thread.CurrentContext != Context.DefaultContext)
{
throw new RemotingException(Environment.GetResourceString("Remoting_Activation_Failed"));
}
proxy = obj2;
}
IMessageSink sink = new StackBuilderSink(proxy);
IMethodReturnMessage message = (IMethodReturnMessage) sink.SyncProcessMessage(msg);
if (message.Exception == null)
{
if (serverType.IsContextful)
{
return RemotingServices.Wrap((ContextBoundObject) obj2);
}
return obj2;
}
e = message.Exception;
return null;
}
//
// DEBUG Helpers
// Note: These methods should be included even in retail builds so that
// they can be called from the debugger.
//
internal static void DumpIdentities()
{
// We don't want to take locks. This will only be called from the debugger.
// To use from cordbg:
// f System.Runtime.Remoting.IdentityHolder::DumpIdentities
Console.Error.WriteLine("Identity Table:");
foreach (DictionaryEntry entry in _URITable)
{
Object obj = entry.Value;
Identity id = null;
if (obj is WeakReference)
{
id = ((WeakReference)obj).Target as Identity;
}
else
{
id = obj as Identity;
}
if (id != null)
{
String uri = id.URI;
ServerIdentity srvId = id as ServerIdentity;
if (srvId != null)
{
Console.Error.WriteLine("server: " + srvId.ServerType + "; uri = <" + uri + ">");
}
else
{
Console.Error.WriteLine("client: uri = <" + uri + ">");
}
}
}
} // DumpIdentities
[System.Security.SecurityCritical] // auto-generated
internal static ServerIdentity FindOrCreateServerIdentity(
MarshalByRefObject obj, String objURI, int flags)
{
Message.DebugOut("Entered FindOrCreateServerIdentity \n");
ServerIdentity srvID = null;
bool fServer;
srvID = (ServerIdentity)MarshalByRefObject.GetIdentity(obj, out fServer);
if (srvID == null)
{
// Create a new server identity and add it to the
// table. IdentityHolder will take care of ----s
Context serverCtx = null;
if (obj is ContextBoundObject)
{
serverCtx = Thread.CurrentContext;
}
else
{
serverCtx = DefaultContext;
}
Contract.Assert(null != serverCtx, "null != serverCtx");
ServerIdentity serverID = new ServerIdentity(obj, serverCtx);
// Set the identity depending on whether we have the server or proxy
if (fServer)
{
srvID = obj.__RaceSetServerIdentity(serverID);
Contract.Assert(srvID == MarshalByRefObject.GetIdentity(obj), "Bad ID state!");
}
else
{
RealProxy rp = null;
rp = RemotingServices.GetRealProxy(obj);
Contract.Assert(null != rp, "null != rp");
rp.IdentityObject = serverID;
srvID = (ServerIdentity)rp.IdentityObject;
}
// DevDiv 720951 and 911924:
// CreateWellKnownObject creates a ServerIdentity and places it in URITable
// before it is fully initialized. This transient flag is set to to prevent
// other concurrent operations from using it. CreateWellKnownObject is the
// only code path that sets this flag, and by default it is false.
if (IdOps.bIsInitializing(flags))
{
srvID.IsInitializing = true;
}
Message.DebugOut("Created ServerIdentity \n");
}
#if false
// Check that we are asked to create the identity for the same
// URI as the one already associated with the server object.
// It is an error to associate two URIs with the same server
// object
// GopalK: Try eliminating the test because it is also done by GetOrCreateIdentity
if ((null != objURI) && (null != srvID.ObjURI))
{
if (string.Compare(objURI, srvID.ObjURI, StringComparison.OrdinalIgnoreCase) == 0) // case-insensitive compare
{
Message.DebugOut("Trying to associate a URI with identity again .. throwing execption \n");
throw new RemotingException(
String.Format(
Environment.GetResourceString(
"Remoting_ResetURI"),
srvID.ObjURI, objURI));
}
}
#endif
// NOTE: for purely x-context cases we never execute this ...
// the server ID is not put in the ID table.
if (IdOps.bStrongIdentity(flags))
{
// We need to guarantee that finally is not interrupted so that the lock is released.
// TableLock has a long path without reliability contract. To avoid adding contract on
// the path, we will use ReaderWriterLock directly.
ReaderWriterLock rwlock = TableLock;
bool takeAndRelease = !rwlock.IsWriterLockHeld;
RuntimeHelpers.PrepareConstrainedRegions();
try
{
if (takeAndRelease)
{
rwlock.AcquireWriterLock(INFINITE);
}
// It is possible that we are marshaling out of this app-domain
// for the first time. We need to do two things
// (1) If there is no URI associated with the identity then go ahead
// and generate one.
// (2) Add the identity to the URI -> Identity map if not already present
// (For purely x-context cases we don't need the URI)
// (3) If the object ref is null, then this object hasn't been
// marshalled yet.
// (4) if id was created through SetObjectUriForMarshal, it would be
// in the ID table
if ((srvID.ObjURI == null) ||
(srvID.IsInIDTable() == false))
{
// we are marshalling a server object, so there should not be a
// a different identity at this location.
SetIdentity(srvID, objURI, DuplicateIdentityOption.Unique);
}
// If the object is marked as disconnect, mark it as connected
if (srvID.IsDisconnected())
{
srvID.SetFullyConnected();
}
}
finally
{
if (takeAndRelease && rwlock.IsWriterLockHeld)
{
rwlock.ReleaseWriterLock();
}
}
}
Message.DebugOut("Leaving FindOrCreateServerIdentity \n");
Contract.Assert(null != srvID, "null != srvID");
return(srvID);
}
internal void InitFields(MessageData msgData)
{
this._frame = msgData.pFrame;
this._delegateMD = msgData.pDelegateMD;
this._methodDesc = msgData.pMethodDesc;
this._flags = msgData.iFlags;
this._initDone = true;
this._metaSigHolder = msgData.pSig;
this._governingType = msgData.thGoverningType;
this._MethodName = null;
this._MethodSignature = null;
this._MethodBase = null;
this._URI = null;
this._Fault = null;
this._ID = null;
this._srvID = null;
this._callContext = null;
if (this._properties != null)
{
((IDictionary) this._properties).Clear();
}
}
[System.Security.SecurityCritical] // auto-generated
internal AsyncWorkItem(IMessage reqMsg, IMessageSink replySink, Context oldCtx, ServerIdentity srvID)
{
_reqMsg = reqMsg;
_replySink = replySink;
_oldCtx = oldCtx;
_callCtx = Thread.CurrentThread.GetMutableExecutionContext().LogicalCallContext;
_srvID = srvID;
}
[System.Security.SecurityCritical] // auto-generated
internal static Object ActivateWithMessage(
Type serverType, IMessage msg, ServerIdentity srvIdToBind,
out Exception e)
{
Object server = null;
e = null;
// Create a blank instance!
server = RemotingServices.AllocateUninitializedObject(serverType);
Object proxyForObject = null;
if (serverType.IsContextful)
{
if (msg is ConstructorCallMessage)
{
// If it is a strictly x-context activation then
// this pointer for the message is the TP that we
// returned to JIT in first phase of activation
proxyForObject = ((ConstructorCallMessage)msg).GetThisPtr();
}
else
{
// we are out of the app-domain, so wrap this object now
proxyForObject = null;
}
// This associates the proxy with the real object and sets
// up the proxy's native context, ID etc.
proxyForObject = RemotingServices.Wrap(
(ContextBoundObject)server,
proxyForObject,
false);
Contract.Assert(
RemotingServices.IsTransparentProxy(proxyForObject),
"Wrapped object should be a transparent proxy");
}
else
{
// Since this is an MBR type, something really bad
// happened if we are not in the default context
if (Thread.CurrentContext != Context.DefaultContext)
{
throw new RemotingException(
Environment.GetResourceString(
"Remoting_Activation_Failed"));
}
// Marshal-by-ref case we just return the object
proxyForObject = server;
}
// Create the dispatcher which will help run the CTOR
IMessageSink dispatcher = (IMessageSink)new StackBuilderSink(proxyForObject);
// This call runs the CTOR on the object
IMethodReturnMessage retMsg = (IMethodReturnMessage)
dispatcher.SyncProcessMessage(msg);
if (retMsg.Exception == null)
{
if (serverType.IsContextful)
{
// call wrap to finish the operation.
return RemotingServices.Wrap((ContextBoundObject)server);
}
else
{
return server;
}
}
else
{
e = retMsg.Exception;
return null;
}
}
private static void RegisterServerIdentity(ServerIdentity identity)
{
lock (uri_hash)
{
if (uri_hash.ContainsKey (identity.ObjectUri))
throw new RemotingException ("Uri already in use: " + identity.ObjectUri + ".");
uri_hash[identity.ObjectUri] = identity;
}
}
internal ServerIdentity StartupWellKnownObject(string asmName, string svrTypeName, string URI, WellKnownObjectMode mode, bool fReplace)
{
lock (s_wkoStartLock)
{
MarshalByRefObject obj2 = null;
ServerIdentity identity = null;
Type type = LoadType(svrTypeName, asmName);
if (!type.IsMarshalByRef)
{
throw new RemotingException(Environment.GetResourceString("Remoting_WellKnown_MustBeMBR", new object[] { svrTypeName }));
}
identity = (ServerIdentity)IdentityHolder.ResolveIdentity(URI);
if ((identity != null) && identity.IsRemoteDisconnected())
{
IdentityHolder.RemoveIdentity(URI);
identity = null;
}
if (identity == null)
{
s_fullTrust.Assert();
try
{
obj2 = (MarshalByRefObject)Activator.CreateInstance(type, true);
if (RemotingServices.IsClientProxy(obj2))
{
RedirectionProxy proxy = new RedirectionProxy(obj2, type)
{
ObjectMode = mode
};
RemotingServices.MarshalInternal(proxy, URI, type);
identity = (ServerIdentity)IdentityHolder.ResolveIdentity(URI);
identity.SetSingletonObjectMode();
}
else if (type.IsCOMObject && (mode == WellKnownObjectMode.Singleton))
{
ComRedirectionProxy proxy2 = new ComRedirectionProxy(obj2, type);
RemotingServices.MarshalInternal(proxy2, URI, type);
identity = (ServerIdentity)IdentityHolder.ResolveIdentity(URI);
identity.SetSingletonObjectMode();
}
else
{
if (RemotingServices.GetObjectUri(obj2) != null)
{
throw new RemotingException(string.Format(CultureInfo.CurrentCulture, Environment.GetResourceString("Remoting_WellKnown_CtorCantMarshal"), new object[] { URI }));
}
RemotingServices.MarshalInternal(obj2, URI, type);
identity = (ServerIdentity)IdentityHolder.ResolveIdentity(URI);
if (mode == WellKnownObjectMode.SingleCall)
{
identity.SetSingleCallObjectMode();
}
else
{
identity.SetSingletonObjectMode();
}
}
}
catch
{
throw;
}
finally
{
CodeAccessPermission.RevertAssert();
}
}
return(identity);
}
}
internal Type ResolveType()
{
Type newType = null;
if (this.srvID == null)
{
this.srvID = IdentityHolder.CasualResolveIdentity(this.uri) as ServerIdentity;
}
if (this.srvID != null)
{
Type lastCalledType = this.srvID.GetLastCalledType(this.typeName);
if (lastCalledType != null)
{
return lastCalledType;
}
int startIndex = 0;
if (string.CompareOrdinal(this.typeName, 0, "clr:", 0, 4) == 0)
{
startIndex = 4;
}
int index = this.typeName.IndexOf(',', startIndex);
if (index == -1)
{
index = this.typeName.Length;
}
lastCalledType = this.srvID.ServerType;
newType = ResolveTypeRelativeTo(this.typeName, startIndex, index - startIndex, lastCalledType);
}
if (newType == null)
{
newType = RemotingServices.InternalGetTypeFromQualifiedTypeName(this.typeName);
}
if (this.srvID != null)
{
this.srvID.SetLastCalledType(this.typeName, newType);
}
return newType;
}
} // CasualResolveReference
//
//
// This is typically called when we need to create/establish
// an identity for a serverObject.
internal static ServerIdentity FindOrCreateServerIdentity(
MarshalByRefObject obj, String objURI, int flags)
{
Message.DebugOut("Entered FindOrCreateServerIdentity \n");
ServerIdentity srvID = null;
bool bLock = false;
try
{
bool fServer;
srvID = (ServerIdentity) MarshalByRefObject.GetIdentity(obj, out fServer);
if (srvID == null)
{
// Create a new server identity and add it to the
// table. IdentityHolder will take care of races
Context serverCtx = null;
if (obj is ContextBoundObject)
{
serverCtx = Thread.CurrentContext;
}
else
{
serverCtx = DefaultContext;
}
BCLDebug.Assert(null != serverCtx, "null != serverCtx");
ServerIdentity serverID = new ServerIdentity(obj, serverCtx);
// Set the identity depending on whether we have the server or proxy
if(fServer)
{
srvID = obj.__RaceSetServerIdentity(serverID);
BCLDebug.Assert(srvID == MarshalByRefObject.GetIdentity(obj), "Bad ID state!" );
}
else
{
RealProxy rp = null;
rp = RemotingServices.GetRealProxy(obj);
BCLDebug.Assert(null != rp, "null != rp");
rp.IdentityObject = serverID;
srvID = (ServerIdentity) rp.IdentityObject;
}
Message.DebugOut("Created ServerIdentity \n");
}
// NOTE: for purely x-context cases we never execute this ...
// the server ID is not put in the ID table.
if ( IdOps.bStrongIdentity(flags) )
{
TableLock.AcquireWriterLock(INFINITE);
bLock = true;
// It is possible that we are marshaling out of this app-domain
// for the first time. We need to do two things
// (1) If there is no URI associated with the identity then go ahead
// and generate one.
// (2) Add the identity to the URI -> Identity map if not already present
// (For purely x-context cases we don't need the URI)
// (3) If the object ref is null, then this object hasn't been
// marshalled yet.
// (4) if id was created through SetObjectUriForMarshal, it would be
// in the ID table
if ((srvID.ObjURI == null) ||
(srvID.IsInIDTable() == false))
{
// we are marshalling a server object, so there should not be a
// a different identity at this location.
SetIdentity(srvID, objURI, DuplicateIdentityOption.Unique);
}
// If the object is marked as disconnect, mark it as connected
if(srvID.IsDisconnected())
srvID.SetFullyConnected();
}
}
finally
{
if (bLock)
{
TableLock.ReleaseWriterLock();
}
}
Message.DebugOut("Leaving FindOrCreateServerIdentity \n");
BCLDebug.Assert(null != srvID,"null != srvID");
return srvID;
}
internal static ServerIdentity FindOrCreateServerIdentity(MarshalByRefObject obj, string objURI, int flags)
{
ServerIdentity idObj = null;
bool flag;
idObj = (ServerIdentity) MarshalByRefObject.GetIdentity(obj, out flag);
if (idObj == null)
{
Context serverCtx = null;
if (obj is ContextBoundObject)
{
serverCtx = Thread.CurrentContext;
}
else
{
serverCtx = DefaultContext;
}
ServerIdentity id = new ServerIdentity(obj, serverCtx);
if (flag)
{
idObj = obj.__RaceSetServerIdentity(id);
}
else
{
RealProxy realProxy = null;
realProxy = RemotingServices.GetRealProxy(obj);
realProxy.IdentityObject = id;
idObj = (ServerIdentity) realProxy.IdentityObject;
}
}
if (IdOps.bStrongIdentity(flags))
{
ReaderWriterLock tableLock = TableLock;
bool flag2 = !tableLock.IsWriterLockHeld;
RuntimeHelpers.PrepareConstrainedRegions();
try
{
if (flag2)
{
tableLock.AcquireWriterLock(0x7fffffff);
}
if ((idObj.ObjURI == null) || !idObj.IsInIDTable())
{
SetIdentity(idObj, objURI, DuplicateIdentityOption.Unique);
}
if (idObj.IsDisconnected())
{
idObj.SetFullyConnected();
}
}
finally
{
if (flag2 && tableLock.IsWriterLockHeld)
{
tableLock.ReleaseWriterLock();
}
}
}
return idObj;
}
} // CasualResolveReference
//
//
// This is typically called when we need to create/establish
// an identity for a serverObject.
internal static ServerIdentity FindOrCreateServerIdentity(
MarshalByRefObject obj, String objURI, int flags)
{
Message.DebugOut("Entered FindOrCreateServerIdentity \n");
ServerIdentity srvID = null;
bool bLock = false;
try
{
bool fServer;
srvID = (ServerIdentity)MarshalByRefObject.GetIdentity(obj, out fServer);
if (srvID == null)
{
// Create a new server identity and add it to the
// table. IdentityHolder will take care of races
Context serverCtx = null;
if (obj is ContextBoundObject)
{
serverCtx = Thread.CurrentContext;
}
else
{
serverCtx = DefaultContext;
}
BCLDebug.Assert(null != serverCtx, "null != serverCtx");
ServerIdentity serverID = new ServerIdentity(obj, serverCtx);
// Set the identity depending on whether we have the server or proxy
if (fServer)
{
srvID = obj.__RaceSetServerIdentity(serverID);
BCLDebug.Assert(srvID == MarshalByRefObject.GetIdentity(obj), "Bad ID state!");
}
else
{
RealProxy rp = null;
rp = RemotingServices.GetRealProxy(obj);
BCLDebug.Assert(null != rp, "null != rp");
rp.IdentityObject = serverID;
srvID = (ServerIdentity)rp.IdentityObject;
}
Message.DebugOut("Created ServerIdentity \n");
}
// NOTE: for purely x-context cases we never execute this ...
// the server ID is not put in the ID table.
if (IdOps.bStrongIdentity(flags))
{
TableLock.AcquireWriterLock(INFINITE);
bLock = true;
// It is possible that we are marshaling out of this app-domain
// for the first time. We need to do two things
// (1) If there is no URI associated with the identity then go ahead
// and generate one.
// (2) Add the identity to the URI -> Identity map if not already present
// (For purely x-context cases we don't need the URI)
// (3) If the object ref is null, then this object hasn't been
// marshalled yet.
// (4) if id was created through SetObjectUriForMarshal, it would be
// in the ID table
if ((srvID.ObjURI == null) ||
(srvID.IsInIDTable() == false))
{
// we are marshalling a server object, so there should not be a
// a different identity at this location.
SetIdentity(srvID, objURI, DuplicateIdentityOption.Unique);
}
// If the object is marked as disconnect, mark it as connected
if (srvID.IsDisconnected())
{
srvID.SetFullyConnected();
}
}
}
finally
{
if (bLock)
{
TableLock.ReleaseWriterLock();
}
}
Message.DebugOut("Leaving FindOrCreateServerIdentity \n");
BCLDebug.Assert(null != srvID, "null != srvID");
return(srvID);
}
} // TransitionCall
// This constructor should be used for cross appdomain case.
internal TransitionCall(IntPtr targetCtxID, IntPtr privateData, int targetDomainID)
{
BCLDebug.Assert(targetCtxID != IntPtr.Zero, "bad target ctx for call back");
BCLDebug.Assert(targetDomainID != 0, "bad target ctx for call back");
_sourceCtxID = Thread.CurrentContext.InternalContextID;
_targetCtxID = targetCtxID;
_delegate = null;
_targetDomainID = targetDomainID;
_privateData = privateData;
// In the cross domain case, the client side just has a base Identity
// and the server domain has the Server identity. We fault in the latter
// when requested later.
// We are going to a context in another app domain
_srvID = null;
_ID = new Identity("TransitionCallURI", null);
// Create the data needed for the channel sink creation
CrossAppDomainData data =
new CrossAppDomainData(_targetCtxID,
_targetDomainID,
Identity.ProcessGuid);
String unUsed;
IMessageSink channelSink =
CrossAppDomainChannel.AppDomainChannel.CreateMessageSink(
null, //uri
data, //channelData
out unUsed);//out objURI
BCLDebug.Assert(channelSink != null, "X-domain transition failure");
_ID.RaceSetChannelSink(channelSink);
} // TransitionCall
IntPtr _privateData; // Used for DoCallbackInEE
// The _delegate should really be on an agile object otherwise
// the whole point of doing a callBack is moot. However, even if it
// is not, remoting and serialization together will ensure that
// everything happens as expected and there is no smuggling.
internal TransitionCall(
IntPtr targetCtxID,
CrossContextDelegate deleg)
{
BCLDebug.Assert(targetCtxID!=IntPtr.Zero, "bad target ctx for call back");
_sourceCtxID = Thread.CurrentContext.InternalContextID;
_targetCtxID = targetCtxID;
_delegate = deleg;
_targetDomainID = 0;
_privateData = IntPtr.Zero;
// We are going to another context in the same app domain
_srvID = new ServerIdentity(
null,
Thread.GetContextInternal(_targetCtxID));
_ID = _srvID;
_ID.RaceSetChannelSink(CrossContextChannel.MessageSink);
_srvID.RaceSetServerObjectChain(this);
//DBG Console.WriteLine("### TransitionCall ctor: " + Int32.Format(_sourceCtxID,"x") + ":" + Int32.Format(_targetCtxID,"x"));
} // TransitionCall
public static void SetObjectUriForMarshal(MarshalByRefObject obj, string uri)
{
Identity identity = null;
Identity identity2 = null;
bool flag;
identity = MarshalByRefObject.GetIdentity(obj, out flag);
identity2 = identity as ServerIdentity;
if ((identity != null) && (identity2 == null))
{
throw new RemotingException(Environment.GetResourceString("Remoting_SetObjectUriForMarshal__ObjectNeedsToBeLocal"));
}
if ((identity != null) && (identity.URI != null))
{
throw new RemotingException(Environment.GetResourceString("Remoting_SetObjectUriForMarshal__UriExists"));
}
if (identity == null)
{
Context serverCtx = null;
serverCtx = Thread.GetDomain().GetDefaultContext();
ServerIdentity id = new ServerIdentity(obj, serverCtx, uri);
if (obj.__RaceSetServerIdentity(id) != id)
{
throw new RemotingException(Environment.GetResourceString("Remoting_SetObjectUriForMarshal__UriExists"));
}
}
else
{
identity.SetOrCreateURI(uri, true);
}
}
internal static IEnvoyInfo CreateEnvoyInfo(ServerIdentity serverID)
{
IEnvoyInfo info = null;
if (null != serverID)
{
// Set the envoy sink chain
if (serverID.EnvoyChain == null)
{
serverID.RaceSetEnvoyChain(
serverID.ServerContext.CreateEnvoyChain(
serverID.TPOrObject));
}
// Create an envoy info object only if necessary
IMessageSink sink = serverID.EnvoyChain as EnvoyTerminatorSink;
if(null == sink)
{
// The chain consists of more than a terminator sink
// Go ahead and create an envoy info structure, otherwise
// a null is returned and we recreate the terminator sink
// on the other side, automatically.
info = new EnvoyInfo(serverID.EnvoyChain);
}
}
return info;
}
public static void SetObjectUriForMarshal( MarshalByRefObject obj, String uri)
{
// if obj is ever Marshal'd it should use this uri. If a uri has
// already been assigned to the object, it should throw.
Message.DebugOut("Entered SetObjectUriForMarshal \n");
Identity idObj = null;
Identity srvIdObj = null;
bool fServer;
idObj = MarshalByRefObject.GetIdentity(obj, out fServer);
srvIdObj = idObj as ServerIdentity;
// Ensure that if we have a transparent proxy then we are not given a remoting
// proxy. This routine should only be called for objects that
// live in this AppDomains.
if ((idObj != null) &&
(srvIdObj == null)) // <-- means idObj is not a ServerIdentity
{
throw new RemotingException(
Environment.GetResourceString(
"Remoting_SetObjectUriForMarshal__ObjectNeedsToBeLocal"));
}
if ((idObj != null) && (idObj.URI != null))
{
throw new RemotingException(
Environment.GetResourceString(
"Remoting_SetObjectUriForMarshal__UriExists"));
}
if (idObj == null)
{
// obj is not ContextBound
Contract.Assert(!(obj is ContextBoundObject), "ContextBoundObject's shouldn't get here.");
// Create a new server identity and add it to the
// table. IdentityHolder will take care of ----s
Context serverCtx = null;
serverCtx = Thread.GetDomain().GetDefaultContext();
Contract.Assert(null != serverCtx, "null != serverCtx");
ServerIdentity serverID = new ServerIdentity(obj, serverCtx, uri);
// set the identity
idObj = obj.__RaceSetServerIdentity(serverID);
Contract.Assert(idObj == MarshalByRefObject.GetIdentity(obj), "Bad ID state!" );
// If our serverID isn't used then someone else marshalled the object
// before we could set the uri.
if (idObj != serverID)
{
throw new RemotingException(
Environment.GetResourceString(
"Remoting_SetObjectUriForMarshal__UriExists"));
}
}
else
{
// This is the ContextBoundObject case
Contract.Assert(obj is ContextBoundObject, "Object should have been a ContextBoundObject.");
idObj.SetOrCreateURI(uri, true);
}
Message.DebugOut("Created ServerIdentity \n");
} // SetObjectUriForMarshal
// NOTE: This method is called multiple times as we reuse the
// message object. Make sure that you reset any fields that you
// add to the message object to the default values. This will
// ensure that the reused message object starts with the correct
// values.
internal void InitFields(MessageData msgData)
{
_frame = msgData.pFrame;
_delegateMD = msgData.pDelegateMD;
_methodDesc = msgData.pMethodDesc;
_last = -1;
_flags = msgData.iFlags;
_initDone = true;
_metaSigHolder = msgData.pSig;
_MethodName = null;
_MethodSignature = null;
_MethodBase = null;
_URI = null;
_Fault = null;
_ID = null;
_srvID = null;
_callContext = null;
if (_properties != null)
{
// A dictionary object already exists. This case occurs
// when we reuse the message object. Just remove all the
// entries from the dictionary object and reuse it.
((IDictionary)_properties).Clear();
}
}
internal ServerIdentity __RaceSetServerIdentity(ServerIdentity id)
{
if (__identity == null)
{
// For strictly MBR types, the TP field in the identity
// holds the real server
if (!id.IsContextBound)
{
id.RaceSetTransparentProxy(this);
}
Interlocked.CompareExchange(ref __identity, id, null);
}
return (ServerIdentity)__identity;
}
internal MethodCall(Object handlerObject, BinaryMethodCallMessage smuggledMsg)
{
if (handlerObject != null)
{
uri = handlerObject as String;
if (uri == null)
{
// This must be the tranparent proxy
MarshalByRefObject mbr = handlerObject as MarshalByRefObject;
if (mbr != null)
{
bool fServer;
srvID = MarshalByRefObject.GetIdentity(mbr, out fServer) as ServerIdentity;
uri = srvID.URI;
}
}
}
typeName = smuggledMsg.TypeName;
methodName = smuggledMsg.MethodName;
methodSignature = (Type[])smuggledMsg.MethodSignature;
args = smuggledMsg.Args;
callContext = smuggledMsg.LogicalCallContext;
ResolveMethod();
if (smuggledMsg.HasProperties)
smuggledMsg.PopulateMessageProperties(Properties);
}
[System.Security.SecurityCritical] // auto-generated
internal static ServerIdentity FindOrCreateServerIdentity(
MarshalByRefObject obj, String objURI, int flags)
{
Message.DebugOut("Entered FindOrCreateServerIdentity \n");
ServerIdentity srvID = null;
bool fServer;
srvID = (ServerIdentity) MarshalByRefObject.GetIdentity(obj, out fServer);
if (srvID == null)
{
// Create a new server identity and add it to the
// table. IdentityHolder will take care of ----s
Context serverCtx = null;
if (obj is ContextBoundObject)
{
serverCtx = Thread.CurrentContext;
}
else
{
serverCtx = DefaultContext;
}
Contract.Assert(null != serverCtx, "null != serverCtx");
ServerIdentity serverID = new ServerIdentity(obj, serverCtx);
// Set the identity depending on whether we have the server or proxy
if(fServer)
{
srvID = obj.__RaceSetServerIdentity(serverID);
Contract.Assert(srvID == MarshalByRefObject.GetIdentity(obj), "Bad ID state!" );
}
else
{
RealProxy rp = null;
rp = RemotingServices.GetRealProxy(obj);
Contract.Assert(null != rp, "null != rp");
rp.IdentityObject = serverID;
srvID = (ServerIdentity) rp.IdentityObject;
}
Message.DebugOut("Created ServerIdentity \n");
}
#if false
// Check that we are asked to create the identity for the same
// URI as the one already associated with the server object.
// It is an error to associate two URIs with the same server
// object
// GopalK: Try eliminating the test because it is also done by GetOrCreateIdentity
if ((null != objURI) && (null != srvID.ObjURI))
{
if (string.Compare(objURI, srvID.ObjURI, StringComparison.OrdinalIgnoreCase) == 0) // case-insensitive compare
{
Message.DebugOut("Trying to associate a URI with identity again .. throwing execption \n");
throw new RemotingException(
String.Format(
Environment.GetResourceString(
"Remoting_ResetURI"),
srvID.ObjURI, objURI));
}
}
#endif
// NOTE: for purely x-context cases we never execute this ...
// the server ID is not put in the ID table.
if ( IdOps.bStrongIdentity(flags) )
{
// We need to guarantee that finally is not interrupted so that the lock is released.
// TableLock has a long path without reliability contract. To avoid adding contract on
// the path, we will use ReaderWriterLock directly.
ReaderWriterLock rwlock = TableLock;
bool takeAndRelease = !rwlock.IsWriterLockHeld;
RuntimeHelpers.PrepareConstrainedRegions();
try
{
if (takeAndRelease)
rwlock.AcquireWriterLock(INFINITE);
// It is possible that we are marshaling out of this app-domain
// for the first time. We need to do two things
// (1) If there is no URI associated with the identity then go ahead
// and generate one.
// (2) Add the identity to the URI -> Identity map if not already present
// (For purely x-context cases we don't need the URI)
// (3) If the object ref is null, then this object hasn't been
// marshalled yet.
// (4) if id was created through SetObjectUriForMarshal, it would be
// in the ID table
if ((srvID.ObjURI == null) ||
(srvID.IsInIDTable() == false))
{
// we are marshalling a server object, so there should not be a
// a different identity at this location.
SetIdentity(srvID, objURI, DuplicateIdentityOption.Unique);
}
// If the object is marked as disconnect, mark it as connected
if(srvID.IsDisconnected())
srvID.SetFullyConnected();
}
finally
{
if (takeAndRelease && rwlock.IsWriterLockHeld)
{
rwlock.ReleaseWriterLock();
}
}
}
Message.DebugOut("Leaving FindOrCreateServerIdentity \n");
Contract.Assert(null != srvID,"null != srvID");
return srvID;
}
} // SetObjectData
//
// ResolveMethod
//
internal Type ResolveType()
{
// resolve type
Type t = null;
if (srvID == null)
srvID = IdentityHolder.CasualResolveIdentity(uri) as ServerIdentity;
if (srvID != null)
{
int startIndex = 0; // start of type name
// check to see if type name starts with "clr:"
if (String.CompareOrdinal(typeName, 0, "clr:", 0, 4) == 0)
{
// type starts just past "clr:"
startIndex = 4;
}
// find end of full type name
int index = typeName.IndexOf(',', startIndex);
if (index == -1)
index = typeName.Length;
Type serverType = srvID.ServerType;
t = Type.ResolveTypeRelativeTo(typeName, startIndex, index - startIndex, serverType);
}
if (t == null)
{
// fall back to Type.GetType() in case someone isn't using
// our convention for the TypeName
t = RemotingServices.InternalGetTypeFromQualifiedTypeName(typeName);
}
return t;
} // ResolveType
