mcs/class/referencesource/mscorlib/system/security/permissions/uipermission.cs

   1 // ==++==
   2 //
   3 //   Copyright (c) Microsoft Corporation.  All rights reserved.
   4 //
   5 // ==--==
   6 // UIPermission.cs
   7 //
   8 // <OWNER>[....]</OWNER>
   9 //
  10
  11 namespace System.Security.Permissions
  12 {
  13     using System;
  14     using System.Security;
  15     using System.Security.Util;
  16     using System.IO;
  17     using System.Runtime.Serialization;
  18     using System.Reflection;
  19     using System.Collections;
  20     using System.Globalization;
  21     using System.Diagnostics.Contracts;
  22
  23     [Serializable]
  24 [System.Runtime.InteropServices.ComVisible(true)]
  25     public enum UIPermissionWindow
  26     {
  27         // No window use allowed at all.
  28         NoWindows = 0x0,
  29
  30         // Only allow safe subwindow use (for embedded components).
  31         SafeSubWindows = 0x01,
  32
  33         // Safe top-level window use only (see specification for details).
  34         SafeTopLevelWindows = 0x02,
  35
  36         // All windows and all event may be used.
  37         AllWindows = 0x03,
  38
  39     }
  40
  41     [Serializable]
  42 [System.Runtime.InteropServices.ComVisible(true)]
  43     public enum UIPermissionClipboard
  44     {
  45         // No clipboard access is allowed.
  46         NoClipboard = 0x0,
  47
  48         // Paste from the same app domain only.
  49         OwnClipboard = 0x1,
  50
  51         // Any clipboard access is allowed.
  52         AllClipboard = 0x2,
  53
  54     }
  55
  56
  57 [System.Runtime.InteropServices.ComVisible(true)]
  58     [Serializable]
  59     sealed public class UIPermission
  60            : CodeAccessPermission, IUnrestrictedPermission, IBuiltInPermission
  61     {
  62         //------------------------------------------------------
  63         //
  64         // PRIVATE STATE DATA
  65         //
  66         //------------------------------------------------------
  67
  68         private UIPermissionWindow m_windowFlag;
  69         private UIPermissionClipboard m_clipboardFlag;
  70
  71         //------------------------------------------------------
  72         //
  73         // PUBLIC CONSTRUCTORS
  74         //
  75         //------------------------------------------------------
  76
  77         public UIPermission(PermissionState state)
  78         {
  79             if (state == PermissionState.Unrestricted)
  80             {
  81                 SetUnrestricted( true );
  82             }
  83             else if (state == PermissionState.None)
  84             {
  85                 SetUnrestricted( false );
  86                 Reset();
  87             }
  88             else
  89             {
  90                 throw new ArgumentException(Environment.GetResourceString("Argument_InvalidPermissionState"));
  91             }
  92         }
  93
  94         public UIPermission(UIPermissionWindow windowFlag, UIPermissionClipboard clipboardFlag )
  95         {
  96             VerifyWindowFlag( windowFlag );
  97             VerifyClipboardFlag( clipboardFlag );
  98
  99             m_windowFlag = windowFlag;
 100             m_clipboardFlag = clipboardFlag;
 101         }
 102
 103         public UIPermission(UIPermissionWindow windowFlag )
 104         {
 105             VerifyWindowFlag( windowFlag );
 106
 107             m_windowFlag = windowFlag;
 108         }
 109
 110         public UIPermission(UIPermissionClipboard clipboardFlag )
 111         {
 112             VerifyClipboardFlag( clipboardFlag );
 113
 114             m_clipboardFlag = clipboardFlag;
 115         }
 116
 117
 118         //------------------------------------------------------
 119         //
 120         // PUBLIC ACCESSOR METHODS
 121         //
 122         //------------------------------------------------------
 123
 124         public UIPermissionWindow Window
 125         {
 126             set
 127             {
 128                 VerifyWindowFlag(value);
 129
 130                 m_windowFlag = value;
 131             }
 132
 133             get
 134             {
 135                 return m_windowFlag;
 136             }
 137         }
 138
 139         public UIPermissionClipboard Clipboard
 140         {
 141             set
 142             {
 143                 VerifyClipboardFlag(value);
 144
 145                 m_clipboardFlag = value;
 146             }
 147
 148             get
 149             {
 150                 return m_clipboardFlag;
 151             }
 152         }
 153
 154         //------------------------------------------------------
 155         //
 156         // PRIVATE AND PROTECTED HELPERS FOR ACCESSORS AND CONSTRUCTORS
 157         //
 158         //------------------------------------------------------
 159
 160         private static void VerifyWindowFlag(UIPermissionWindow flag)
 161         {
 162             if (flag < UIPermissionWindow.NoWindows || flag > UIPermissionWindow.AllWindows)
 163             {
 164                 throw new ArgumentException(Environment.GetResourceString("Arg_EnumIllegalVal", (int)flag));
 165             }
 166             Contract.EndContractBlock();
 167         }
 168
 169         private static void VerifyClipboardFlag(UIPermissionClipboard flag)
 170         {
 171             if (flag < UIPermissionClipboard.NoClipboard || flag > UIPermissionClipboard.AllClipboard)
 172             {
 173                 throw new ArgumentException(Environment.GetResourceString("Arg_EnumIllegalVal", (int)flag));
 174             }
 175             Contract.EndContractBlock();
 176         }
 177
 178         private void Reset()
 179         {
 180             m_windowFlag = UIPermissionWindow.NoWindows;
 181             m_clipboardFlag = UIPermissionClipboard.NoClipboard;
 182         }
 183
 184         private void SetUnrestricted( bool unrestricted )
 185         {
 186             if (unrestricted)
 187             {
 188                 m_windowFlag = UIPermissionWindow.AllWindows;
 189                 m_clipboardFlag = UIPermissionClipboard.AllClipboard;
 190             }
 191         }
 192
 193 #if false
 194         //------------------------------------------------------
 195         //
 196         // OBJECT METHOD OVERRIDES
 197         //
 198         //------------------------------------------------------
 199         public String ToString()
 200         {
 201     #if _DEBUG
 202             StringBuilder sb = new StringBuilder();
 203             sb.Append("UIPermission(");
 204             if (IsUnrestricted())
 205             {
 206                 sb.Append("Unrestricted");
 207             }
 208             else
 209             {
 210                 sb.Append(m_stateNameTableWindow[m_windowFlag]);
 211                 sb.Append(", ");
 212                 sb.Append(m_stateNameTableClipboard[m_clipboardFlag]);
 213             }
 214
 215             sb.Append(")");
 216             return sb.ToString();
 217     #else
 218             return super.ToString();
 219     #endif
 220         }
 221 #endif
 222
 223         //------------------------------------------------------
 224         //
 225         // CODEACCESSPERMISSION IMPLEMENTATION
 226         //
 227         //------------------------------------------------------
 228
 229         public bool IsUnrestricted()
 230         {
 231             return m_windowFlag == UIPermissionWindow.AllWindows && m_clipboardFlag == UIPermissionClipboard.AllClipboard;
 232         }
 233
 234         //------------------------------------------------------
 235         //
 236         // IPERMISSION IMPLEMENTATION
 237         //
 238         //------------------------------------------------------
 239
 240         public override bool IsSubsetOf(IPermission target)
 241         {
 242             if (target == null)
 243             {
 244                 // Only safe subset if this is empty
 245                 return m_windowFlag == UIPermissionWindow.NoWindows && m_clipboardFlag == UIPermissionClipboard.NoClipboard;
 246             }
 247
 248             try
 249             {
 250                 UIPermission operand = (UIPermission)target;
 251                 if (operand.IsUnrestricted())
 252                     return true;
 253                 else if (this.IsUnrestricted())
 254                     return false;
 255                 else
 256                     return this.m_windowFlag <= operand.m_windowFlag && this.m_clipboardFlag <= operand.m_clipboardFlag;
 257             }
 258             catch (InvalidCastException)
 259             {
 260                 throw new
 261                     ArgumentException(
 262                                     Environment.GetResourceString("Argument_WrongType", this.GetType().FullName)
 263                                      );
 264             }
 265
 266         }
 267
 268         public override IPermission Intersect(IPermission target)
 269         {
 270             if (target == null)
 271             {
 272                 return null;
 273             }
 274             else if (!VerifyType(target))
 275             {
 276                 throw new
 277                     ArgumentException(
 278                                     Environment.GetResourceString("Argument_WrongType", this.GetType().FullName)
 279                                      );
 280             }
 281
 282             UIPermission operand = (UIPermission)target;
 283             UIPermissionWindow isectWindowFlags = m_windowFlag < operand.m_windowFlag ? m_windowFlag : operand.m_windowFlag;
 284             UIPermissionClipboard isectClipboardFlags = m_clipboardFlag < operand.m_clipboardFlag ? m_clipboardFlag : operand.m_clipboardFlag;
 285             if (isectWindowFlags == UIPermissionWindow.NoWindows && isectClipboardFlags == UIPermissionClipboard.NoClipboard)
 286                 return null;
 287             else
 288                 return new UIPermission(isectWindowFlags, isectClipboardFlags);
 289         }
 290
 291         public override IPermission Union(IPermission target)
 292         {
 293             if (target == null)
 294             {
 295                 return this.Copy();
 296             }
 297             else if (!VerifyType(target))
 298             {
 299                 throw new
 300                     ArgumentException(
 301                                     Environment.GetResourceString("Argument_WrongType", this.GetType().FullName)
 302                                      );
 303             }
 304
 305             UIPermission operand = (UIPermission)target;
 306             UIPermissionWindow isectWindowFlags = m_windowFlag > operand.m_windowFlag ? m_windowFlag : operand.m_windowFlag;
 307             UIPermissionClipboard isectClipboardFlags = m_clipboardFlag > operand.m_clipboardFlag ? m_clipboardFlag : operand.m_clipboardFlag;
 308             if (isectWindowFlags == UIPermissionWindow.NoWindows && isectClipboardFlags == UIPermissionClipboard.NoClipboard)
 309                 return null;
 310             else
 311                 return new UIPermission(isectWindowFlags, isectClipboardFlags);
 312         }
 313
 314         public override IPermission Copy()
 315         {
 316             return new UIPermission(this.m_windowFlag, this.m_clipboardFlag);
 317         }
 318
 319 #if FEATURE_CAS_POLICY
 320         public override SecurityElement ToXml()
 321         {
 322             SecurityElement esd = CodeAccessPermission.CreatePermissionElement( this, "System.Security.Permissions.UIPermission" );
 323             if (!IsUnrestricted())
 324             {
 325                 if (m_windowFlag != UIPermissionWindow.NoWindows)
 326                 {
 327                     esd.AddAttribute( "Window", Enum.GetName( typeof( UIPermissionWindow ), m_windowFlag ) );
 328                 }
 329                 if (m_clipboardFlag != UIPermissionClipboard.NoClipboard)
 330                 {
 331                     esd.AddAttribute( "Clipboard", Enum.GetName( typeof( UIPermissionClipboard ), m_clipboardFlag ) );
 332                 }
 333             }
 334             else
 335             {
 336                 esd.AddAttribute( "Unrestricted", "true" );
 337             }
 338             return esd;
 339         }
 340
 341         public override void FromXml(SecurityElement esd)
 342         {
 343             CodeAccessPermission.ValidateElement( esd, this );
 344             if (XMLUtil.IsUnrestricted( esd ))
 345             {
 346                 SetUnrestricted( true );
 347                 return;
 348             }
 349
 350             m_windowFlag = UIPermissionWindow.NoWindows;
 351             m_clipboardFlag = UIPermissionClipboard.NoClipboard;
 352
 353             String window = esd.Attribute( "Window" );
 354             if (window != null)
 355                 m_windowFlag = (UIPermissionWindow)Enum.Parse( typeof( UIPermissionWindow ), window );
 356
 357             String clipboard = esd.Attribute( "Clipboard" );
 358             if (clipboard != null)
 359                 m_clipboardFlag = (UIPermissionClipboard)Enum.Parse( typeof( UIPermissionClipboard ), clipboard );
 360         }
 361 #endif // FEATURE_CAS_POLICY
 362
 363         /// <internalonly/>
 364         int IBuiltInPermission.GetTokenIndex()
 365         {
 366             return UIPermission.GetTokenIndex();
 367         }
 368
 369         internal static int GetTokenIndex()
 370         {
 371             return BuiltInPermissionIndex.UIPermissionIndex;
 372         }
 373
 374     }
 375
 376
 377 }