ProtectedUri.cs source code in C# .NET

Source code for the .NET framework in C#

                        
Code:

                         / DotNET / DotNET / 8.0 / untmp / WIN_WINDOWS / lh_tools_devdiv_wpf / Windows / wcp / Framework / MS / Internal / Utility / ProtectedUri.cs / 2 / ProtectedUri.cs
                        

                        
                            //------------------------------------------------------------------------------ 
//  Microsoft Avalon
//  Copyright (c) Microsoft Corporation, 2001
//
//  File:           protecteduri.cs 
//
//  Description:    Secure wrapper for URIs containing path information 
// 
//  History:        12-02-04 - [....] - created
//----------------------------------------------------------------------------- 
using System;
using System.IO;
using System.ComponentModel;
using System.Windows; 
using System.Windows.Navigation;
using System.Windows.Media; 
 
using System.Diagnostics;
using System.Globalization; 
using System.Security.Permissions;
using System.IO.Packaging;
using MS.Internal.AppModel;
using System.Windows.Controls; 
using MS.Internal ;
using MS.Internal.PresentationFramework;                   // SecurityHelper 
using System.Security; 

namespace MS.Internal.Utility 
{
    /// 
    /// Wrapper class for URIs containing path information.
    ///  
    internal class ProtectedUri
    { 
        ///  
        /// Original URI which should *not* contain path information ever
        ///  
        Uri _originalUri;
        /// 
        /// URI that may contain path information
        ///  
        /// 
        /// Critical - may contain path information 
        ///  
        [SecurityCritical]
        Uri _value; 
        /// 
        /// Determines if _value contains path information
        /// 
        ///  
        /// Critical - determines if _value contains path information, which
        ///            in turn determines if we demand a permission to get access 
        ///            to _value. 
        /// 
        [SecurityCritical] 
        bool _containsPathInformation;

        /// 
        /// Creates a ProtectedUri that contains no path information 
        /// 
        /// Safe URI (generally provided from user code) 
        /// Protected wrapper 
        /// 
        /// Critical - because the caller of this API needs to ensure that  
        ///            contains no critical information, this API is critical.
        /// 
        [SecurityCritical]
        internal static ProtectedUri FromSafeUri(Uri value) 
        {
            if (value == null) throw new ArgumentNullException("value"); 
            ProtectedUri wrapper = new ProtectedUri(); 
            wrapper._value = wrapper._originalUri = value;
            wrapper._containsPathInformation = false; 
            return wrapper;
        }

        ///  
        /// Returns the "full" URI (may contain path information>
        ///  
        ///  
        ///     There is currently no "safeUri" property on this class,
        ///     however you could write one if there is a need. Look at SD history for an example. 
        /// 
        /// 
        /// Critical - deals with full URI
        /// TreatAsSafe - demands PathDiscovery if the URI is tagged as having path information 
        /// 
        internal Uri UnsafeUri 
        { 
            [SecurityCritical, SecurityTreatAsSafe]
            get 
            {
                if (_containsPathInformation)
                {
                    SecurityHelper.DemandPathDiscovery(_value.LocalPath); 
                }
                return _value; 
            } 
        }
 
        /// 
        /// Returns the hashcode associated with the URI
        /// 
        /// hashcode associated with the URI 
        /// 
        /// Critical - access the full URI 
        ///  
        [SecurityCritical]
        public override int GetHashCode() 
        {
            return _value.GetHashCode();
        }
 
        /// 
        /// Determines if this wraps the same uri as another protected URI 
        ///  
        /// ProtectedURI to compare to.
        /// true if the objects are equal 
        /// 
        /// Critical - access the full URI
        /// 
        [SecurityCritical] 
        public override bool Equals(object other)
        { 
            ProtectedUri otherUri = other as ProtectedUri; 
            return (otherUri != null)
                && (this._value.Equals(otherUri._value)) 
                && (this._containsPathInformation.Equals(otherUri._containsPathInformation));
        }
    }
} 

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.

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