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_0
  35         [ComVisible (true)]
  36 #endif
  37         [AttributeUsage (
  38                 System.AttributeTargets.Assembly
  39                 | System.AttributeTargets.Class
  40                 | System.AttributeTargets.Struct
  41                 | System.AttributeTargets.Constructor
  42                 | System.AttributeTargets.Method,
  43                 AllowMultiple=true,
  44                 Inherited=false)
  45         ]
  46         [Serializable]
  47         public sealed class SecurityPermissionAttribute : CodeAccessSecurityAttribute {
  48                 private SecurityPermissionFlag m_Flags;
  49
  50                 public SecurityPermissionAttribute (SecurityAction action) : base(action)
  51                 {
  52                         m_Flags = SecurityPermissionFlag.NoFlags;
  53                 }
  54
  55                 public bool Assertion {
  56                         get {
  57                                 return ((m_Flags & SecurityPermissionFlag.Assertion) != 0);
  58                         }
  59                         set {
  60                                 if (value) {
  61                                         m_Flags |= SecurityPermissionFlag.Assertion;
  62                                 }
  63                                 else{
  64                                         m_Flags &= ~SecurityPermissionFlag.Assertion;
  65                                 }
  66                         }
  67                 }
  68 #if NET_2_0
  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 #endif
  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 #if NET_2_0
 182                 [ComVisible (true)]
 183 #endif
 184                 public bool Infrastructure {
 185                         get {
 186                                 return ((m_Flags & SecurityPermissionFlag.Infrastructure) != 0);
 187                         }
 188                         set {
 189                                 if (value) {
 190                                         m_Flags |= SecurityPermissionFlag.Infrastructure;
 191                                 }
 192                                 else {
 193                                         m_Flags &= ~SecurityPermissionFlag.Infrastructure;
 194                                 }
 195                         }
 196                 }
 197
 198                 public bool RemotingConfiguration {
 199                         get {
 200                                 return ((m_Flags & SecurityPermissionFlag.RemotingConfiguration) != 0);
 201                         }
 202                         set {
 203                                 if (value) {
 204                                         m_Flags |= SecurityPermissionFlag.RemotingConfiguration;
 205                                 }
 206                                 else {
 207                                         m_Flags &= ~SecurityPermissionFlag.RemotingConfiguration;
 208                                 }
 209                         }
 210                 }
 211
 212                 public bool SerializationFormatter {
 213                         get {
 214                                 return ((m_Flags & SecurityPermissionFlag.SerializationFormatter) != 0);
 215                         }
 216                         set {
 217                                 if (value) {
 218                                         m_Flags |= SecurityPermissionFlag.SerializationFormatter;
 219                                 }
 220                                 else {
 221                                         m_Flags &= ~SecurityPermissionFlag.SerializationFormatter;
 222                                 }
 223                         }
 224                 }
 225
 226                 public bool SkipVerification {
 227                         get {
 228                                 return ((m_Flags & SecurityPermissionFlag.SkipVerification) != 0);
 229                         }
 230                         set {
 231                                 if (value) {
 232                                         m_Flags |= SecurityPermissionFlag.SkipVerification;
 233                                 }
 234                                 else {
 235                                         m_Flags &= ~SecurityPermissionFlag.SkipVerification;
 236                                 }
 237                         }
 238                 }
 239
 240                 public bool UnmanagedCode {
 241                         get {
 242                                 return ((m_Flags & SecurityPermissionFlag.UnmanagedCode) != 0);
 243                         }
 244                         set {
 245                                 if (value) {
 246                                         m_Flags |= SecurityPermissionFlag.UnmanagedCode;
 247                                 }
 248                                 else {
 249                                         m_Flags &= ~SecurityPermissionFlag.UnmanagedCode;
 250                                 }
 251                         }
 252                 }
 253
 254                 public override IPermission CreatePermission ()
 255                 {
 256                         SecurityPermission perm = null;
 257                         if (this.Unrestricted)
 258                                 perm = new SecurityPermission (PermissionState.Unrestricted);
 259                         else
 260                                 perm = new SecurityPermission (m_Flags);
 261                         return perm;
 262                 }
 263
 264                 public SecurityPermissionFlag Flags {
 265                         get {
 266                                 return m_Flags;
 267                         }
 268                         set {
 269                                 m_Flags = value;
 270                         }
 271                 }
 272         }  // public sealed class SecurityPermissionAttribute
 273 }  // namespace System.Security.Permissions