public void Default ()
{
SecurityPermissionAttribute a = new SecurityPermissionAttribute (SecurityAction.Assert);
Assert.IsFalse (a.Assertion, "Assertion");
#if NET_2_0
Assert.IsFalse (a.BindingRedirects, "BindingRedirects");
#endif
Assert.IsFalse (a.ControlAppDomain, "ControlAppDomain");
Assert.IsFalse (a.ControlDomainPolicy, "ControlDomainPolicy");
Assert.IsFalse (a.ControlEvidence, "ControlEvidence");
Assert.IsFalse (a.ControlPolicy, "ControlPolicy");
Assert.IsFalse (a.ControlPrincipal, "ControlPrincipal");
Assert.IsFalse (a.ControlThread, "ControlThread");
Assert.IsFalse (a.Execution, "Execution");
Assert.IsFalse (a.Infrastructure, "Infrastructure");
Assert.IsFalse (a.RemotingConfiguration, "RemotingConfiguration");
Assert.IsFalse (a.SerializationFormatter, "SerializationFormatter");
Assert.IsFalse (a.SkipVerification, "SkipVerification");
Assert.IsFalse (a.UnmanagedCode, "UnmanagedCode");
Assert.AreEqual (SecurityPermissionFlag.NoFlags, a.Flags, "Flags");
Assert.AreEqual (a.ToString (), a.TypeId.ToString (), "TypeId");
Assert.IsFalse (a.Unrestricted, "Unrestricted");
SecurityPermission perm = (SecurityPermission) a.CreatePermission ();
Assert.AreEqual (SecurityPermissionFlag.NoFlags, perm.Flags, "CreatePermission.Flags");
}
public void Action ()
{
SecurityPermissionAttribute a = new SecurityPermissionAttribute (SecurityAction.Assert);
Assert.AreEqual (SecurityAction.Assert, a.Action, "Action=Assert");
a.Action = SecurityAction.Demand;
Assert.AreEqual (SecurityAction.Demand, a.Action, "Action=Demand");
a.Action = SecurityAction.Deny;
Assert.AreEqual (SecurityAction.Deny, a.Action, "Action=Deny");
a.Action = SecurityAction.InheritanceDemand;
Assert.AreEqual (SecurityAction.InheritanceDemand, a.Action, "Action=InheritanceDemand");
a.Action = SecurityAction.LinkDemand;
Assert.AreEqual (SecurityAction.LinkDemand, a.Action, "Action=LinkDemand");
a.Action = SecurityAction.PermitOnly;
Assert.AreEqual (SecurityAction.PermitOnly, a.Action, "Action=PermitOnly");
a.Action = SecurityAction.RequestMinimum;
Assert.AreEqual (SecurityAction.RequestMinimum, a.Action, "Action=RequestMinimum");
a.Action = SecurityAction.RequestOptional;
Assert.AreEqual (SecurityAction.RequestOptional, a.Action, "Action=RequestOptional");
a.Action = SecurityAction.RequestRefuse;
Assert.AreEqual (SecurityAction.RequestRefuse, a.Action, "Action=RequestRefuse");
#if NET_2_0
a.Action = SecurityAction.DemandChoice;
Assert.AreEqual (SecurityAction.DemandChoice, a.Action, "Action=DemandChoice");
a.Action = SecurityAction.InheritanceDemandChoice;
Assert.AreEqual (SecurityAction.InheritanceDemandChoice, a.Action, "Action=InheritanceDemandChoice");
a.Action = SecurityAction.LinkDemandChoice;
Assert.AreEqual (SecurityAction.LinkDemandChoice, a.Action, "Action=LinkDemandChoice");
#endif
}
/// <summary>
/// Workitem 7889: handle ERROR_LOCK_VIOLATION during read
/// </summary>
/// <remarks>
/// This could be gracefully handled with an extension attribute, but
/// This assembly is built for .NET 2.0, so I cannot use them.
/// </remarks>
internal static int ReadWithRetry(System.IO.Stream s, byte[] buffer, int offset, int count, string FileName)
{
int n = 0;
bool done = false;
#if !NETCF && !SILVERLIGHT
int retries = 0;
#endif
do
{
try
{
n = s.Read(buffer, offset, count);
done = true;
}
#if NETCF || SILVERLIGHT
catch (System.IO.IOException)
{
throw;
}
#else
catch (System.IO.IOException ioexc1)
{
// Check if we can call GetHRForException,
// which makes unmanaged code calls.
var p = new System.Security.Permissions.SecurityPermissionAttribute(SecurityAction.Assert).Unrestricted;
if (p)
{
uint hresult = _HRForException(ioexc1);
if (hresult != 0x80070021) // ERROR_LOCK_VIOLATION
{
throw new System.IO.IOException(String.Format("Cannot read file {0}", FileName), ioexc1);
}
retries++;
if (retries > 10)
{
throw new System.IO.IOException(String.Format("Cannot read file {0}, at offset 0x{1:X8} after 10 retries", FileName, offset), ioexc1);
}
// max time waited on last retry = 250 + 10*550 = 5.75s
// aggregate time waited after 10 retries: 250 + 55*550 = 30.5s
System.Threading.Thread.Sleep(250 + retries * 550);
}
else
{
// The permission.Demand() failed. Therefore, we cannot call
// GetHRForException, and cannot do the subtle handling of
// ERROR_LOCK_VIOLATION. Just bail.
throw;
}
}
#endif
}while (!done);
return(n);
}
public static int Main()
{
object[] o = Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(System.Security.Permissions.SecurityPermissionAttribute), false);
if (o.Length != 1)
{
return(1);
}
System.Security.Permissions.SecurityPermissionAttribute a = (System.Security.Permissions.SecurityPermissionAttribute)o[0];
if (a.Action != System.Security.Permissions.SecurityAction.RequestMinimum)
{
return(2);
}
if (!a.SkipVerification)
{
return(3);
}
Console.WriteLine(a);
return(0);
}
private SecurityPermissionAttribute Empty ()
{
SecurityPermissionAttribute a = new SecurityPermissionAttribute (SecurityAction.Assert);
a.Assertion = false;
#if NET_2_0
a.BindingRedirects = false;
#endif
a.ControlAppDomain = false;
a.ControlDomainPolicy = false;
a.ControlEvidence = false;
a.ControlPolicy = false;
a.ControlPrincipal = false;
a.ControlThread = false;
a.Execution = false;
a.Infrastructure = false;
a.RemotingConfiguration = false;
a.SerializationFormatter = false;
a.SkipVerification = false;
a.UnmanagedCode = false;
Assert.AreEqual (SecurityPermissionFlag.NoFlags, a.Flags, "Flags");
return a;
}
public void Action_Invalid ()
{
SecurityPermissionAttribute a = new SecurityPermissionAttribute ((SecurityAction)Int32.MinValue);
// no validation in attribute
}
public void Flags ()
{
SecurityPermissionAttribute a = new SecurityPermissionAttribute (SecurityAction.Assert);
a.Flags = SecurityPermissionFlag.Assertion;
Assert.IsTrue (a.Assertion, "Assertion");
#if NET_2_0
a.Flags |= SecurityPermissionFlag.BindingRedirects;
Assert.IsTrue (a.BindingRedirects, "BindingRedirects");
#endif
a.Flags |= SecurityPermissionFlag.ControlAppDomain;
Assert.IsTrue (a.ControlAppDomain, "ControlAppDomain");
a.Flags |= SecurityPermissionFlag.ControlDomainPolicy;
Assert.IsTrue (a.ControlDomainPolicy, "ControlDomainPolicy");
a.Flags |= SecurityPermissionFlag.ControlEvidence;
Assert.IsTrue (a.ControlEvidence, "ControlEvidence");
a.Flags |= SecurityPermissionFlag.ControlPolicy;
Assert.IsTrue (a.ControlPolicy, "ControlPolicy");
a.Flags |= SecurityPermissionFlag.ControlPrincipal;
Assert.IsTrue (a.ControlPrincipal, "ControlPrincipal");
a.Flags |= SecurityPermissionFlag.ControlThread;
Assert.IsTrue (a.ControlThread, "ControlThread");
a.Flags |= SecurityPermissionFlag.Execution;
Assert.IsTrue (a.Execution, "Execution");
a.Flags |= SecurityPermissionFlag.Infrastructure;
Assert.IsTrue (a.Infrastructure, "Infrastructure");
a.Flags |= SecurityPermissionFlag.RemotingConfiguration;
Assert.IsTrue (a.RemotingConfiguration, "RemotingConfiguration");
a.Flags |= SecurityPermissionFlag.SerializationFormatter;
Assert.IsTrue (a.SerializationFormatter, "SerializationFormatter");
a.Flags |= SecurityPermissionFlag.SkipVerification;
Assert.IsTrue (a.SkipVerification, "SkipVerification");
a.Flags |= SecurityPermissionFlag.UnmanagedCode;
Assert.IsTrue (a.UnmanagedCode, "UnmanagedCode");
Assert.IsFalse (a.Unrestricted, "Unrestricted");
a.Flags &= ~SecurityPermissionFlag.Assertion;
Assert.IsFalse (a.Assertion, "Assertion-False");
#if NET_2_0
a.Flags &= ~SecurityPermissionFlag.BindingRedirects;
Assert.IsFalse (a.BindingRedirects, "BindingRedirects-False");
#endif
a.Flags &= ~SecurityPermissionFlag.ControlAppDomain;
Assert.IsFalse (a.ControlAppDomain, "ControlAppDomain-False");
a.Flags &= ~SecurityPermissionFlag.ControlDomainPolicy;
Assert.IsFalse (a.ControlDomainPolicy, "ControlDomainPolicy-False");
a.Flags &= ~SecurityPermissionFlag.ControlEvidence;
Assert.IsFalse (a.ControlEvidence, "ControlEvidence-False");
a.Flags &= ~SecurityPermissionFlag.ControlPolicy;
Assert.IsFalse (a.ControlPolicy, "ControlPolicy-False");
a.Flags &= ~SecurityPermissionFlag.ControlPrincipal;
Assert.IsFalse (a.ControlPrincipal, "ControlPrincipal-False");
a.Flags &= ~SecurityPermissionFlag.ControlThread;
Assert.IsFalse (a.ControlThread, "ControlThread-False");
a.Flags &= ~SecurityPermissionFlag.Execution;
Assert.IsFalse (a.Execution, "Execution-False");
a.Flags &= ~SecurityPermissionFlag.Infrastructure;
Assert.IsFalse (a.Infrastructure, "Infrastructure-False");
a.Flags &= ~SecurityPermissionFlag.RemotingConfiguration;
Assert.IsFalse (a.RemotingConfiguration, "RemotingConfiguration-False");
a.Flags &= ~SecurityPermissionFlag.SerializationFormatter;
Assert.IsFalse (a.SerializationFormatter, "SerializationFormatter-False");
a.Flags &= ~SecurityPermissionFlag.SkipVerification;
Assert.IsFalse (a.SkipVerification, "SkipVerification-False");
a.Flags &= ~SecurityPermissionFlag.UnmanagedCode;
}
public void Unrestricted ()
{
SecurityPermissionAttribute a = new SecurityPermissionAttribute (SecurityAction.Assert);
a.Unrestricted = true;
Assert.AreEqual (SecurityPermissionFlag.NoFlags, a.Flags, "Unrestricted");
SecurityPermission perm = (SecurityPermission) a.CreatePermission ();
Assert.AreEqual (SecurityPermissionFlag.AllFlags, perm.Flags, "CreatePermission.Flags");
}
