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

   1 // ==++==
   2 //
   3 //   Copyright (c) Microsoft Corporation.  All rights reserved.
   4 //
   5 // ==--==
   6 //
   7 // <OWNER>[....]</OWNER>
   8 //
   9 // Purpose : This permission is used to controls/administer access to
  10 //  IsolatedStorageFile
  11 //
  12
  13 namespace System.Security.Permissions {
  14
  15     using System.Globalization;
  16
  17     [Serializable]
  18 [System.Runtime.InteropServices.ComVisible(true)]
  19     sealed public class IsolatedStorageFilePermission : IsolatedStoragePermission, IBuiltInPermission
  20     {
  21         public IsolatedStorageFilePermission(PermissionState state)
  22         : base(state) { }
  23
  24         internal IsolatedStorageFilePermission(IsolatedStorageContainment UsageAllowed,
  25             long ExpirationDays, bool PermanentData)
  26         : base(UsageAllowed, ExpirationDays, PermanentData) { }
  27
  28         //------------------------------------------------------
  29         //
  30         // IPERMISSION IMPLEMENTATION
  31         //
  32         //------------------------------------------------------
  33
  34         public override IPermission Union(IPermission target)
  35         {
  36             if (target == null)
  37             {
  38                 return this.Copy();
  39             }
  40             else if (!VerifyType(target))
  41             {
  42                 throw new
  43                     ArgumentException(
  44                                     Environment.GetResourceString("Argument_WrongType", this.GetType().FullName)
  45                                      );
  46             }
  47
  48             IsolatedStorageFilePermission operand = (IsolatedStorageFilePermission)target;
  49
  50             if (this.IsUnrestricted() || operand.IsUnrestricted())
  51             {
  52                 return new IsolatedStorageFilePermission( PermissionState.Unrestricted );
  53             }
  54             else
  55             {
  56                 IsolatedStorageFilePermission union;
  57                 union = new IsolatedStorageFilePermission( PermissionState.None );
  58                 union.m_userQuota = max(m_userQuota,operand.m_userQuota);
  59                 union.m_machineQuota = max(m_machineQuota,operand.m_machineQuota);
  60                 union.m_expirationDays = max(m_expirationDays,operand.m_expirationDays);
  61                 union.m_permanentData = m_permanentData || operand.m_permanentData;
  62                 union.m_allowed = (IsolatedStorageContainment)max((long)m_allowed,(long)operand.m_allowed);
  63                 return union;
  64             }
  65         }
  66
  67         public override bool IsSubsetOf(IPermission target)
  68         {
  69             if (target == null)
  70             {
  71                 return ((m_userQuota == 0) &&
  72                         (m_machineQuota == 0) &&
  73                         (m_expirationDays == 0) &&
  74                         (m_permanentData == false) &&
  75                         (m_allowed == IsolatedStorageContainment.None));
  76             }
  77
  78             try
  79             {
  80                 IsolatedStorageFilePermission operand = (IsolatedStorageFilePermission)target;
  81
  82                 if (operand.IsUnrestricted())
  83                     return true;
  84
  85                 return ((operand.m_userQuota >= m_userQuota) &&
  86                         (operand.m_machineQuota >= m_machineQuota) &&
  87                         (operand.m_expirationDays >= m_expirationDays) &&
  88                         (operand.m_permanentData || !m_permanentData) &&
  89                         (operand.m_allowed >= m_allowed));
  90             }
  91             catch (InvalidCastException)
  92             {
  93                 throw new
  94                     ArgumentException(
  95                                     Environment.GetResourceString("Argument_WrongType", this.GetType().FullName)
  96                                      );
  97             }
  98
  99         }
 100
 101         public override IPermission Intersect(IPermission target)
 102         {
 103             if (target == null)
 104                 return null;
 105             else if (!VerifyType(target))
 106             {
 107                 throw new
 108                     ArgumentException(
 109                                     Environment.GetResourceString("Argument_WrongType", this.GetType().FullName)
 110                                      );
 111             }
 112
 113             IsolatedStorageFilePermission operand = (IsolatedStorageFilePermission)target;
 114
 115             if(operand.IsUnrestricted())
 116                 return Copy();
 117             else if(IsUnrestricted())
 118                 return target.Copy();
 119
 120             IsolatedStorageFilePermission intersection;
 121             intersection = new IsolatedStorageFilePermission( PermissionState.None );
 122             intersection.m_userQuota = min(m_userQuota,operand.m_userQuota);
 123             intersection.m_machineQuota = min(m_machineQuota,operand.m_machineQuota);
 124             intersection.m_expirationDays = min(m_expirationDays,operand.m_expirationDays);
 125             intersection.m_permanentData = m_permanentData && operand.m_permanentData;
 126             intersection.m_allowed = (IsolatedStorageContainment)min((long)m_allowed,(long)operand.m_allowed);
 127
 128             if ((intersection.m_userQuota == 0) &&
 129             (intersection.m_machineQuota == 0) &&
 130             (intersection.m_expirationDays == 0) &&
 131             (intersection.m_permanentData == false) &&
 132             (intersection.m_allowed == IsolatedStorageContainment.None))
 133                 return null;
 134
 135             return intersection;
 136         }
 137
 138         public override IPermission Copy()
 139         {
 140             IsolatedStorageFilePermission copy ;
 141             copy = new IsolatedStorageFilePermission(PermissionState.Unrestricted);
 142             if(!IsUnrestricted()){
 143                 copy.m_userQuota = m_userQuota;
 144                 copy.m_machineQuota = m_machineQuota;
 145                 copy.m_expirationDays = m_expirationDays;
 146                 copy.m_permanentData = m_permanentData;
 147                 copy.m_allowed = m_allowed;
 148             }
 149             return copy;
 150         }
 151
 152
 153         /// <internalonly/>
 154         int IBuiltInPermission.GetTokenIndex()
 155         {
 156             return IsolatedStorageFilePermission.GetTokenIndex();
 157         }
 158
 159         internal static int GetTokenIndex()
 160         {
 161             return BuiltInPermissionIndex.IsolatedStorageFilePermissionIndex;
 162         }
 163
 164         //------------------------------------------------------
 165         //
 166         // IsolatedStoragePermission OVERRIDES
 167         //
 168         //------------------------------------------------------
 169 #if FEATURE_CAS_POLICY
 170         [System.Runtime.InteropServices.ComVisible(false)]
 171         public override SecurityElement ToXml()
 172         {
 173             return base.ToXml( "System.Security.Permissions.IsolatedStorageFilePermission" );
 174         }
 175 #endif // FEATURE_CAS_POLICY
 176     }
 177 }
 178