Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

mcs/class/referencesource/System.ServiceModel/System/ServiceModel/Security/SecurityHeader.cs

@@ -0,0 +1,164 @@
+//----------------------------------------------------------
+// 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);
+        }
+    }
+}