Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

mcs/class/referencesource/System.Net/net/PeerToPeer/Collaboration/CollaborationEnumTypes.cs

@@ -0,0 +1,73 @@
+//------------------------------------------------------------------------------
+// <copyright file="CollabEnumTypes.cs" company="Microsoft">
+//     Copyright (c) Microsoft Corporation.  All rights reserved.
+// </copyright>                                                                
+//------------------------------------------------------------------------------
+
+namespace System.Net.PeerToPeer.Collaboration
+{
+    //
+    // Defines all the enums used by peer collaboration
+    //
+
+    public enum PeerPresenceStatus
+    {
+        Offline = 0,
+        OutToLunch,
+        Away,
+        BeRightBack,
+        Idle,
+        Busy,
+        OnThePhone,
+        Online
+    }
+
+    public enum PeerScope
+    {
+        None = 0,
+        NearMe,
+        Internet,
+        All = NearMe | Internet
+    }
+
+    public enum PeerApplicationRegistrationType
+    {
+        CurrentUser = 0,
+        AllUsers
+    }
+
+    public enum PeerInvitationResponseType
+    {
+        Declined = 0,
+        Accepted,
+        Expired
+    }
+
+    public enum PeerChangeType
+    {
+        Added = 0,
+        Deleted,
+        Updated
+    }
+    
+    public enum SubscriptionType
+    {
+        Blocked = 0,
+        Allowed
+    }
+
+    internal enum PeerCollabEventType
+    {
+        WatchListChanged = 1,
+        EndPointChanged = 2,
+        EndPointPresenceChanged = 3,
+        EndPointApplicationChanged = 4,
+        EndPointObjectChanged = 5,
+        MyEndPointChanged = 6,
+        MyPresenceChanged = 7,
+        MyApplicationChanged = 8,
+        MyObjectChanged = 9,
+        PeopleNearMeChanged = 10,
+        RequestStatusChanged = 11
+    }
+}

mcs/class/referencesource/System.Net/net/PeerToPeer/Collaboration/PeerApplicationLaunchInfo.cs

@@ -0,0 +1,76 @@
+//------------------------------------------------------------------------------
+// <copyright file="PeerApplicationLaunchInfo.cs" company="Microsoft">
+//     Copyright (c) Microsoft Corporation.  All rights reserved.
+// </copyright>                                                                
+//------------------------------------------------------------------------------
+
+namespace System.Net.PeerToPeer.Collaboration
+{
+    using System;
+
+    /// <summary>
+    /// Represents launch info that collab gives back for the running application.
+    /// If this application has been started up via collab invitation then it gives 
+    /// back the details of that invitation.
+    /// </summary>
+    public class PeerApplicationLaunchInfo
+    {
+        private PeerContact m_peerContact;
+        private PeerEndPoint m_peerEndPoint;
+        private PeerApplication m_peerApplication;
+        private byte[] m_inviteData;
+        private string m_message;
+
+        internal PeerApplicationLaunchInfo() { }
+
+        public PeerContact PeerContact
+        {
+            get{
+                return m_peerContact;
+            }
+            internal set{
+                m_peerContact = value;
+            }
+        }
+
+        public PeerEndPoint PeerEndPoint
+        {
+            get{
+                return m_peerEndPoint;
+            }
+            internal set{
+                m_peerEndPoint = value;
+            }
+        }
+
+        public PeerApplication PeerApplication
+        {
+            get{
+                return m_peerApplication;
+            }
+            internal set{
+                m_peerApplication = value;
+            }
+        }
+
+        public byte[] Data
+        {
+            get{
+                return m_inviteData;
+            }
+            internal set{
+                m_inviteData = value;
+            }
+        }
+
+        public string Message
+        {
+            get{
+                return m_message;
+            }
+            internal set{
+                m_message = value;
+            }
+        }
+    }
+}

mcs/class/referencesource/System.Net/net/PeerToPeer/Collaboration/PeerCollaborationPermission.cs

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

mcs/class/referencesource/System.Net/net/PeerToPeer/Collaboration/PeerInvitationResponse.cs

@@ -0,0 +1,25 @@
+using System;
+
+namespace System.Net.PeerToPeer.Collaboration
+{
+    public class PeerInvitationResponse
+    {
+        private PeerInvitationResponseType m_peerInvResponseType;
+
+        internal PeerInvitationResponse() { }
+        internal PeerInvitationResponse(PeerInvitationResponseType reponseType) 
+        {
+            m_peerInvResponseType = reponseType;
+        }
+
+        public PeerInvitationResponseType PeerInvitationResponseType
+        {
+            get{
+                return m_peerInvResponseType;
+            }
+            internal set{
+                m_peerInvResponseType = value;
+            }
+        }
+    }
+}

mcs/class/referencesource/System.Net/net/PeerToPeer/Collaboration/PeerPresenceInfo.cs

@@ -0,0 +1,48 @@
+//------------------------------------------------------------------------------
+// <copyright file="PeerPresenceInfo.cs" company="Microsoft">
+//     Copyright (c) Microsoft Corporation.  All rights reserved.
+// </copyright>                                                                
+//------------------------------------------------------------------------------
+
+namespace System.Net.PeerToPeer.Collaboration
+{
+    using System;
+
+    /// <summary>
+    /// Encapsulates the presence information for a collab peer
+    /// </summary>
+    public class PeerPresenceInfo
+    {
+        private PeerPresenceStatus m_peerPresenceStatus;
+        private string m_descriptiveText;
+
+        public PeerPresenceInfo() {}
+
+        public PeerPresenceInfo(PeerPresenceStatus presenceStatus, string description) {
+            m_peerPresenceStatus = presenceStatus;
+            m_descriptiveText = description;
+        }
+
+        public PeerPresenceStatus PresenceStatus
+        {
+            get{
+                return m_peerPresenceStatus;
+            }
+            set
+            {
+                m_peerPresenceStatus = value;
+            }
+        }
+        public string DescriptiveText
+        {
+            get{
+                return m_descriptiveText;
+            }
+            set
+            {
+                m_descriptiveText = value;
+            }
+        }
+    }
+
+}