Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

mcs/class/referencesource/System.Net/net/PeerToPeer/PnrpPermission.cs

@@ -0,0 +1,190 @@
+//------------------------------------------------------------------------------
+// <copyright file="PnrpPermission.cs" company="Microsoft">
+//     Copyright (c) Microsoft Corporation.  All rights reserved.
+// </copyright>
+//------------------------------------------------------------------------------
+namespace System.Net.PeerToPeer
+{
+    using System.Security;
+    using System.Security.Permissions;
+    using System.Globalization;
+
+    /// <remarks>
+    /// PnrpPermission atrribute
+    /// </remarks>
+    [AttributeUsage(AttributeTargets.Method | AttributeTargets.Constructor |
+                     AttributeTargets.Class | AttributeTargets.Struct |
+                     AttributeTargets.Assembly,
+                     AllowMultiple = true, Inherited = false)]
+    [Serializable()]
+    public sealed class PnrpPermissionAttribute : CodeAccessSecurityAttribute
+    {
+        /// <summary>
+        /// Just call base constructor
+        /// </summary>
+        /// <param name="action"></param>
+        public PnrpPermissionAttribute(SecurityAction action) : base(action) { }
+
+        /// <summary>
+        /// As required by the SecurityAttribute class. 
+        /// </summary>
+        /// <returns></returns>
+        public override IPermission CreatePermission() {
+            if (Unrestricted) {
+                return new PnrpPermission(PermissionState.Unrestricted);
+            }
+            else {
+                return new PnrpPermission(PermissionState.None);
+            }
+        }
+    }
+
+    /// <remarks>
+    /// Currently we only support two levels - Unrestrictred or none
+    /// </remarks>
+    [Serializable]
+    public sealed class PnrpPermission : CodeAccessPermission, IUnrestrictedPermission
+    {
+        private bool m_noRestriction;
+
+        internal static readonly PnrpPermission UnrestrictedPnrpPermission = new PnrpPermission(PermissionState.Unrestricted);
+
+        /// <summary>
+        ///    <para>
+        ///       Creates a new instance of the <see cref='System.Net.PeerToPeer.PnrpPermission'/>
+        ///       class that passes all demands or that fails all demands.
+        ///    </para>
+        /// </summary>
+        public PnrpPermission(PermissionState state)
+        {
+            m_noRestriction = (state == PermissionState.Unrestricted);
+        }
+
+        internal PnrpPermission(bool free)
+        {
+            m_noRestriction = free;
+        }
+
+        // IUnrestrictedPermission interface methods
+        /// <summary>
+        ///    <para>
+        ///       Checks the overall permission state of the object.
+        ///    </para>
+        /// </summary>
+        public bool IsUnrestricted()
+        {
+            return m_noRestriction;
+        }
+
+        // IPermission interface methods
+        /// <summary>
+        ///    <para>
+        ///       Creates a copy of a <see cref='System.Net.PeerToPeer.PnrpPermission'/> instance.
+        ///    </para>
+        /// </summary>
+        public override IPermission Copy()
+        {
+            return new PnrpPermission(m_noRestriction);
+        }
+
+        /// <summary>
+        /// <para>Returns the logical union between two <see cref='System.Net.PeerToPeer.PnrpPermission'/> instances.</para>
+        /// </summary>
+        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);
+        }
+
+        /// <summary>
+        /// <para>Returns the logical intersection between two <see cref='System.Net.PeerToPeer.PnrpPermission'/> instances.</para>
+        /// </summary>
+        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;
+        }
+
+
+        /// <summary>
+        /// <para>Compares two <see cref='System.Net.PeerToPeer.PnrpPermission'/> instances.</para>
+        /// </summary>
+        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);
+        }
+
+        /// <summary>
+        /// Cinstrcy from a security element
+        /// </summary>
+        /// <param name="securityElement"></param>
+        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);
+        }
+
+        /// <summary>
+        /// Copyto a security element 
+        /// </summary>
+        /// <returns></returns>
+        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