Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

mcs/class/referencesource/System.ServiceModel/System/ServiceModel/Channels/ContextProtocol.cs

@@ -0,0 +1,147 @@
+//------------------------------------------------------------
+// Copyright (c) Microsoft Corporation.  All rights reserved.
+//------------------------------------------------------------
+
+namespace System.ServiceModel.Channels
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Xml;
+    using System.Net;
+    using System.IO;
+    using System.Text;
+    using System.Globalization;
+    using System.Runtime.Serialization;
+    using System.ServiceModel.Diagnostics;
+    using System.Diagnostics;
+
+    abstract class ContextProtocol
+    {
+        ContextExchangeMechanism contextExchangeMechanism;
+
+        protected ContextProtocol(ContextExchangeMechanism contextExchangeMechanism)
+        {
+            if (!ContextExchangeMechanismHelper.IsDefined(contextExchangeMechanism))
+            {
+                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("contextExchangeMechanism"));
+            }
+            this.contextExchangeMechanism = contextExchangeMechanism;
+        }
+
+        protected ContextExchangeMechanism ContextExchangeMechanism
+        {
+            get { return this.contextExchangeMechanism; }
+        }
+
+        public abstract void OnIncomingMessage(Message message);
+
+        public abstract void OnOutgoingMessage(Message message, RequestContext requestContext);
+
+        protected void OnSendSoapContextHeader(Message message, ContextMessageProperty context)
+        {
+            if (message == null)
+            {
+                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("message");
+            }
+            if (context == null)
+            {
+                throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("context");
+            }
+
+            if (context.Context.Count > 0)
+            {
+                message.Headers.Add(new ContextMessageHeader(context.Context));
+            }
+
+            if (DiagnosticUtility.ShouldTraceVerbose)
+            {
+                TraceUtility.TraceEvent(TraceEventType.Verbose, TraceCode.ContextProtocolContextAddedToMessage,
+                    SR.GetString(SR.TraceCodeContextProtocolContextAddedToMessage), this);
+            }
+        }
+
+        internal static class HttpCookieToolbox
+        {
+            public const string ContextHttpCookieName = "WscContext";
+            public const string RemoveContextHttpCookieHeader = ContextHttpCookieName + ";Max-Age=0";
+
+            public static string EncodeContextAsHttpSetCookieHeader(ContextMessageProperty context, Uri uri)
+            {
+                if (uri == null)
+                {
+                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("uri");
+                }
+                if (context == null)
+                {
+                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("context");
+                }
+
+                MemoryStream stream = new MemoryStream();
+                XmlWriterSettings writerSettings = new XmlWriterSettings();
+                writerSettings.OmitXmlDeclaration = true;
+                XmlWriter writer = XmlWriter.Create(stream, writerSettings);
+                ContextMessageHeader contextHeader = new ContextMessageHeader(context.Context);
+                contextHeader.WriteHeader(writer, MessageVersion.Default);
+                writer.Flush();
+
+                string result = string.Format(
+                    CultureInfo.InvariantCulture,
+                    "{0}=\"{1}\";Path={2}",
+                    HttpCookieToolbox.ContextHttpCookieName,
+                    Convert.ToBase64String(stream.GetBuffer(), 0, (int)stream.Length),
+                    uri.AbsolutePath);
+
+                return result;
+            }
+
+            public static bool TryCreateFromHttpCookieHeader(string httpCookieHeader, out ContextMessageProperty context)
+            {
+                if (httpCookieHeader == null)
+                {
+                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("httpCookieHeader");
+                }
+
+                context = null;
+
+                foreach (string token in httpCookieHeader.Split(';'))
+                {
+                    string trimmedToken = token.Trim();
+                    if (trimmedToken.StartsWith(HttpCookieToolbox.ContextHttpCookieName, StringComparison.Ordinal))
+                    {
+                        int equalsSignIndex = trimmedToken.IndexOf('=');
+                        if (equalsSignIndex < 0)
+                        {
+                            context = new ContextMessageProperty();
+                            break;
+                        }
+                        if (equalsSignIndex < (trimmedToken.Length - 1))
+                        {
+                            string value = trimmedToken.Substring(equalsSignIndex + 1).Trim();
+
+                            if (value.Length > 1 && (value[0] == '"') && (value[value.Length - 1] == '"'))
+                            {
+                                value = value.Substring(1, value.Length - 2);
+                            }
+                            try
+                            {
+                                context = ContextMessageHeader.ParseContextHeader(
+                                    XmlReader.Create(new MemoryStream(Convert.FromBase64String(value))));
+                                break;
+                            }
+                            catch (SerializationException e)
+                            {
+                                DiagnosticUtility.TraceHandledException(e, TraceEventType.Warning);
+                            }
+                            catch (ProtocolException pe)
+                            {
+                                DiagnosticUtility.TraceHandledException(pe, TraceEventType.Warning);
+                            }
+                        }
+                    }
+                }
+
+                return context != null;
+            }
+        }
+    }
+}