SecurityHeader.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 / Security / SecurityHeader.cs / 1 / SecurityHeader.cs
                        

                        
                            //---------------------------------------------------------- 
// Copyright (c) Microsoft Corporation.  All rights reserved.
//-----------------------------------------------------------

namespace System.ServiceModel.Security 
{
    using System.Globalization; 
    using System.ServiceModel.Channels; 
    using System.ServiceModel;
    using System.ServiceModel.Description; 
    using System.Xml;

    using DictionaryManager = System.IdentityModel.DictionaryManager;
    using ISecurityElement = System.IdentityModel.ISecurityElement; 

    abstract class SecurityHeader : MessageHeader 
    { 
        readonly string actor;
        readonly SecurityAlgorithmSuite algorithmSuite; 
        bool encryptedKeyContainsReferenceList = true;
        Message message;
        readonly bool mustUnderstand;
        readonly bool relay; 
        bool requireMessageProtection = true;
        bool processingStarted; 
        bool maintainSignatureConfirmationState; 
        readonly SecurityStandardsManager standardsManager;
        MessageDirection transferDirection; 
        SecurityHeaderLayout layout = SecurityHeaderLayout.Strict;

        public SecurityHeader(Message message,
            string actor, bool mustUnderstand, bool relay, 
            SecurityStandardsManager standardsManager, SecurityAlgorithmSuite algorithmSuite,
            MessageDirection transferDirection) 
        { 
            if (message == null)
            { 
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("message");
            }
            if (actor == null)
            { 
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("actor");
            } 
            if (standardsManager == null) 
            {
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("standardsManager"); 
            }
            if (algorithmSuite == null)
            {
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("algorithmSuite"); 
            }
 
            this.message = message; 
            this.actor = actor;
            this.mustUnderstand = mustUnderstand; 
            this.relay = relay;
            this.standardsManager = standardsManager;
            this.algorithmSuite = algorithmSuite;
            this.transferDirection = transferDirection; 
        }
 
        public override string Actor 
        {
            get { return this.actor; } 
        }

        public SecurityAlgorithmSuite AlgorithmSuite
        { 
            get { return this.algorithmSuite; }
        } 
 
        public bool EncryptedKeyContainsReferenceList
        { 
            get { return this.encryptedKeyContainsReferenceList; }
            set
            {
                ThrowIfProcessingStarted(); 
                this.encryptedKeyContainsReferenceList = value;
            } 
        } 

        public bool RequireMessageProtection 
        {
            get { return this.requireMessageProtection; }
            set
            { 
                ThrowIfProcessingStarted();
                this.requireMessageProtection = value; 
            } 
        }
 
        public bool MaintainSignatureConfirmationState
        {
            get { return this.maintainSignatureConfirmationState; }
            set 
            {
                ThrowIfProcessingStarted(); 
                this.maintainSignatureConfirmationState = value; 
            }
        } 

        protected Message Message
        {
            get { return this.message; } 
            set { this.message = value; }
        } 
 
        public override bool MustUnderstand
        { 
            get { return this.mustUnderstand; }
        }

        public override bool Relay 
        {
            get { return this.relay; } 
        } 

        public SecurityHeaderLayout Layout 
        {
            get
            {
                return this.layout; 
            }
            set 
            { 
                ThrowIfProcessingStarted();
                this.layout = value; 
            }
        }

        public SecurityStandardsManager StandardsManager 
        {
            get { return this.standardsManager; } 
        } 

        public MessageDirection MessageDirection 
        {
            get { return this.transferDirection; }
        }
 
        protected MessageVersion Version
        { 
            get { return this.message.Version; } 
        }
 
        protected void SetProcessingStarted()
        {
            this.processingStarted = true;
        } 

        protected void ThrowIfProcessingStarted() 
        { 
            if (this.processingStarted)
            { 
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.OperationCannotBeDoneAfterProcessingIsStarted)));
            }
        }
 
        public override string ToString()
        { 
            return string.Format(CultureInfo.InvariantCulture, "{0}(Actor = '{1}')", GetType().Name, this.Actor); 
        }
    } 
}

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