PeerCollaborationPermission.cs source code in C# .NET

                        Code:
                         / 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / SystemNet / Net / PeerToPeer / Collaboration / PeerCollaborationPermission.cs / 1305376 / PeerCollaborationPermission.cs
                        
                        
                            //------------------------------------------------------------------------------ 
// 
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// 
//----------------------------------------------------------------------------- 

namespace System.Net.PeerToPeer.Collaboration 
{ 
    using System.Security;
    using System.Security.Permissions; 
    using System.Globalization;

    /// 
    /// PeerCollaborationPermissionAttribute atrribute 
    /// 
    [AttributeUsage(AttributeTargets.Method | AttributeTargets.Constructor | 
                     AttributeTargets.Class | AttributeTargets.Struct | 
                     AttributeTargets.Assembly,
                     AllowMultiple = true, Inherited = false)] 
    [Serializable()]
    public sealed class PeerCollaborationPermissionAttribute : CodeAccessSecurityAttribute
    {
        ///  
        /// Just call base constructor
        ///  
        ///  
        public PeerCollaborationPermissionAttribute(SecurityAction action) : base(action) { }
 
        /// 
        /// As required by the SecurityAttribute class.
        /// 
        ///  
        public override IPermission CreatePermission()
        { 
            if (Unrestricted){ 
                return new PeerCollaborationPermission(PermissionState.Unrestricted);
            } 
            else{
                return new PeerCollaborationPermission(PermissionState.None);
            }
        } 
    }
 
    ///  
    /// Currently we only support two levels - Unrestrictred or none
    ///  
    [Serializable]
    public sealed class PeerCollaborationPermission : CodeAccessPermission, IUnrestrictedPermission
    {
        private bool m_noRestriction; 

        internal static readonly PeerCollaborationPermission UnrestrictedPeerCollaborationPermission = 
            new PeerCollaborationPermission(PermissionState.Unrestricted); 

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

        internal PeerCollaborationPermission(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() 
        { 
            if (m_noRestriction)
                return new PeerCollaborationPermission(true); 
            else
                return new PeerCollaborationPermission(false);
        }
 
        /// 
        /// Returns the logical union between two  instances. 
        ///  
        public override IPermission Union(IPermission target)
        { 
            // Pattern suggested by Security engine
            if (target == null){
                return this.Copy();
            } 
            PeerCollaborationPermission other = target as PeerCollaborationPermission;
            if (other == null){ 
                throw new ArgumentException(SR.GetString(SR.Collab_PermissionUnionError), "target"); 
            }
            return new PeerCollaborationPermission(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;
            }

            PeerCollaborationPermission other = target as PeerCollaborationPermission; 
            if (other == null){
                throw new ArgumentException(SR.GetString(SR.Collab_PermissionIntersectError), "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 PeerCollaborationPermission(true);
            } 
            return null;
        } 
 

        ///  
        /// Compares two  instances.
        /// 
        public override bool IsSubsetOf(IPermission target)
        { 
            // Pattern suggested by Security engine
            if (target == null){ 
                return m_noRestriction == false; 
            }
 
            PeerCollaborationPermission other = target as PeerCollaborationPermission;
            if (other == null){
                throw new ArgumentException(SR.GetString(SR.Collab_BadPermissionTarget), "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);
        } 

        ///  
        /// Copy from a security element 
        /// 
        ///  
        public override void FromXml(SecurityElement e)
        {
            if (e == null){
                throw new ArgumentNullException("e"); 
            }
 
            // SecurityElement must be a permission element 
            if (!e.Tag.Equals("IPermission"))
            { 
                throw new ArgumentException(SR.GetString(SR.InvalidSecurityElem), "e");
            }
            string className = e.Attribute("class");
            // SecurityElement must be a permission element for this type 
            if (className == null){
                throw new ArgumentException(SR.GetString(SR.InvalidSecurityElemNoClass), "e"); 
            } 

            if (className.IndexOf(this.GetType().FullName, StringComparison.Ordinal) < 0){ 
                throw new ArgumentException(SR.GetString(SR.InvalidSecurityElemNoType), "e");
            }
            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;
        }
    } 
}

// 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
PeerCollaborationPermission.cs source code in C# .NET

Source code for the .NET framework in C#

Code:

Link Menu
