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

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