PartialTrustValidationBehavior.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ WCF / WCF / 3.5.30729.1 / untmp / Orcas / SP / ndp / cdf / src / WCF / ServiceModel / System / ServiceModel / Dispatcher / PartialTrustValidationBehavior.cs / 1 / PartialTrustValidationBehavior.cs

                            //------------------------------------------------------------ 
// Copyright (c) Microsoft Corporation.  All rights reserved.
//-----------------------------------------------------------
namespace System.ServiceModel.Dispatcher
{ 
    using System.ServiceModel.Channels;
    using System.ServiceModel; 
    using System.ServiceModel.Description; 
    using System.Collections.ObjectModel;
    using System.Collections.Generic; 
    using System.Xml;
    using System.Security;
    using System.Security.Permissions;
    using System.ServiceModel.MsmqIntegration; 

    class PartialTrustValidationBehavior : IServiceBehavior, IEndpointBehavior 
    { 
        static PartialTrustValidationBehavior instance = null;
 
        internal static PartialTrustValidationBehavior Instance
        {
            get
            { 
                // no need to synchronize -- it's ok if two are created
                if (instance == null) 
                { 
                    instance = new PartialTrustValidationBehavior();
                } 
                return instance;
            }
        }
 
        void ValidateEndpoint(ServiceEndpoint endpoint)
        { 
            Binding binding = endpoint.Binding; 
            if (binding != null)
            { 
                new BindingValidator(endpoint.Binding).Validate();
            }
        }
 
        #region IEndpointBehavior Members
 
        void IEndpointBehavior.Validate(ServiceEndpoint endpoint) 
        {
            if (endpoint == null) 
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("endpoint");

            ValidateEndpoint(endpoint);
        } 

        void IEndpointBehavior.AddBindingParameters(ServiceEndpoint endpoint, BindingParameterCollection bindingParameters) { } 
        void IEndpointBehavior.ApplyDispatchBehavior(ServiceEndpoint endpoint, EndpointDispatcher endpointDispatcher) { } 
        void IEndpointBehavior.ApplyClientBehavior(ServiceEndpoint endpoint, ClientRuntime clientRuntime) { }
 
        #endregion

        #region IServiceBehavior Members
 
        public void Validate(ServiceDescription description, ServiceHostBase serviceHostBase)
        { 
            if (description == null) 
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("description");
            for (int i = 0; i < description.Endpoints.Count; i++) 
            {
                ServiceEndpoint endpoint = description.Endpoints[i];
                if (endpoint != null)
                { 
                    ValidateEndpoint(endpoint);
                } 
            } 
        }
 
        public void AddBindingParameters(ServiceDescription serviceDescription, ServiceHostBase serviceHostBase, Collection endpoints, BindingParameterCollection bindingParameters) { }
        public void ApplyDispatchBehavior(ServiceDescription serviceDescription, ServiceHostBase serviceHostBase) { }

        #endregion 

        struct BindingValidator 
        { 
            static Type[] unsupportedBindings = new Type[]
            { 
                typeof(NetTcpBinding),
                typeof(NetNamedPipeBinding),
                typeof(WSDualHttpBinding),
                typeof(WS2007FederationHttpBinding), 
                typeof(WSFederationHttpBinding),
                typeof(NetMsmqBinding), 
                typeof(NetPeerTcpBinding), 
                typeof(MsmqIntegrationBinding),
            }; 

            static Type[] unsupportedBindingElements = new Type[]
            {
                typeof(AsymmetricSecurityBindingElement), 
                typeof(CompositeDuplexBindingElement),
                typeof(MsmqTransportBindingElement), 
                typeof(NamedPipeTransportBindingElement), 
                typeof(OneWayBindingElement),
                typeof(PeerCustomResolverBindingElement), 
                typeof(PeerTransportBindingElement),
                typeof(PnrpPeerResolverBindingElement),
                typeof(ReliableSessionBindingElement),
                typeof(SymmetricSecurityBindingElement), 
                typeof(TcpTransportBindingElement),
                typeof(TransportSecurityBindingElement), 
                typeof(MtomMessageEncodingBindingElement), 
            };
 
            Binding binding;
            internal BindingValidator(Binding binding)
            {
                this.binding = binding; 
            }
 
            internal void Validate() 
            {
                System.Diagnostics.Debug.Assert(binding != null, "BindingValidator was not constructed with a valid Binding instance"); 

                Type bindingType = binding.GetType();
                if (IsUnsupportedBindingType(bindingType))
                { 
                    UnsupportedSecurityCheck(SR.FullTrustOnlyBindingSecurityCheck1, bindingType);
                } 
 
                // special-case error message for WSHttpBindings
                bool isWSHttpBinding = typeof(WSHttpBinding).IsAssignableFrom(bindingType); 
                string sr = isWSHttpBinding ? SR.FullTrustOnlyBindingElementSecurityCheckWSHttpBinding1 : SR.FullTrustOnlyBindingElementSecurityCheck1;

                BindingElementCollection elements = binding.CreateBindingElements();
                foreach (BindingElement element in elements) 
                {
                    Type bindingElementType = element.GetType(); 
                    if (element != null && IsUnsupportedBindingElementType(bindingElementType)) 
                    {
                        UnsupportedSecurityCheck(sr, bindingElementType); 
                    }
                }
            }
 
            bool IsUnsupportedBindingType(Type bindingType)
            { 
                for (int i = 0; i < unsupportedBindings.Length; i++) 
                {
                    if (unsupportedBindings[i] == bindingType) 
                        return true;
                }
                return false;
            } 

            bool IsUnsupportedBindingElementType(Type bindingElementType) 
            { 
                for (int i = 0; i < unsupportedBindingElements.Length; i++)
                { 
                    if (unsupportedBindingElements[i] == bindingElementType)
                        return true;
                }
                return false; 
            }
 
            static readonly PermissionSet fullTrust = new PermissionSet(PermissionState.Unrestricted); 
            void UnsupportedSecurityCheck(string resource, Type type)
            { 
                try
                {
                    fullTrust.Demand();
                } 
                catch (SecurityException)
                { 
                    throw new InvalidOperationException(SR.GetString(resource, binding.Name, type)); 
                }
            } 

        }
    }
 
}

// 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