mcs/class/corlib/System.Security.Permissions/SecurityPermissionAttribute.cs

   1 //
   2 // System.Security.Permissions.SecurityPermissionAttribute.cs
   3 //
   4 // Author:         Nick Drochak, ndrochak@gol.com
   5 // Created:        2002-01-06
   6 //
   7 // Copyright (C) 2001 Nick Drochak, All Rights Reserved
   8 // Copyright (C) 2004-2005 Novell, Inc (http://www.novell.com)
   9 //
  10 // Permission is hereby granted, free of charge, to any person obtaining
  11 // a copy of this software and associated documentation files (the
  12 // "Software"), to deal in the Software without restriction, including
  13 // without limitation the rights to use, copy, modify, merge, publish,
  14 // distribute, sublicense, and/or sell copies of the Software, and to
  15 // permit persons to whom the Software is furnished to do so, subject to
  16 // the following conditions:
  17 //
  18 // The above copyright notice and this permission notice shall be
  19 // included in all copies or substantial portions of the Software.
  20 //
  21 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  22 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  23 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  24 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  25 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  26 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  27 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  28 //
  29
  30 using System.Runtime.InteropServices;
  31
  32 namespace System.Security.Permissions {
  33
  34 #if NET_2_1 && !MONOTOUCH
  35         [Obsolete ("CAS support is not available with Silverlight applications.")]
  36 #endif
  37         [ComVisible (true)]
  38         [AttributeUsage (
  39                 System.AttributeTargets.Assembly
  40                 | System.AttributeTargets.Class
  41                 | System.AttributeTargets.Struct
  42                 | System.AttributeTargets.Constructor
  43                 | System.AttributeTargets.Method,
  44                 AllowMultiple=true,
  45                 Inherited=false)
  46         ]
  47         [Serializable]
  48         public sealed class SecurityPermissionAttribute : CodeAccessSecurityAttribute {
  49                 private SecurityPermissionFlag m_Flags;
  50
  51                 public SecurityPermissionAttribute (SecurityAction action) : base(action)
  52                 {
  53                         m_Flags = SecurityPermissionFlag.NoFlags;
  54                 }
  55
  56                 public bool Assertion {
  57                         get {
  58                                 return ((m_Flags & SecurityPermissionFlag.Assertion) != 0);
  59                         }
  60                         set {
  61                                 if (value) {
  62                                         m_Flags |= SecurityPermissionFlag.Assertion;
  63                                 }
  64                                 else{
  65                                         m_Flags &= ~SecurityPermissionFlag.Assertion;
  66                                 }
  67                         }
  68                 }
  69                 public bool BindingRedirects {
  70                         get {
  71                                 return ((m_Flags & SecurityPermissionFlag.BindingRedirects) != 0);
  72                         }
  73                         set {
  74                                 if (value) {
  75                                         m_Flags |= SecurityPermissionFlag.BindingRedirects;
  76                                 }
  77                                 else{
  78                                         m_Flags &= ~SecurityPermissionFlag.BindingRedirects;
  79                                 }
  80                         }
  81                 }
  82
  83                 public bool ControlAppDomain {
  84                         get {
  85                                 return ((m_Flags & SecurityPermissionFlag.ControlAppDomain) != 0);
  86                         }
  87                         set {
  88                                 if (value) {
  89                                         m_Flags |= SecurityPermissionFlag.ControlAppDomain;
  90                                 }
  91                                 else {
  92                                         m_Flags &= ~SecurityPermissionFlag.ControlAppDomain;
  93                                 }
  94                         }
  95                 }
  96
  97                 public bool ControlDomainPolicy {
  98                         get {
  99                                 return ((m_Flags & SecurityPermissionFlag.ControlDomainPolicy) != 0);
 100                         }
 101                         set {
 102                                 if (value) {
 103                                         m_Flags |= SecurityPermissionFlag.ControlDomainPolicy;
 104                                 }
 105                                 else {
 106                                         m_Flags &= ~SecurityPermissionFlag.ControlDomainPolicy;
 107                                 }
 108                         }
 109                 }
 110
 111                 public bool ControlEvidence {
 112                         get {
 113                                 return ((m_Flags & SecurityPermissionFlag.ControlEvidence) != 0);
 114                         }
 115                         set {
 116                                 if (value) {
 117                                         m_Flags |= SecurityPermissionFlag.ControlEvidence;
 118                                 }
 119                                 else {
 120                                         m_Flags &= ~SecurityPermissionFlag.ControlEvidence;
 121                                 }
 122                         }
 123                 }
 124
 125                 public bool ControlPolicy {
 126                         get {
 127                                 return ((m_Flags & SecurityPermissionFlag.ControlPolicy) != 0);
 128                         }
 129                         set {
 130                                 if (value) {
 131                                         m_Flags |= SecurityPermissionFlag.ControlPolicy;
 132                                 }
 133                                 else {
 134                                         m_Flags &= ~SecurityPermissionFlag.ControlPolicy;
 135                                 }
 136                         }
 137                 }
 138
 139                 public bool ControlPrincipal {
 140                         get {
 141                                 return ((m_Flags & SecurityPermissionFlag.ControlPrincipal) != 0);
 142                         }
 143                         set {
 144                                 if (value) {
 145                                         m_Flags |= SecurityPermissionFlag.ControlPrincipal;
 146                                 }
 147                                 else {
 148                                         m_Flags &= ~SecurityPermissionFlag.ControlPrincipal;
 149                                 }
 150                         }
 151                 }
 152
 153                 public bool ControlThread {
 154                         get {
 155                                 return ((m_Flags & SecurityPermissionFlag.ControlThread) != 0);
 156                         }
 157                         set {
 158                                 if (value) {
 159                                         m_Flags |= SecurityPermissionFlag.ControlThread;
 160                                 }
 161                                 else {
 162                                         m_Flags &= ~SecurityPermissionFlag.ControlThread;
 163                                 }
 164                         }
 165                 }
 166
 167                 public bool Execution {
 168                         get {
 169                                 return ((m_Flags & SecurityPermissionFlag.Execution) != 0);
 170                         }
 171                         set {
 172                                 if (value) {
 173                                         m_Flags |= SecurityPermissionFlag.Execution;
 174                                 }
 175                                 else {
 176                                         m_Flags &= ~SecurityPermissionFlag.Execution;
 177                                 }
 178                         }
 179                 }
 180
 181                 [ComVisible (true)]
 182                 public bool Infrastructure {
 183                         get {
 184                                 return ((m_Flags & SecurityPermissionFlag.Infrastructure) != 0);
 185                         }
 186                         set {
 187                                 if (value) {
 188                                         m_Flags |= SecurityPermissionFlag.Infrastructure;
 189                                 }
 190                                 else {
 191                                         m_Flags &= ~SecurityPermissionFlag.Infrastructure;
 192                                 }
 193                         }
 194                 }
 195
 196                 public bool RemotingConfiguration {
 197                         get {
 198                                 return ((m_Flags & SecurityPermissionFlag.RemotingConfiguration) != 0);
 199                         }
 200                         set {
 201                                 if (value) {
 202                                         m_Flags |= SecurityPermissionFlag.RemotingConfiguration;
 203                                 }
 204                                 else {
 205                                         m_Flags &= ~SecurityPermissionFlag.RemotingConfiguration;
 206                                 }
 207                         }
 208                 }
 209
 210                 public bool SerializationFormatter {
 211                         get {
 212                                 return ((m_Flags & SecurityPermissionFlag.SerializationFormatter) != 0);
 213                         }
 214                         set {
 215                                 if (value) {
 216                                         m_Flags |= SecurityPermissionFlag.SerializationFormatter;
 217                                 }
 218                                 else {
 219                                         m_Flags &= ~SecurityPermissionFlag.SerializationFormatter;
 220                                 }
 221                         }
 222                 }
 223
 224                 public bool SkipVerification {
 225                         get {
 226                                 return ((m_Flags & SecurityPermissionFlag.SkipVerification) != 0);
 227                         }
 228                         set {
 229                                 if (value) {
 230                                         m_Flags |= SecurityPermissionFlag.SkipVerification;
 231                                 }
 232                                 else {
 233                                         m_Flags &= ~SecurityPermissionFlag.SkipVerification;
 234                                 }
 235                         }
 236                 }
 237
 238                 public bool UnmanagedCode {
 239                         get {
 240                                 return ((m_Flags & SecurityPermissionFlag.UnmanagedCode) != 0);
 241                         }
 242                         set {
 243                                 if (value) {
 244                                         m_Flags |= SecurityPermissionFlag.UnmanagedCode;
 245                                 }
 246                                 else {
 247                                         m_Flags &= ~SecurityPermissionFlag.UnmanagedCode;
 248                                 }
 249                         }
 250                 }
 251
 252                 public override IPermission CreatePermission ()
 253                 {
 254 #if NET_2_1
 255                         return null;
 256 #else
 257                         SecurityPermission perm = null;
 258                         if (this.Unrestricted)
 259                                 perm = new SecurityPermission (PermissionState.Unrestricted);
 260                         else
 261                                 perm = new SecurityPermission (m_Flags);
 262                         return perm;
 263 #endif
 264                 }
 265
 266                 public SecurityPermissionFlag Flags {
 267                         get {
 268                                 return m_Flags;
 269                         }
 270                         set {
 271                                 m_Flags = value;
 272                         }
 273                 }
 274         }  // public sealed class SecurityPermissionAttribute
 275 }  // namespace System.Security.Permissions