private void ReturnCallContextToThread(Thread currentThread, IMessage retMsg, int msgFlags, LogicalCallContext currCtx)
 {
     if ((msgFlags == 0) && (retMsg != null))
     {
         IMethodReturnMessage message = retMsg as IMethodReturnMessage;
         if (message != null)
         {
             LogicalCallContext logicalCallContext = message.LogicalCallContext;
             if (logicalCallContext == null)
             {
                 currentThread.SetLogicalCallContext(currCtx);
             }
             else if (!(message is StackBasedReturnMessage))
             {
                 LogicalCallContext context2 = currentThread.SetLogicalCallContext(logicalCallContext);
                 if (context2 != logicalCallContext)
                 {
                     IPrincipal principal = context2.Principal;
                     if (principal != null)
                     {
                         logicalCallContext.Principal = principal;
                     }
                 }
             }
         }
     }
 }
Ejemplo n.º 2
0
 internal static LogicalCallContext SetLogicalCallContext(
     Thread currThread, LogicalCallContext callCtx)
 {
     return currThread.SetLogicalCallContext(callCtx);
 }
Ejemplo n.º 3
0
        void ReturnCallContextToThread(Thread currentThread, IMessage retMsg, int msgFlags)
        {
            if (msgFlags == Message.Sync)
            {
                if (retMsg == null)
                    return;

                IMethodReturnMessage mrm = retMsg as IMethodReturnMessage;
                if (mrm == null)
                    return;                            
                            
                LogicalCallContext retCtx = mrm.LogicalCallContext;
                if (retCtx == null)
                    return;
                
                if (!(mrm is StackBasedReturnMessage))
                {
                    LogicalCallContext oldCtx = currentThread.SetLogicalCallContext(retCtx);
                    if ((Object)oldCtx != (Object)retCtx)
                    {
                        // If the new call context does not match the old call context,
                        //   we must have gone remote. We need to keep the preserve
                        //   the principal from the original call context.
                        IPrincipal principal = oldCtx.Principal;
                        if (principal != null)
                            retCtx.Principal = principal;
                    }                    
                }
                //for other types (async/one-way etc) there is nothing to be 
                //done as we have just finished processing BeginInvoke or EndInvoke
            }
        }