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.Threading \ CompressedStack

SSCLI
  1. // ==++==
  2. //
  3. //
  4. // Copyright (c) 2006 Microsoft Corporation. All rights reserved.
  5. //
  6. // The use and distribution terms for this software are contained in the file
  7. // named license.txt, which can be found in the root of this distribution.
  8. // By using this software in any fashion, you are agreeing to be bound by the
  9. // terms of this license.
  10. //
  11. // You must not remove this notice, or any other, from this software.
  12. //
  13. //
  14. // ==--==
  15. /*=============================================================================
  16. **
  17. ** Class: CompressedStack
  18. **
  19. ** Purpose: Managed wrapper for the security stack compression implementation
  20. **
  21. =============================================================================*/
  23. namespace System.Threading
  24. {
  25.     using System.Security;
  26.     using System.Security.Permissions;
  27.     using System.Runtime.InteropServices;
  28.     using System.Runtime.CompilerServices;
  29.     using System.Runtime.ConstrainedExecution;
  30.     using System.Reflection;
  31.     using System.Collections;
  32.     using System.Threading;
  33.     using System.Runtime.Serialization;
  34.    
  35.    
  36.     internal struct CompressedStackSwitcher : IDisposable
  37.     {
  38.         internal CompressedStack curr_CS;
  39.         internal CompressedStack prev_CS;
  40.         internal IntPtr prev_ADStack;
  41.        
  42.        
  43.         public override bool Equals(object obj)
  44.         {
  45.             if (obj == null || !(obj is CompressedStackSwitcher))
  46.                 return false;
  47.             CompressedStackSwitcher sw = (CompressedStackSwitcher)obj;
  48.             return (this.curr_CS == sw.curr_CS && this.prev_CS == sw.prev_CS && this.prev_ADStack == sw.prev_ADStack);
  49.         }
  50.        
  51.         public override int GetHashCode()
  52.         {
  53.             return ToString().GetHashCode();
  54.         }
  55.        
  56.         public static bool operator ==(CompressedStackSwitcher c1, CompressedStackSwitcher c2)
  57.         {
  58.             return c1.Equals(c2);
  59.         }
  60.        
  61.         public static bool operator !=(CompressedStackSwitcher c1, CompressedStackSwitcher c2)
  62.         {
  63.             return !c1.Equals(c2);
  64.         }
  65.         /// <internalonly/>
  66.         void IDisposable.Dispose()
  67.         {
  68.             Undo();
  69.         }
  70.        
  71.         [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
  72.         internal bool UndoNoThrow()
  73.         {
  74.             try {
  75.                 Undo();
  76.             }
  77.             catch {
  78.                 return false;
  79.             }
  80.             return true;
  81.         }
  82.        
  83.        
  84.         [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
  85.         public void Undo()
  86.         {
  87.             if (curr_CS == null && prev_CS == null)
  88.                 return;
  89.             if (prev_ADStack != (IntPtr)0)
  90.                 CompressedStack.RestoreAppDomainStack(prev_ADStack);
  91.             CompressedStack.SetCompressedStackThread(prev_CS);
  92.            
  93.             prev_CS = null;
  94.             curr_CS = null;
  95.             prev_ADStack = (IntPtr)0;
  96.         }
  97.     }
  98.    
  99.     internal class SafeCompressedStackHandle : SafeHandle
  100.     {
  101.         public SafeCompressedStackHandle() : base(IntPtr.Zero, true)
  102.         {
  103.         }
  104.        
  105.         public override bool IsInvalid {
  106.             get { return handle == IntPtr.Zero; }
  107.         }
  108.        
  109.         protected override bool ReleaseHandle()
  110.         {
  111.             CompressedStack.DestroyDelayedCompressedStack(handle);
  112.             handle = IntPtr.Zero;
  113.             return true;
  114.         }
  115.     }
  116.    
  117.    
  118.    
  119.     [Serializable()]
  120.     public sealed class CompressedStack : ISerializable
  121.     {
  122.        
  123.         private PermissionListSet m_pls;
  124.         private SafeCompressedStackHandle m_csHandle;
  125.        
  126.        
  127.         internal PermissionListSet PLS {
  128.             get { return m_pls; }
  129.         }
  130.        
  131.         internal CompressedStack(SafeCompressedStackHandle csHandle)
  132.         {
  133.             m_csHandle = csHandle;
  134.         }
  135.        
  136.         private CompressedStack(SafeCompressedStackHandle csHandle, PermissionListSet pls)
  137.         {
  138.             this.m_csHandle = csHandle;
  139.             this.m_pls = pls;
  140.         }
  141.        
  142.         [SecurityPermissionAttribute(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.SerializationFormatter)]
  143.         public void GetObjectData(SerializationInfo info, StreamingContext context)
  144.         {
  145.             if (info == null)
  146.                 throw new ArgumentNullException("info");
  147.             CompleteConstruction(null);
  148.             info.AddValue("PLS", this.m_pls);
  149.         }
  150.        
  151.         private CompressedStack(SerializationInfo info, StreamingContext context)
  152.         {
  153.             this.m_pls = (PermissionListSet)info.GetValue("PLS", typeof(PermissionListSet));
  154.         }
  155.        
  156.         internal SafeCompressedStackHandle CompressedStackHandle {
  157.             [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
  158.             get { return m_csHandle; }
  159.         }
  160.        
  161.         [StrongNameIdentityPermissionAttribute(SecurityAction.LinkDemand, PublicKey = "0x00000000000000000400000000000000"), SecurityPermissionAttribute(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.UnmanagedCode)]
  162.         public static CompressedStack GetCompressedStack()
  163.         {
  164.             // This is a Capture()
  165.             StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
  166.             return CompressedStack.GetCompressedStack(ref stackMark);
  167.         }
  168.        
  169.         static internal CompressedStack GetCompressedStack(ref StackCrawlMark stackMark)
  170.         {
  171.             CompressedStack cs;
  172.             CompressedStack innerCS = null;
  173.             if (CodeAccessSecurityEngine.QuickCheckForAllDemands()) {
  174.                 cs = new CompressedStack(null);
  175.             }
  176.             else if (CodeAccessSecurityEngine.AllDomainsHomogeneousWithNoStackModifiers()) {
  177.                 cs = new CompressedStack(null);
  178.                 cs.m_pls = PermissionListSet.CreateCompressedState_HG();
  179.             }
  180.             else {
  181.                 // regular stackwalking case
  182.                 cs = new CompressedStack(GetDelayedCompressedStack(ref stackMark));
  183.                 if (cs.CompressedStackHandle != null && IsImmediateCompletionCandidate(cs.CompressedStackHandle, out innerCS)) {
  184.                     cs.CompleteConstruction(innerCS);
  185.                     DestroyDCSList(cs.CompressedStackHandle);
  186.                 }
  187.             }
  188.             return cs;
  189.         }
  190.        
  191.         public static CompressedStack Capture()
  192.         {
  193.             StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
  194.             return GetCompressedStack(ref stackMark);
  195.         }
  196.        
  197.         [SecurityPermissionAttribute(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.Infrastructure), DynamicSecurityMethodAttribute()]
  198.         public static void Run(CompressedStack compressedStack, ContextCallback callback, object state)
  199.         {
  200.            
  201.             if (compressedStack == null) {
  202.                 throw new ArgumentException(Environment.GetResourceString("Arg_NamedParamNull"), "compressedStack");
  203.             }
  204.             if (cleanupCode == null) {
  205.                 tryCode = new RuntimeHelpers.TryCode(runTryCode);
  206.                 cleanupCode = new RuntimeHelpers.CleanupCode(runFinallyCode);
  207.             }
  208.            
  209.             CompressedStackRunData runData = new CompressedStackRunData(compressedStack, callback, state);
  210.             RuntimeHelpers.ExecuteCodeWithGuaranteedCleanup(tryCode, cleanupCode, runData);
  211.         }
  212.        
  213.         internal class CompressedStackRunData
  214.         {
  215.             internal CompressedStack cs;
  216.             internal ContextCallback callBack;
  217.             internal object state;
  218.             internal CompressedStackSwitcher cssw;
  219.             internal CompressedStackRunData(CompressedStack cs, ContextCallback cb, object state)
  220.             {
  221.                 this.cs = cs;
  222.                 this.callBack = cb;
  223.                 this.state = state;
  224.                 this.cssw = new CompressedStackSwitcher();
  225.             }
  226.         }
  227.         static internal void runTryCode(object userData)
  228.         {
  229.             CompressedStackRunData rData = (CompressedStackRunData)userData;
  230.             rData.cssw = SetCompressedStack(rData.cs, GetCompressedStackThread());
  231.             rData.callBack(rData.state);
  232.            
  233.         }
  234.        
  235.         [PrePrepareMethod()]
  236.         static internal void runFinallyCode(object userData, bool exceptionThrown)
  237.         {
  238.             CompressedStackRunData rData = (CompressedStackRunData)userData;
  239.             rData.cssw.Undo();
  240.         }
  241.        
  242.         static internal RuntimeHelpers.TryCode tryCode;
  243.         static internal RuntimeHelpers.CleanupCode cleanupCode;
  244.        
  245.        
  246.         static internal CompressedStackSwitcher SetCompressedStack(CompressedStack cs, CompressedStack prevCS)
  247.         {
  248.             CompressedStackSwitcher cssw = new CompressedStackSwitcher();
  249.             RuntimeHelpers.PrepareConstrainedRegions();
  250.             try {
  251.                 // Order is important in this block.
  252.                 // Also, we dont want any THreadAborts happening when we try to set it
  253.                 RuntimeHelpers.PrepareConstrainedRegions();
  254.                 try {
  255.                     // Empty try block to ensure no ThreadAborts in the finally block
  256.                 }
  257.                 finally {
  258.                     // SetCompressedStackThread can throw - only if it suceeds we shd update the switcher and overrides
  259.                     SetCompressedStackThread(cs);
  260.                     cssw.prev_CS = prevCS;
  261.                     cssw.curr_CS = cs;
  262.                     cssw.prev_ADStack = SetAppDomainStack(cs);
  263.                 }
  264.             }
  265.             catch {
  266.                 cssw.UndoNoThrow();
  267.                 throw;
  268.                 // throw the original exception
  269.             }
  270.             return cssw;
  271.         }
  272.        
  273.        
  274.         [ComVisible(false)]
  275.         public CompressedStack CreateCopy()
  276.         {
  277.             return new CompressedStack(this.m_csHandle, this.m_pls);
  278.         }
  279.        
  280.         [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
  281.         static internal IntPtr SetAppDomainStack(CompressedStack cs)
  282.         {
  283.             //Update the AD Stack on the thread and return the previous AD Stack
  284.             return Thread.CurrentThread.SetAppDomainStack((cs == null ? null : cs.CompressedStackHandle));
  285.         }
  286.        
  287.        
  288.         [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
  289.         static internal void RestoreAppDomainStack(IntPtr appDomainStack)
  290.         {
  291.             Thread.CurrentThread.RestoreAppDomainStack(appDomainStack);
  292.             //Restore the previous AD Stack
  293.         }
  294.         static internal CompressedStack GetCompressedStackThread()
  295.         {
  296.             ExecutionContext ec = Thread.CurrentThread.GetExecutionContextNoCreate();
  297.             if (ec != null && ec.SecurityContext != null)
  298.                 return ec.SecurityContext.CompressedStack;
  299.             return null;
  300.         }
  301.         [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
  302.         static internal void SetCompressedStackThread(CompressedStack cs)
  303.         {
  304.             ExecutionContext ec = Thread.CurrentThread.ExecutionContext;
  305.             if (ec.SecurityContext != null)
  306.                 ec.SecurityContext.CompressedStack = cs;
  307.             else if (cs != null) {
  308.                 SecurityContext sc = new SecurityContext();
  309.                 sc.CompressedStack = cs;
  310.                 ec.SecurityContext = sc;
  311.             }
  312.         }
  313.        
  314.        
  315.         internal bool CheckDemand(CodeAccessPermission demand, PermissionToken permToken, RuntimeMethodHandle rmh)
  316.         {
  317.             CompleteConstruction(null);
  318.            
  319.             if (PLS == null)
  320.                 return SecurityRuntime.StackHalt;
  321.             else
  322.                 return PLS.CheckDemand(demand, permToken, rmh);
  323.            
  324.         }
  325.        
  326.         internal bool CheckSetDemand(PermissionSet pset, RuntimeMethodHandle rmh)
  327.         {
  328.             CompleteConstruction(null);
  329.            
  330.             if (PLS == null)
  331.                 return SecurityRuntime.StackHalt;
  332.             else
  333.                 return PLS.CheckSetDemand(pset, rmh);
  334.         }
  335.        
  336.        
  337.         internal void GetZoneAndOrigin(ArrayList zoneList, ArrayList originList, PermissionToken zoneToken, PermissionToken originToken)
  338.         {
  339.            
  340.            
  341.             CompleteConstruction(null);
  342.             if (PLS != null)
  343.                 PLS.GetZoneAndOrigin(zoneList, originList, zoneToken, originToken);
  344.             return;
  345.         }
  346.        
  347.         internal void CompleteConstruction(CompressedStack innerCS)
  348.         {
  349.             if (PLS != null)
  350.                 return;
  351.             PermissionListSet pls = PermissionListSet.CreateCompressedState(this, innerCS);
  352.             lock (this) {
  353.                 if (PLS == null)
  354.                     m_pls = pls;
  355.             }
  356.         }
  357.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  358.         static internal extern SafeCompressedStackHandle GetDelayedCompressedStack(ref StackCrawlMark stackMark);
  359.        
  360.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  361.         static internal extern void DestroyDelayedCompressedStack(IntPtr unmanagedCompressedStack);
  362.        
  363.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  364.         static internal extern void DestroyDCSList(SafeCompressedStackHandle compressedStack);
  365.        
  366.        
  367.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  368.         static internal extern int GetDCSCount(SafeCompressedStackHandle compressedStack);
  369.        
  370.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  371.         static internal extern bool IsImmediateCompletionCandidate(SafeCompressedStackHandle compressedStack, out CompressedStack innerCS);
  372.        
  373.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  374.         static internal extern DomainCompressedStack GetDomainCompressedStack(SafeCompressedStackHandle compressedStack, int index);
  375.        
  376.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  377.         static internal extern void GetHomogeneousPLS(PermissionListSet hgPLS);
  378.        
  379.        
  380.     }
  381.    
  382.     //**********************************************************
  383.     // New Implementation of CompressedStack creation/demand eval - NewCompressedStack/DomainCompressedStack
  384.     //**********************************************************
  385.     [Serializable()]
  386.     internal sealed class DomainCompressedStack
  387.     {
  388.         // Managed equivalent of DomainCompressedStack - used to perform demand evaluation
  389.         private PermissionListSet m_pls;
  390.         // Did we terminate construction on this DCS and therefore, should we terminate construction on the rest of the CS?
  391.         private bool m_bHaltConstruction;
  392.        
  393.        
  394.         // CompresedStack interacts with this class purely through the three properties marked internal
  395.         // Zone, Origin, AGRList.
  396.         internal PermissionListSet PLS {
  397.             get { return m_pls; }
  398.         }
  399.        
  400.         internal bool ConstructionHalted {
  401.             get { return m_bHaltConstruction; }
  402.         }
  403.        
  404.        
  405.        
  406.         // Called from the VM only.
  407.         private static DomainCompressedStack CreateManagedObject(IntPtr unmanagedDCS)
  408.         {
  409.             DomainCompressedStack newDCS = new DomainCompressedStack();
  410.             newDCS.m_pls = PermissionListSet.CreateCompressedState(unmanagedDCS, out newDCS.m_bHaltConstruction);
  411.             // return the created object
  412.             return newDCS;
  413.         }
  414.        
  415.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  416.         static internal extern int GetDescCount(IntPtr dcs);
  417.        
  418.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  419.         static internal extern void GetDomainPermissionSets(IntPtr dcs, out PermissionSet granted, out PermissionSet refused);
  420.        
  421.         // returns true if the descriptor is a FrameSecurityDescriptor
  422.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  423.         static internal extern bool GetDescriptorInfo(IntPtr dcs, int index, out PermissionSet granted, out PermissionSet refused, out Assembly assembly, out FrameSecurityDescriptor fsd);
  424.        
  425.         [MethodImplAttribute(MethodImplOptions.InternalCall)]
  426.         static internal extern bool IgnoreDomain(IntPtr dcs);
  427.     }
  428.    
  429. }

Developer Fusion