PnrpPermission.cs source code in C# .NET

                        Code:
                         / 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / SystemNet / Net / PeerToPeer / PnrpPermission.cs / 1305376 / PnrpPermission.cs
                        
                        
                            //------------------------------------------------------------------------------ 
// 
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// 
//----------------------------------------------------------------------------- 
namespace System.Net.PeerToPeer
{ 
    using System.Security; 
    using System.Security.Permissions;
    using System.Globalization; 

    /// 
    /// PnrpPermission atrribute
    ///  
    [AttributeUsage(AttributeTargets.Method | AttributeTargets.Constructor |
                     AttributeTargets.Class | AttributeTargets.Struct | 
                     AttributeTargets.Assembly, 
                     AllowMultiple = true, Inherited = false)]
    [Serializable()] 
    public sealed class PnrpPermissionAttribute : CodeAccessSecurityAttribute
    {
        /// 
        /// Just call base constructor 
        /// 
        ///  
        public PnrpPermissionAttribute(SecurityAction action) : base(action) { } 

        ///  
        /// As required by the SecurityAttribute class.
        /// 
        /// 
        public override IPermission CreatePermission() { 
            if (Unrestricted) {
                return new PnrpPermission(PermissionState.Unrestricted); 
            } 
            else {
                return new PnrpPermission(PermissionState.None); 
            }
        }
    }
 
    /// 
    /// Currently we only support two levels - Unrestrictred or none 
    ///  
    [Serializable]
    public sealed class PnrpPermission : CodeAccessPermission, IUnrestrictedPermission 
    {
        private bool m_noRestriction;

        internal static readonly PnrpPermission UnrestrictedPnrpPermission = new PnrpPermission(PermissionState.Unrestricted); 

        ///  
        ///     
        ///       Creates a new instance of the 
        ///       class that passes all demands or that fails all demands. 
        ///    
        /// 
        public PnrpPermission(PermissionState state)
        { 
            m_noRestriction = (state == PermissionState.Unrestricted);
        } 
 
        internal PnrpPermission(bool free)
        { 
            m_noRestriction = free;
        }

        // IUnrestrictedPermission interface methods 
        /// 
        ///     
        ///       Checks the overall permission state of the object. 
        ///    
        ///  
        public bool IsUnrestricted()
        {
            return m_noRestriction;
        } 

        // IPermission interface methods 
        ///  
        ///    
        ///       Creates a copy of a  instance. 
        ///    
        /// 
        public override IPermission Copy()
        { 
            return new PnrpPermission(m_noRestriction);
        } 
 
        /// 
        /// Returns the logical union between two  instances. 
        /// 
        public override IPermission Union(IPermission target)
        {
            // Pattern suggested by Security engine 
            if (target == null) {
                return this.Copy(); 
            } 
            PnrpPermission other = target as PnrpPermission;
            if (other == null) { 
                throw new ArgumentException( SR.GetString(SR.PnrpPermission_CantUnionWithNonPnrpPermission), "target");
            }
            return new PnrpPermission(m_noRestriction || other.m_noRestriction);
        } 

        ///  
        /// Returns the logical intersection between two  instances. 
        /// 
        public override IPermission Intersect(IPermission target) 
        {
            // Pattern suggested by Security engine
            if (target == null) {
                return null; 
            }
            PnrpPermission other = target as PnrpPermission; 
            if (other == null) { 
                throw new ArgumentException(SR.GetString(SR.PnrpPermission_CantIntersectWithNonPnrpPermission), "target");
            } 
            // return null if resulting permission is restricted and empty
            // Hence, the only way for a bool permission will be.
            if (this.m_noRestriction && other.m_noRestriction) {
                return new PnrpPermission(true); 
            }
            return null; 
        } 

 
        /// 
        /// Compares two  instances.
        /// 
        public override bool IsSubsetOf(IPermission target) 
        {
            // Pattern suggested by Security engine 
            if (target == null)  { 
                return m_noRestriction == false;
            } 
            PnrpPermission other = target as PnrpPermission;
            if (other == null) {
                throw new ArgumentException(SR.GetString(SR.PnrpPermission_TargetNotAPnrpPermission), "target");
            } 
            //Here is the matrix of result based on m_noRestriction for me and she
            //    me.noRestriction      she.noRestriction   me.isSubsetOf(she) 
            //                  0       0                   1 
            //                  0       1                   1
            //                  1       0                   0 
            //                  1       1                   1
            return (!m_noRestriction || other.m_noRestriction);
        }
 
        /// 
        /// Cinstrcy from a security element 
        ///  
        /// 
        public override void FromXml(SecurityElement e) 
        {
            if (e == null) {
                throw new ArgumentNullException(SR.GetString(SR.InvalidSecurityElem));
            } 
            // SecurityElement must be a permission element
            if (!e.Tag.Equals("IPermission")) { 
                throw new ArgumentException(SR.GetString(SR.InvalidSecurityElem), "securityElement"); 
            }
            string className = e.Attribute("class"); 
            // SecurityElement must be a permission element for this type
            if (className == null) {
                throw new ArgumentException(SR.GetString(SR.InvalidSecurityElem), "securityElement");
            } 
            if (className.IndexOf(this.GetType().FullName, StringComparison.Ordinal) < 0) {
                throw new ArgumentException(SR.GetString(SR.InvalidSecurityElem), "securityElement"); 
            } 
            string str = e.Attribute("Unrestricted");
            m_noRestriction = (str != null ? (0 == string.Compare(str, "true", StringComparison.OrdinalIgnoreCase)) : false); 
        }

        /// 
        /// Copyto a security element 
        /// 
        ///  
        public override SecurityElement ToXml() 
        {
            SecurityElement securityElement = new SecurityElement("IPermission"); 
            securityElement.AddAttribute("class", this.GetType().FullName + ", " + this.GetType().Module.Assembly.FullName.Replace('\"', '\''));
            securityElement.AddAttribute("version", "1");
            if (m_noRestriction) {
                securityElement.AddAttribute("Unrestricted", "true"); 
            }
            return securityElement; 
        } 
    } // class PnrpPermission
} // namespace System.Net.PeerToPeer 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
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
PnrpPermission.cs source code in C# .NET

Source code for the .NET framework in C#

Code:

Link Menu
