[System.Security.SecurityCritical] // auto-generated
private void Terminate(PermissionSetTriple currentTriple, PermissionListSet pls)
{
#if FEATURE_COMPRESSEDSTACK
this.UpdateZoneAndOrigin(pls);
#endif // FEATURE_COMPRESSEDSTACK
this.UpdatePermissions(currentTriple, pls);
this.UpdateTripleListAndCreateNewTriple(currentTriple, null);
}
[System.Security.SecurityCritical] // auto-generated
internal void UpdateDomainPLS (PermissionSet grantSet, PermissionSet deniedSet) {
Contract.Assert(m_permSetTriples == null, "m_permSetTriples != null");
if (m_firstPermSetTriple == null)
m_firstPermSetTriple = new PermissionSetTriple();
// update the grant and denied sets
m_firstPermSetTriple.UpdateGrant(grantSet);
m_firstPermSetTriple.UpdateRefused(deniedSet);
}
private void EnsureTriplesListCreated()
{
if (m_permSetTriples == null)
{
m_permSetTriples = new ArrayList();
if (m_firstPermSetTriple != null)
{
m_permSetTriples.Add(m_firstPermSetTriple);
m_firstPermSetTriple = null;
}
}
}
[System.Security.SecurityCritical] // auto-generated
internal bool Update(PermissionSetTriple psTriple, out PermissionSetTriple retTriple)
{
retTriple = null;
retTriple = UpdateAssert(psTriple.AssertSet);
// Special case: unrestricted assert. Note: dcs.Assert.IsUnrestricted => dcs.Grant.IsUnrestricted
if (psTriple.AssertSet != null && psTriple.AssertSet.IsUnrestricted())
{
return true; // stop construction
}
UpdateGrant(psTriple.GrantSet);
UpdateRefused(psTriple.RefusedSet);
return false;
}
private void UpdateTripleListAndCreateNewTriple(PermissionSetTriple currentTriple, ArrayList tripleList)
{
if (!currentTriple.IsEmpty())
{
if (m_firstPermSetTriple == null && m_permSetTriples == null)
{
m_firstPermSetTriple = new PermissionSetTriple(currentTriple);
}
else
{
EnsureTriplesListCreated();
m_permSetTriples.Add(new PermissionSetTriple(currentTriple));
}
currentTriple.Reset();
}
if (tripleList != null)
{
EnsureTriplesListCreated();
m_permSetTriples.AddRange(tripleList);
}
}
[System.Security.SecurityCritical] // auto-generated
private bool UpdatePermissions(PermissionSetTriple currentTriple, PermissionListSet pls)
{
if (pls != null)
{
if (pls.m_permSetTriples != null)
{
// DCS has an AGR List. So we need to add the AGR List
UpdateTripleListAndCreateNewTriple(currentTriple, pls.m_permSetTriples);
}
else
{
// Common case: One AGR set
PermissionSetTriple tmp_psTriple = pls.m_firstPermSetTriple;
PermissionSetTriple retTriple;
// First try and update currentTriple. Return value indicates if we can stop construction
if (currentTriple.Update(tmp_psTriple, out retTriple))
{
return(true);
}
// If we got a non-null retTriple, what it means is that compression failed,
// and we now have 2 triples to deal with: retTriple and currentTriple.
// retTriple has to be appended first. then currentTriple.
if (retTriple != null)
{
EnsureTriplesListCreated();
// we just created a new triple...add the previous one (returned) to the list
m_permSetTriples.Add(retTriple);
}
}
}
else
{
// pls can be null only outside the loop in CreateCompressedState
UpdateTripleListAndCreateNewTriple(currentTriple, null);
}
return(false);
}
internal static PermissionListSet CreateCompressedState(CompressedStack cs, CompressedStack innerCS)
{
bool constructionHalted = false;
if (cs.CompressedStackHandle == null)
{
return(null);
}
PermissionListSet set = new PermissionListSet();
PermissionSetTriple currentTriple = new PermissionSetTriple();
for (int i = CompressedStack.GetDCSCount(cs.CompressedStackHandle) - 1; (i >= 0) && !constructionHalted; i--)
{
DomainCompressedStack domainCompressedStack = CompressedStack.GetDomainCompressedStack(cs.CompressedStackHandle, i);
if (domainCompressedStack != null)
{
if (domainCompressedStack.PLS == null)
{
throw new SecurityException(string.Format(CultureInfo.InvariantCulture, Environment.GetResourceString("Security_Generic"), new object[0]));
}
set.UpdateZoneAndOrigin(domainCompressedStack.PLS);
set.Update(currentTriple, domainCompressedStack.PLS);
constructionHalted = domainCompressedStack.ConstructionHalted;
}
}
if (!constructionHalted)
{
PermissionListSet pls = null;
if (innerCS != null)
{
innerCS.CompleteConstruction(null);
pls = innerCS.PLS;
}
set.Terminate(currentTriple, pls);
return(set);
}
set.Terminate(currentTriple);
return(set);
}
private void UpdateTripleListAndCreateNewTriple(PermissionSetTriple currentTriple, ArrayList tripleList)
{
if (!currentTriple.IsEmpty())
{
if (this.m_firstPermSetTriple == null && this.m_permSetTriples == null)
{
this.m_firstPermSetTriple = new PermissionSetTriple(currentTriple);
}
else
{
this.EnsureTriplesListCreated();
this.m_permSetTriples.Add((object)new PermissionSetTriple(currentTriple));
}
currentTriple.Reset();
}
if (tripleList == null)
{
return;
}
this.EnsureTriplesListCreated();
this.m_permSetTriples.AddRange((ICollection)tripleList);
}
[System.Security.SecurityCritical] // auto-generated
static internal PermissionListSet CreateCompressedState(IntPtr unmanagedDCS, out bool bHaltConstruction)
{
PermissionListSet pls = new PermissionListSet();
PermissionSetTriple currentTriple = new PermissionSetTriple();
PermissionSet tmp_g, tmp_r;
// Construct the descriptor list
int descCount = DomainCompressedStack.GetDescCount(unmanagedDCS);
bHaltConstruction = false;
for (int i = 0; (i < descCount && !bHaltConstruction); i++)
{
FrameSecurityDescriptor fsd;
Assembly assembly;
if (DomainCompressedStack.GetDescriptorInfo(unmanagedDCS, i, out tmp_g, out tmp_r, out assembly, out fsd))
{
// Got an FSD
bHaltConstruction = pls.Update(currentTriple, fsd);
}
else
{
pls.Update(currentTriple, tmp_g, tmp_r);
}
}
if (!bHaltConstruction)
{
// domain
if (!DomainCompressedStack.IgnoreDomain(unmanagedDCS))
{
DomainCompressedStack.GetDomainPermissionSets(unmanagedDCS, out tmp_g, out tmp_r);
pls.Update(currentTriple, tmp_g, tmp_r);
}
}
pls.Terminate(currentTriple);
// return the created object
return(pls);
}
[System.Security.SecurityCritical] // auto-generated
static internal PermissionListSet CreateCompressedState(IntPtr unmanagedDCS, out bool bHaltConstruction)
{
PermissionListSet pls = new PermissionListSet();
PermissionSetTriple currentTriple = new PermissionSetTriple();
PermissionSet tmp_g, tmp_r;
// Construct the descriptor list
int descCount = DomainCompressedStack.GetDescCount(unmanagedDCS);
bHaltConstruction = false;
for(int i=0; (i < descCount && !bHaltConstruction); i++)
{
FrameSecurityDescriptor fsd;
Assembly assembly;
if (DomainCompressedStack.GetDescriptorInfo(unmanagedDCS, i, out tmp_g, out tmp_r, out assembly, out fsd))
{
// Got an FSD
bHaltConstruction = pls.Update(currentTriple, fsd);
}
else
{
pls.Update(currentTriple, tmp_g, tmp_r);
}
}
if (!bHaltConstruction)
{
// domain
if (!DomainCompressedStack.IgnoreDomain(unmanagedDCS))
{
DomainCompressedStack.GetDomainPermissionSets(unmanagedDCS, out tmp_g, out tmp_r);
pls.Update(currentTriple, tmp_g, tmp_r);
}
}
pls.Terminate(currentTriple);
// return the created object
return pls;
}
private void UpdateTripleListAndCreateNewTriple(PermissionSetTriple currentTriple, ArrayList tripleList)
{
if (!currentTriple.IsEmpty())
{
if (m_firstPermSetTriple == null && m_permSetTriples == null)
{
m_firstPermSetTriple = new PermissionSetTriple(currentTriple);
}
else
{
EnsureTriplesListCreated();
m_permSetTriples.Add(new PermissionSetTriple(currentTriple));
}
currentTriple.Reset();
}
if (tripleList != null)
{
EnsureTriplesListCreated();
m_permSetTriples.AddRange(tripleList);
}
}
[System.Security.SecurityCritical] // auto-generated
private void Update(PermissionSet in_g)
{
if (m_firstPermSetTriple == null)
m_firstPermSetTriple = new PermissionSetTriple();
Update(m_firstPermSetTriple, in_g, null);
}
[System.Security.SecurityCritical] // auto-generated
private bool Update2(PermissionSetTriple currentTriple, FrameSecurityDescriptor fsd, bool fDeclarative)
{
// Deny
PermissionSet deniedPset = fsd.GetDenials(fDeclarative);
if (deniedPset != null)
{
currentTriple.UpdateRefused(deniedPset);
}
// permit only
PermissionSet permitOnlyPset = fsd.GetPermitOnly(fDeclarative);
if (permitOnlyPset != null)
{
currentTriple.UpdateGrant(permitOnlyPset);
}
// Assert all possible
if (fsd.GetAssertAllPossible())
{
// If we have no grant set, it means that the only assembly we've seen on the stack so
// far is mscorlib. Since mscorlib will always be fully trusted, the grant set of the
// compressed stack is also FullTrust.
if (currentTriple.GrantSet == null)
currentTriple.GrantSet = PermissionSet.s_fullTrust;
return true; // halt the construction
}
// Assert
PermissionSet assertPset = fsd.GetAssertions(fDeclarative);
if (assertPset != null)
{
if (assertPset.IsUnrestricted())
{
// If we have no grant set, it means that the only assembly we've seen on the stack so
// far is mscorlib. Since mscorlib will always be fully trusted, the grant set of the
// compressed stack is also FullTrust.
if (currentTriple.GrantSet == null)
currentTriple.GrantSet = PermissionSet.s_fullTrust;
return true; // halt the construction
}
PermissionSetTriple retTriple = currentTriple.UpdateAssert(assertPset);
if (retTriple != null)
{
EnsureTriplesListCreated();
m_permSetTriples.Add(retTriple);
}
}
return false;
}
internal PermissionSetTriple(PermissionSetTriple triple)
{
this.AssertSet = triple.AssertSet;
this.GrantSet = triple.GrantSet;
this.RefusedSet = triple.RefusedSet;
}
private bool Update(PermissionSetTriple currentTriple, PermissionListSet pls)
{
return(this.UpdatePermissions(currentTriple, pls));
}
private bool Update2(PermissionSetTriple currentTriple, FrameSecurityDescriptorWithResolver fsdWithResolver)
{
System.Reflection.Emit.DynamicResolver resolver = fsdWithResolver.Resolver;
CompressedStack dynamicCompressedStack = resolver.GetSecurityContext();
dynamicCompressedStack.CompleteConstruction(null);
return this.Update(currentTriple, dynamicCompressedStack.PLS);
}
private void Update(PermissionSet in_g)
{
if (this.m_firstPermSetTriple == null)
{
this.m_firstPermSetTriple = new PermissionSetTriple();
}
this.Update(this.m_firstPermSetTriple, in_g, null);
}
internal PermissionSetTriple UpdateAssert(PermissionSet in_a)
{
PermissionSetTriple triple = null;
if (in_a != null)
{
PermissionSet set;
bool flag;
if (in_a.IsSubsetOf(this.AssertSet))
{
return null;
}
if (this.GrantSet != null)
{
set = in_a.Intersect(this.GrantSet);
}
else
{
this.GrantSet = new PermissionSet(true);
set = in_a.Copy();
}
set = PermissionSet.RemoveRefusedPermissionSet(set, this.RefusedSet, out flag);
if (!flag)
{
flag = PermissionSet.IsIntersectingAssertedPermissions(set, this.AssertSet);
}
if (flag)
{
triple = new PermissionSetTriple(this);
this.Reset();
this.GrantSet = triple.GrantSet.Copy();
}
if (this.AssertSet == null)
{
this.AssertSet = set;
return triple;
}
this.AssertSet.InplaceUnion(set);
}
return triple;
}
internal bool Update(PermissionSetTriple psTriple, out PermissionSetTriple retTriple)
{
retTriple = null;
if ((psTriple.AssertSet != null) && psTriple.AssertSet.IsUnrestricted())
{
return true;
}
retTriple = this.UpdateAssert(psTriple.AssertSet);
this.UpdateGrant(psTriple.GrantSet);
this.UpdateRefused(psTriple.RefusedSet);
return false;
}
private bool UpdatePermissions(PermissionSetTriple currentTriple, PermissionListSet pls)
{
if (pls != null)
{
if (pls.m_permSetTriples != null)
{
this.UpdateTripleListAndCreateNewTriple(currentTriple, pls.m_permSetTriples);
}
else
{
PermissionSetTriple triple2;
PermissionSetTriple firstPermSetTriple = pls.m_firstPermSetTriple;
if (currentTriple.Update(firstPermSetTriple, out triple2))
{
return true;
}
if (triple2 != null)
{
this.EnsureTriplesListCreated();
this.m_permSetTriples.Add(triple2);
}
}
}
else
{
this.UpdateTripleListAndCreateNewTriple(currentTriple, null);
}
return false;
}
internal void UpdateDomainPLS(PermissionSet grantSet, PermissionSet deniedSet)
{
if (this.m_firstPermSetTriple == null)
{
this.m_firstPermSetTriple = new PermissionSetTriple();
}
this.m_firstPermSetTriple.UpdateGrant(grantSet);
this.m_firstPermSetTriple.UpdateRefused(deniedSet);
}
private bool Update2(PermissionSetTriple currentTriple, FrameSecurityDescriptor fsd, bool fDeclarative)
{
PermissionSet denials = fsd.GetDenials(fDeclarative);
if (denials != null)
{
currentTriple.UpdateRefused(denials);
}
PermissionSet permitOnly = fsd.GetPermitOnly(fDeclarative);
if (permitOnly != null)
{
currentTriple.UpdateGrant(permitOnly);
}
if (fsd.GetAssertAllPossible())
{
if (currentTriple.GrantSet == null)
{
currentTriple.GrantSet = PermissionSet.s_fullTrust;
}
return true;
}
PermissionSet assertions = fsd.GetAssertions(fDeclarative);
if (assertions != null)
{
if (assertions.IsUnrestricted())
{
if (currentTriple.GrantSet == null)
{
currentTriple.GrantSet = PermissionSet.s_fullTrust;
}
return true;
}
PermissionSetTriple triple = currentTriple.UpdateAssert(assertions);
if (triple != null)
{
this.EnsureTriplesListCreated();
this.m_permSetTriples.Add(triple);
}
}
return false;
}
private void Update(PermissionSetTriple currentTriple, PermissionSet in_g, PermissionSet in_r)
{
ZoneIdentityPermission permission;
UrlIdentityPermission permission2;
currentTriple.UpdateGrant(in_g, out permission, out permission2);
currentTriple.UpdateRefused(in_r);
this.AppendZoneOrigin(permission, permission2);
}
private bool Update(PermissionSetTriple currentTriple, PermissionListSet pls)
{
this.UpdateZoneAndOrigin(pls);
return this.UpdatePermissions(currentTriple, pls);
}
[System.Security.SecurityCritical] // auto-generated
private bool Update(PermissionSetTriple currentTriple, FrameSecurityDescriptor fsd)
{
#if FEATURE_COMPRESSEDSTACK
FrameSecurityDescriptorWithResolver fsdWithResolver = fsd as FrameSecurityDescriptorWithResolver;
if (fsdWithResolver != null)
{
return Update2(currentTriple, fsdWithResolver);
}
#endif // FEATURE_COMPRESSEDSTACK
// check imperative
bool fHalt = Update2(currentTriple, fsd, false);
if (!fHalt)
{
// then declarative
fHalt = Update2(currentTriple, fsd, true);
}
return fHalt;
}
[System.Security.SecurityCritical] // auto-generated
private bool Update2(PermissionSetTriple currentTriple, FrameSecurityDescriptor fsd, bool fDeclarative)
{
// Deny
PermissionSet deniedPset = fsd.GetDenials(fDeclarative);
if (deniedPset != null)
{
currentTriple.UpdateRefused(deniedPset);
}
// permit only
PermissionSet permitOnlyPset = fsd.GetPermitOnly(fDeclarative);
if (permitOnlyPset != null)
{
currentTriple.UpdateGrant(permitOnlyPset);
}
// Assert all possible
if (fsd.GetAssertAllPossible())
{
// If we have no grant set, it means that the only assembly we've seen on the stack so
// far is mscorlib. Since mscorlib will always be fully trusted, the grant set of the
// compressed stack is also FullTrust.
if (currentTriple.GrantSet == null)
{
currentTriple.GrantSet = PermissionSet.s_fullTrust;
}
UpdateTripleListAndCreateNewTriple(currentTriple, m_permSetTriples);
currentTriple.GrantSet = PermissionSet.s_fullTrust;
currentTriple.UpdateAssert(fsd.GetAssertions(fDeclarative));
return(true);
}
// Assert
PermissionSet assertPset = fsd.GetAssertions(fDeclarative);
if (assertPset != null)
{
if (assertPset.IsUnrestricted())
{
// If we have no grant set, it means that the only assembly we've seen on the stack so
// far is mscorlib. Since mscorlib will always be fully trusted, the grant set of the
// compressed stack is also FullTrust.
if (currentTriple.GrantSet == null)
{
currentTriple.GrantSet = PermissionSet.s_fullTrust;
}
UpdateTripleListAndCreateNewTriple(currentTriple, m_permSetTriples);
currentTriple.GrantSet = PermissionSet.s_fullTrust;
currentTriple.UpdateAssert(assertPset);
return(true);
}
PermissionSetTriple retTriple = currentTriple.UpdateAssert(assertPset);
if (retTriple != null)
{
EnsureTriplesListCreated();
m_permSetTriples.Add(retTriple);
}
}
return(false);
}
internal PermissionSetTriple(PermissionSetTriple triple)
{
this.AssertSet = triple.AssertSet;
this.GrantSet = triple.GrantSet;
this.RefusedSet = triple.RefusedSet;
}
private void Terminate(PermissionSetTriple currentTriple, PermissionListSet pls)
{
this.UpdateZoneAndOrigin(pls);
this.UpdatePermissions(currentTriple, pls);
this.UpdateTripleListAndCreateNewTriple(currentTriple, null);
}
[System.Security.SecurityCritical] // auto-generated
internal PermissionSetTriple UpdateAssert(PermissionSet in_a)
{
PermissionSetTriple retTriple = null;
if (in_a != null)
{
Contract.Assert((!in_a.IsUnrestricted() || RefusedSet == null), "Cannot be unrestricted or refused must be null");
// if we're already asserting in_a, nothing to do
if (in_a.IsSubsetOf(AssertSet))
return null;
PermissionSet retPs;
if (GrantSet != null)
retPs = in_a.Intersect(GrantSet); // Restrict the assert to what we've already been granted
else
{
GrantSet = new PermissionSet(true);
retPs = in_a.Copy(); // Currently unrestricted Grant: assert the whole assert set
}
bool bFailedToCompress = false;
// removes anything that is already in the refused set from the assert set
if (RefusedSet != null)
{
retPs = PermissionSet.RemoveRefusedPermissionSet(retPs, RefusedSet, out bFailedToCompress);
}
if (!bFailedToCompress)
bFailedToCompress = PermissionSet.IsIntersectingAssertedPermissions(retPs, AssertSet);
if (bFailedToCompress)
{
retTriple = new PermissionSetTriple(this);
this.Reset();
this.GrantSet = retTriple.GrantSet.Copy();
}
if (AssertSet == null)
AssertSet = retPs;
else
AssertSet.InplaceUnion(retPs);
}
return retTriple;
}
internal static PermissionListSet CreateCompressedState(CompressedStack cs, CompressedStack innerCS)
{
bool constructionHalted = false;
if (cs.CompressedStackHandle == null)
{
return null;
}
PermissionListSet set = new PermissionListSet();
PermissionSetTriple currentTriple = new PermissionSetTriple();
for (int i = CompressedStack.GetDCSCount(cs.CompressedStackHandle) - 1; (i >= 0) && !constructionHalted; i--)
{
DomainCompressedStack domainCompressedStack = CompressedStack.GetDomainCompressedStack(cs.CompressedStackHandle, i);
if (domainCompressedStack != null)
{
if (domainCompressedStack.PLS == null)
{
throw new SecurityException(string.Format(CultureInfo.InvariantCulture, Environment.GetResourceString("Security_Generic"), new object[0]));
}
set.UpdateZoneAndOrigin(domainCompressedStack.PLS);
set.Update(currentTriple, domainCompressedStack.PLS);
constructionHalted = domainCompressedStack.ConstructionHalted;
}
}
if (!constructionHalted)
{
PermissionListSet pls = null;
if (innerCS != null)
{
innerCS.CompleteConstruction(null);
pls = innerCS.PLS;
}
set.Terminate(currentTriple, pls);
return set;
}
set.Terminate(currentTriple);
return set;
}
[System.Security.SecurityCritical] // auto-generated
private bool Update(PermissionSetTriple currentTriple, FrameSecurityDescriptor fsd)
{
// check imperative
bool fHalt = Update2(currentTriple, fsd, false);
if (!fHalt)
{
// then declarative
fHalt = Update2(currentTriple, fsd, true);
}
return fHalt;
}
internal static PermissionListSet CreateCompressedState(IntPtr unmanagedDCS, out bool bHaltConstruction)
{
PermissionSet set2;
PermissionSet set3;
PermissionListSet set = new PermissionListSet();
PermissionSetTriple currentTriple = new PermissionSetTriple();
int descCount = DomainCompressedStack.GetDescCount(unmanagedDCS);
bHaltConstruction = false;
for (int i = 0; (i < descCount) && !bHaltConstruction; i++)
{
FrameSecurityDescriptor descriptor;
Assembly assembly;
if (DomainCompressedStack.GetDescriptorInfo(unmanagedDCS, i, out set2, out set3, out assembly, out descriptor))
{
bHaltConstruction = set.Update(currentTriple, descriptor);
}
else
{
set.Update(currentTriple, set2, set3);
}
}
if (!bHaltConstruction && !DomainCompressedStack.IgnoreDomain(unmanagedDCS))
{
DomainCompressedStack.GetDomainPermissionSets(unmanagedDCS, out set2, out set3);
set.Update(currentTriple, set2, set3);
}
set.Terminate(currentTriple);
return set;
}
[System.Security.SecurityCritical] // auto-generated
private void Update(PermissionSetTriple currentTriple, PermissionSet in_g, PermissionSet in_r)
{
#if FEATURE_COMPRESSEDSTACK
ZoneIdentityPermission z;
UrlIdentityPermission u;
currentTriple.UpdateGrant(in_g, out z, out u);
currentTriple.UpdateRefused(in_r);
AppendZoneOrigin(z, u);
#else // !FEATURE_COMPRESEDSTACK
currentTriple.UpdateGrant(in_g);
currentTriple.UpdateRefused(in_r);
#endif // FEATURE_COMPRESSEDSTACK
}
private void Terminate(PermissionSetTriple currentTriple, PermissionListSet pls)
{
this.UpdatePermissions(currentTriple, pls);
this.UpdateTripleListAndCreateNewTriple(currentTriple, null);
}
[System.Security.SecurityCritical] // auto-generated
private bool UpdatePermissions(PermissionSetTriple currentTriple, PermissionListSet pls)
{
if (pls != null)
{
if (pls.m_permSetTriples != null)
{
// DCS has an AGR List. So we need to add the AGR List
UpdateTripleListAndCreateNewTriple(currentTriple,pls.m_permSetTriples);
}
else
{
// Common case: One AGR set
PermissionSetTriple tmp_psTriple = pls.m_firstPermSetTriple;
PermissionSetTriple retTriple;
// First try and update currentTriple. Return value indicates if we can stop construction
if (currentTriple.Update(tmp_psTriple, out retTriple))
return true;
// If we got a non-null retTriple, what it means is that compression failed,
// and we now have 2 triples to deal with: retTriple and currentTriple.
// retTriple has to be appended first. then currentTriple.
if (retTriple != null)
{
EnsureTriplesListCreated();
// we just created a new triple...add the previous one (returned) to the list
m_permSetTriples.Add(retTriple);
}
}
}
else
{
// pls can be null only outside the loop in CreateCompressedState
UpdateTripleListAndCreateNewTriple(currentTriple, null);
}
return false;
}
private void Terminate(PermissionSetTriple currentTriple, PermissionListSet pls)
{
this.UpdateZoneAndOrigin(pls);
this.UpdatePermissions(currentTriple, pls);
this.UpdateTripleListAndCreateNewTriple(currentTriple, (ArrayList)null);
}
// public(internal) interface begins...
// Creation functions
static internal PermissionListSet CreateCompressedState(CompressedStack cs, CompressedStack innerCS)
{
// function that completes the construction of the compressed stack if not done so already (bottom half for demand evaluation)
bool bHaltConstruction = false;
if (cs.CompressedStackHandle == null)
return null; // FT case or Security off
PermissionListSet pls = new PermissionListSet();
PermissionSetTriple currentTriple = new PermissionSetTriple();
int numDomains = CompressedStack.GetDCSCount(cs.CompressedStackHandle);
for (int i=numDomains-1; (i >= 0 && !bHaltConstruction) ; i--)
{
DomainCompressedStack dcs = CompressedStack.GetDomainCompressedStack(cs.CompressedStackHandle, i);
if (dcs == null)
continue; // we hit a FT Domain
if (dcs.PLS == null)
{
// We failed on some DCS
throw new SecurityException(String.Format(CultureInfo.InvariantCulture, Environment.GetResourceString("Security_Generic")));
}
pls.UpdateZoneAndOrigin(dcs.PLS);
pls.Update(currentTriple, dcs.PLS);
bHaltConstruction = dcs.ConstructionHalted;
}
if (!bHaltConstruction)
{
PermissionListSet tmp_pls = null;
// Construction did not halt.
if (innerCS != null)
{
innerCS.CompleteConstruction(null);
tmp_pls = innerCS.PLS;
}
pls.Terminate(currentTriple, tmp_pls);
}
else
{
pls.Terminate(currentTriple);
}
return pls;
}
private bool Update(PermissionSetTriple currentTriple, PermissionListSet pls)
{
this.UpdateZoneAndOrigin(pls);
return(this.UpdatePermissions(currentTriple, pls));
}
private void Terminate(PermissionSetTriple currentTriple)
{
UpdateTripleListAndCreateNewTriple(currentTriple, null);
}
private bool Update(PermissionSetTriple currentTriple, FrameSecurityDescriptor fsd)
{
bool flag = this.Update2(currentTriple, fsd, false);
if (!flag)
{
flag = this.Update2(currentTriple, fsd, true);
}
return flag;
}
private void Terminate(PermissionSetTriple currentTriple)
{
UpdateTripleListAndCreateNewTriple(currentTriple, null);
}
private void Terminate(PermissionSetTriple currentTriple)
{
this.UpdateTripleListAndCreateNewTriple(currentTriple, (ArrayList)null);
}
[System.Security.SecurityCritical] // auto-generated
private bool Update(PermissionSetTriple currentTriple, PermissionListSet pls)
{
#if FEATURE_COMPRESSEDSTACK
this.UpdateZoneAndOrigin(pls);
#endif // FEATURE_COMPRESSEDSTACK
return this.UpdatePermissions(currentTriple, pls);
}
private void Update(PermissionSetTriple currentTriple, PermissionSet in_g, PermissionSet in_r)
{
currentTriple.UpdateGrant(in_g);
currentTriple.UpdateRefused(in_r);
}
