IsolatedStoragePermission.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ FX-1434 / FX-1434 / 1.0 / untmp / whidbey / REDBITS / ndp / clr / src / BCL / System / Security / Permissions / IsolatedStoragePermission.cs / 1 / IsolatedStoragePermission.cs

                            // ==++== 
//
//   Copyright (c) Microsoft Corporation.  All rights reserved.
//
// ==--== 

namespace System.Security.Permissions { 
 
    using System;
    using System.IO; 
    using System.Security;
    using System.Security.Util;
    using System.Globalization;
 
    [Serializable]
[System.Runtime.InteropServices.ComVisible(true)] 
    public enum IsolatedStorageContainment { 
        None                                    = 0x00,
        DomainIsolationByUser                   = 0x10, 
        ApplicationIsolationByUser              = 0x15,
        AssemblyIsolationByUser                 = 0x20,
        DomainIsolationByMachine                = 0x30,
        AssemblyIsolationByMachine              = 0x40, 
        ApplicationIsolationByMachine          = 0x45,
        DomainIsolationByRoamingUser            = 0x50, 
        AssemblyIsolationByRoamingUser          = 0x60, 
        ApplicationIsolationByRoamingUser          = 0x65,
        AdministerIsolatedStorageByUser         = 0x70, 
        //AdministerIsolatedStorageByMachine    = 0x80,
        UnrestrictedIsolatedStorage             = 0xF0
    };
 

    [Serializable, SecurityPermissionAttribute( SecurityAction.InheritanceDemand, ControlEvidence = true, ControlPolicy = true )] 
[System.Runtime.InteropServices.ComVisible(true)] 
    abstract public class IsolatedStoragePermission
           : CodeAccessPermission, IUnrestrictedPermission 
    {

        //------------------------------------------------------
        // 
        // PRIVATE STATE DATA
        // 
        //----------------------------------------------------- 

        ///  
        internal long m_userQuota;
        /// 
        internal long m_machineQuota;
        ///  
        internal long m_expirationDays;
        ///  
        internal bool m_permanentData; 
        /// 
        internal IsolatedStorageContainment m_allowed; 

        //-----------------------------------------------------
        //
        // CONSTRUCTORS 
        //
        //----------------------------------------------------- 
 
        protected IsolatedStoragePermission(PermissionState state)
        { 
            if (state == PermissionState.Unrestricted)
            {
                m_userQuota = Int64.MaxValue;
                m_machineQuota = Int64.MaxValue; 
                m_expirationDays = Int64.MaxValue ;
                m_permanentData = true; 
                m_allowed = IsolatedStorageContainment.UnrestrictedIsolatedStorage; 
            }
            else if (state == PermissionState.None) 
            {
                m_userQuota = 0;
                m_machineQuota = 0;
                m_expirationDays = 0; 
                m_permanentData = false;
                m_allowed = IsolatedStorageContainment.None; 
            } 
            else
            { 
                throw new ArgumentException(Environment.GetResourceString("Argument_InvalidPermissionState"));
            }
        }
 
        internal IsolatedStoragePermission(IsolatedStorageContainment UsageAllowed,
            long ExpirationDays, bool PermanentData) 
 
        {
                m_userQuota = 0;    // typical demand won't include quota 
                m_machineQuota = 0; // typical demand won't include quota
                m_expirationDays = ExpirationDays;
                m_permanentData = PermanentData;
                m_allowed = UsageAllowed; 
        }
 
        internal IsolatedStoragePermission(IsolatedStorageContainment UsageAllowed, 
            long ExpirationDays, bool PermanentData, long UserQuota)
 
        {
                m_machineQuota = 0;
                m_userQuota = UserQuota;
                m_expirationDays = ExpirationDays; 
                m_permanentData = PermanentData;
                m_allowed = UsageAllowed; 
        } 

 
        //------------------------------------------------------
        //
        // PUBLIC ACCESSOR METHODS
        // 
        //-----------------------------------------------------
 
        // properties 
        public long UserQuota {
            set{ 
                m_userQuota = value;
            }
            get{
                return m_userQuota; 
            }
        } 
 
#if false
        internal long MachineQuota { 
            set{
                m_machineQuota = value;
            }
            get{ 
                return m_machineQuota;
            } 
        } 
        internal long ExpirationDays {
            set{ 
                m_expirationDays = value;
            }
            get{
                return m_expirationDays; 
            }
        } 
        internal bool PermanentData { 
            set{
                m_permanentData = value; 
            }
            get{
                return m_permanentData;
            } 
        }
#endif 
 
        public IsolatedStorageContainment UsageAllowed {
            set{ 
                m_allowed = value;
            }
            get{
                return m_allowed; 
            }
        } 
 

        //------------------------------------------------------ 
        //
        // CODEACCESSPERMISSION IMPLEMENTATION
        //
        //------------------------------------------------------ 

        public bool IsUnrestricted() 
        { 
            return m_allowed == IsolatedStorageContainment.UnrestrictedIsolatedStorage;
        } 


        //-----------------------------------------------------
        // 
        // INTERNAL METHODS
        // 
        //------------------------------------------------------ 
        internal static long min(long x,long y) {return x>y?y:x;}
        internal static long max(long x,long y) {return x0)
                { 
                    esd.AddAttribute(_strUserQuota, (m_userQuota).ToString(CultureInfo.InvariantCulture)) ; 
                }
                if (m_machineQuota>0) 
                {
                    esd.AddAttribute(_strMachineQuota, (m_machineQuota).ToString(CultureInfo.InvariantCulture)) ;
                }
                if (m_expirationDays>0) 
                {
                    esd.AddAttribute( _strExpiry, (m_expirationDays).ToString(CultureInfo.InvariantCulture)) ; 
                } 
                if (m_permanentData)
                { 
                    esd.AddAttribute(_strPermDat, (m_permanentData).ToString()) ;
                }
            }
            else 
            {
                esd.AddAttribute( "Unrestricted", "true" ); 
            } 
            return esd;
        } 


        public override void FromXml(SecurityElement esd)
        { 
            CodeAccessPermission.ValidateElement( esd, this );
 
            m_allowed = IsolatedStorageContainment.None;    // default if no match 

            if (XMLUtil.IsUnrestricted(esd)) 
            {
                m_allowed = IsolatedStorageContainment.UnrestrictedIsolatedStorage;
            }
            else 
            {
                String allowed = esd.Attribute( "Allowed" ); 
 
                if (allowed != null)
                    m_allowed = (IsolatedStorageContainment)Enum.Parse( typeof( IsolatedStorageContainment ), allowed ); 
            }

            if (m_allowed == IsolatedStorageContainment.UnrestrictedIsolatedStorage)
            { 
                m_userQuota = Int64.MaxValue;
                m_machineQuota = Int64.MaxValue; 
                m_expirationDays = Int64.MaxValue ; 
                m_permanentData = true;
            } 
            else
            {
                String param;
                param = esd.Attribute (_strUserQuota) ; 
                m_userQuota = param != null ? Int64.Parse(param, CultureInfo.InvariantCulture) : 0 ;
                param = esd.Attribute (_strMachineQuota) ; 
                m_machineQuota = param != null ? Int64.Parse(param, CultureInfo.InvariantCulture) : 0 ; 
                param = esd.Attribute (_strExpiry) ;
                m_expirationDays = param != null ? Int64.Parse(param, CultureInfo.InvariantCulture) : 0 ; 
                param = esd.Attribute (_strPermDat) ;
                m_permanentData = param != null ? (Boolean.Parse(param)) : false ;
            }
        } 
    }
}
                        

Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK