internal IsolatedStoragePermission
(IsolatedStoragePermissionAttribute copyFrom)
{
this.state = PermissionState.None;
this.userQuota = copyFrom.userQuota;
this.usageAllowed = copyFrom.usageAllowed;
}
public RegistryPermission(RegistryPermissionAccess flag, String pathList)
{
if(pathList == null)
{
throw new ArgumentNullException("pathList");
}
if((flag & ~(RegistryPermissionAccess.AllAccess)) != 0)
{
throw new ArgumentException(_("Arg_RegistryAccess"));
}
this.state = PermissionState.None;
String[] split = EnvironmentPermission.SplitPath(pathList);
if((flag & RegistryPermissionAccess.Read) != 0)
{
readList = split;
}
if((flag & RegistryPermissionAccess.Write) != 0)
{
writeList = split;
}
if((flag & RegistryPermissionAccess.Create) != 0)
{
createList = split;
}
}
public PerformanceCounterPermission(PermissionState state)
: base(state)
{
PermissionAccessType =
typeof(PerformanceCounterPermissionAccess);
TagNames = new String [] {"Machine", "Category"};
}
public ReflectionPermission (PermissionState state)
{
if (CheckPermissionState (state, true) == PermissionState.Unrestricted)
flags = ReflectionPermissionFlag.AllFlags;
else
flags = ReflectionPermissionFlag.NoFlags;
}
/// <summary>
/// Creates a new instance of IngresPermission.
/// </summary>
/// <param name="state">
/// PermissionState for access to all or no resources.</param>
/// <param name="allowBlankPassword"></param>
public IngresPermission(
PermissionState state,
bool allowBlankPassword)
: base(state)
{
this.AllowBlankPassword = allowBlankPassword;
}
// constructors
public HostProtectionPermission (PermissionState state)
{
if (CheckPermissionState (state, true) == PermissionState.Unrestricted)
_resources = HostProtectionResource.All;
else
_resources = HostProtectionResource.None;
}
// private AccessControlActions _control;
#endif
// Constructors
public RegistryPermission (PermissionState state)
{
_state = CheckPermissionState (state, true);
createList = new ArrayList ();
readList = new ArrayList ();
writeList = new ArrayList ();
}
public DataProtectionPermission (PermissionState state)
{
if (PermissionHelper.CheckPermissionState (state, true) == PermissionState.Unrestricted)
_flags = DataProtectionPermissionFlags.AllFlags;
else
_flags = DataProtectionPermissionFlags.NoFlags;
}
public StorePermission (PermissionState state)
{
if (PermissionHelper.CheckPermissionState (state, true) == PermissionState.Unrestricted)
_flags = StorePermissionFlags.AllFlags;
else
_flags = StorePermissionFlags.NoFlags;
}
// Convert an XML value into a permissions value.
public override void FromXml(SecurityElement esd)
{
String value;
if(esd == null)
{
throw new ArgumentNullException("esd");
}
if(esd.Attribute("version") != "1")
{
throw new ArgumentException(S._("Arg_PermissionVersion"));
}
value = esd.Attribute("Unrestricted");
if(value != null && Boolean.Parse(value))
{
state = PermissionState.Unrestricted;
}
else
{
state = PermissionState.None;
}
value = esd.Attribute("Level");
if(value != null)
{
level = (PrintingPermissionLevel)
Enum.Parse(typeof(PrintingPermissionLevel), value);
}
else
{
level = PrintingPermissionLevel.NoPrinting;
}
}
public FileIOPermission(FileIOPermissionAccess flag, String pathList)
{
if(pathList == null)
{
throw new ArgumentNullException("pathList");
}
if((flag & ~(FileIOPermissionAccess.AllAccess)) != 0)
{
throw new ArgumentException(_("Arg_FileIOAccess"));
}
this.state = PermissionState.None;
String[] split = EnvironmentPermission.SplitPath(pathList);
if((flag & FileIOPermissionAccess.Read) != 0)
{
readList = split;
}
if((flag & FileIOPermissionAccess.Write) != 0)
{
writeList = split;
}
if((flag & FileIOPermissionAccess.Append) != 0)
{
appendList = split;
}
if((flag & FileIOPermissionAccess.PathDiscovery) != 0)
{
discoveryList = split;
}
allLocalFiles = FileIOPermissionAccess.NoAccess;
allFiles = FileIOPermissionAccess.NoAccess;
}
internal EnvironmentPermission(PermissionState state, String[] readList,
String[] writeList)
{
this.state = state;
this.readList = readList;
this.writeList = writeList;
}
// Convert an XML value into a permissions value.
public override void FromXml(SecurityElement esd)
{
String value;
if(esd == null)
{
throw new ArgumentNullException("esd");
}
if(esd.Attribute("version") != "1")
{
throw new ArgumentException(_("Arg_PermissionVersion"));
}
value = esd.Attribute("Unrestricted");
if(value != null && Boolean.Parse(value))
{
state = PermissionState.Unrestricted;
}
else
{
state = PermissionState.None;
}
value = esd.Attribute("Access");
if(value != null)
{
flags = (FileDialogPermissionAccess)
Enum.Parse(typeof(FileDialogPermissionAccess), value);
}
else
{
flags = FileDialogPermissionAccess.None;
}
}
/// <include file='doc\MessageQueuePermission.uex' path='docs/doc[@for="MessageQueuePermission.MessageQueuePermission1"]/*' />
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public MessageQueuePermission(PermissionState state)
{
if (state == PermissionState.Unrestricted)
this.isUnrestricted = true;
else
this.isUnrestricted = false;
}
public IsolatedStoragePermission (PermissionState state)
#endif
{
if (CheckPermissionState (state, true) == PermissionState.Unrestricted) {
UsageAllowed = IsolatedStorageContainment.UnrestrictedIsolatedStorage;
}
}
public GisaPrincipalPermission(PermissionState state, GisaPrincipal Principal, string ClassName, params string[] FunctionOperation)
{
this.mState = state;
this.mPrincipal = Principal;
this.mClassName = ClassName;
this.mOperations = FunctionOperation;
}
public AspNetHostingPermission (PermissionState state)
{
if (PermissionHelper.CheckPermissionState (state, true) == PermissionState.Unrestricted)
_level = AspNetHostingPermissionLevel.Unrestricted;
else
_level = AspNetHostingPermissionLevel.None;
}
// constructors
public SecurityPermission (PermissionState state)
{
if (CheckPermissionState (state, true) == PermissionState.Unrestricted)
flags = SecurityPermissionFlag.AllFlags;
else
flags = SecurityPermissionFlag.NoFlags;
}
// Constructors
public UIPermission (PermissionState state)
{
if (CheckPermissionState (state, true) == PermissionState.Unrestricted) {
_clipboard = UIPermissionClipboard.AllClipboard;
_window = UIPermissionWindow.AllWindows;
}
}
// Constructors
public FileDialogPermission (PermissionState state)
{
if (CheckPermissionState (state, true) == PermissionState.Unrestricted)
_access = FileDialogPermissionAccess.OpenSave;
else
_access = FileDialogPermissionAccess.None;
}
//------------------------------------------------------
//
// PUBLIC CONSTRUCTORS
//
//-----------------------------------------------------
public GacIdentityPermission(PermissionState state)
{
if (state != PermissionState.Unrestricted && state != PermissionState.None)
{
throw new ArgumentException(Environment.GetResourceString("Argument_InvalidPermissionState"));
}
}
public ZoneIdentityPermission (PermissionState state)
{
// false == do not allow Unrestricted for Identity Permissions
CheckPermissionState (state, false);
// default values
zone = SecurityZone.NoZone;
}
public SybasePermission (PermissionState state, bool allowBlankPassword)
#if NET_2_0
: base (PermissionState.None)
#endif
{
throw new NotImplementedException ();
}
internal RegistryPermission(PermissionState state, String[] readList,
String[] writeList, String[] createList)
{
this.state = state;
this.readList = readList;
this.writeList = writeList;
this.createList = createList;
}
public DataProtectionPermission (PermissionState state) {
if (state == PermissionState.Unrestricted)
m_flags = DataProtectionPermissionFlags.AllFlags;
else if (state == PermissionState.None)
m_flags = DataProtectionPermissionFlags.NoFlags;
else
throw new ArgumentException(SecurityResources.GetResourceString("Argument_InvalidPermissionState"));
}
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
protected ResourcePermissionBase(PermissionState state) {
if (state == PermissionState.Unrestricted)
this.isUnrestricted = true;
else if (state == PermissionState.None)
this.isUnrestricted = false;
else
throw new ArgumentException(SR.GetString(SR.InvalidPermissionState), "state");
}
public RegistryPermission (RegistryPermissionAccess access, string pathList)
{
_state = PermissionState.None;
createList = new ArrayList ();
readList = new ArrayList ();
writeList = new ArrayList ();
AddPathList (access, pathList);
}
public StorePermission (PermissionState state) {
if (state == PermissionState.Unrestricted)
m_flags = StorePermissionFlags.AllFlags;
else if (state == PermissionState.None)
m_flags = StorePermissionFlags.NoFlags;
else
throw new ArgumentException(SR.GetString(SR.Argument_InvalidPermissionState));
}
// Constructor.
public SiteIdentityPermission(PermissionState state)
{
if(state != PermissionState.None)
{
throw new ArgumentException(_("Arg_PermissionState"));
}
sites = null;
}
// Constructors
public PrincipalPermission (PermissionState state)
{
principals = new ArrayList ();
if (CodeAccessPermission.CheckPermissionState (state, true) == PermissionState.Unrestricted) {
PrincipalInfo pi = new PrincipalInfo (null, null, true);
principals.Add (pi);
}
}
public PrintingPermission(PermissionState state)
{
}
public void PermissionState_Invalid()
{
PermissionState ps = (PermissionState)Int32.MinValue;
OleDbPermission perm = new OleDbPermission(ps);
}
static PermissionSet \u202C([In] PermissionState obj0)
{
// ISSUE: unable to decompile the method.
}
public TypeDescriptorPermission(PermissionState state)
{
}
public SecurityPermission(PermissionState state)
{
Theraot.No.Op(state);
}
protected IsolatedStoragePermission(PermissionState state)
{
}
/// <summary> /// proxy /// </summary> public override CodeAccessPermission CreatePermission(PermissionState state) => WrappedFactory.CreatePermission(state);
/// <summary>
/// Returns a new instance of the <see cref="PsCodeAccessPermission"/> class.
/// </summary>
/// <param name="state">One of the <see cref="PermissionState"/> values.</param>
/// <returns>A <see cref="PsCodeAccessPermission"/> object for the specified <see cref="PermissionState"/>.</returns>
public override CodeAccessPermission CreatePermission(PermissionState state)
{
return(new PsCodeAccessPermission(state));
}
public WebBrowserPermission(PermissionState state)
{
}
public SmtpPermission(PermissionState state)
{
}
// Constructors
public PrincipalPermission(PermissionState state)
{
}
public NetworkInformationPermission(PermissionState state)
{
}
public UrlIdentityPermission(PermissionState state)
{
}
public OraclePermission(PermissionState state)
{
}
public FileIOPermission(PermissionState state)
{
}
public WebPermission(PermissionState state)
{
}
// Constructors
public SecurityPermission(PermissionState state)
{
}
public PermissionSet(PermissionState state)
{
}
/// <summary>Initializes a new instance of the <see cref="T:System.Security.Permissions.EnvironmentPermission" /> class with either restricted or unrestricted permission as specified.</summary><param name="state">One of the <see cref="T:System.Security.Permissions.PermissionState" /> values. </param><exception cref="T:System.ArgumentException">The <paramref name="state" /> parameter is not a valid value of <see cref="T:System.Security.Permissions.PermissionState" />. </exception>
public EnvironmentPermission(PermissionState state)
{
throw new NotImplementedException();
}
public FileDialogPermission(PermissionState state)
{
}
public DirectoryServicesPermission(PermissionState state)
: base(state)
{
SetUp();
}
// Constructors
public RegistryPermission(PermissionState state)
{
}
protected DBDataPermission(PermissionState state, bool allowBlankPassword) : this(state)
{
this.AllowBlankPassword = allowBlankPassword;
}
public SiteIdentityPermission(PermissionState state)
{
}
public ConfigurationPermission(PermissionState state)
{
unrestricted = (state == PermissionState.Unrestricted);
}
public UIPermission(PermissionState state)
{
}
public MediaPermission(PermissionState state)
{
}
/// <summary>Initializes a new instance of the <see cref="T:System.Security.Permissions.ZoneIdentityPermission" /> class with the specified <see cref="T:System.Security.Permissions.PermissionState" />.</summary>
/// <param name="state">One of the <see cref="T:System.Security.Permissions.PermissionState" /> values.</param>
/// <exception cref="T:System.ArgumentException">The <paramref name="state" /> parameter is not a valid value of <see cref="T:System.Security.Permissions.PermissionState" />. </exception>
public ZoneIdentityPermission(PermissionState state)
{
CodeAccessPermission.CheckPermissionState(state, false);
this.zone = SecurityZone.NoZone;
}
public FileDialogPermission(PermissionState state)
{
Contract.Requires((int)state == 1 || (int)state == 0);
return(default(FileDialogPermission));
}
public XamlLoadPermission(PermissionState state)
{
}
