Files
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
Adding reference source for
System.Data
System.Data.DataSetExtensions
System.Data.Entity
System.Data.Entity.Design
System.Data.Linq
System.Data.SqlXml
System.ServiceModel
System.ServiceModel.Activation
System.ServiceModel.Activities
System.ServiceModel.Channels
System.ServiceModel.Discovery
System.ServiceModel.Internals
System.ServiceModel.Routing
System.ServiceModel.WasHosting
System.ServiceModel.Web
System.Web
System.Web.ApplicationServices
System.Web.DynamicData
System.Web.Entity
System.Web.Entity.Design
System.Web.Extensions
System.Web.Mobile
System.Web.Routing
System.Web.Services
System.Xml
System.Xml.Linq
2016-05-03 00:07:37 +02:00

382 lines
14 KiB
C#

//------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//------------------------------------------------------------
namespace System.ServiceModel.Channels
{
using System;
using System.Collections.Generic;
using System.Net;
using System.Runtime;
using System.ServiceModel;
using System.ServiceModel.Diagnostics;
class ClientContextProtocol : ContextProtocol, IContextManager
{
ContextMessageProperty context;
bool contextInitialized;
bool contextManagementEnabled;
CookieContainer cookieContainer;
IChannel owner;
object thisLock;
Uri uri;
Uri callbackAddress;
public ClientContextProtocol(ContextExchangeMechanism contextExchangeMechanism, Uri uri, IChannel owner, Uri callbackAddress, bool contextManagementEnabled)
: base(contextExchangeMechanism)
{
if (contextExchangeMechanism == ContextExchangeMechanism.HttpCookie)
{
this.cookieContainer = new CookieContainer();
}
this.context = ContextMessageProperty.Empty;
this.contextManagementEnabled = contextManagementEnabled;
this.owner = owner;
this.thisLock = new object();
this.uri = uri;
this.callbackAddress = callbackAddress;
}
protected Uri Uri
{
get
{
return this.uri;
}
}
bool IContextManager.Enabled
{
get
{
return this.contextManagementEnabled;
}
set
{
if (this.owner.State != CommunicationState.Created)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
new InvalidOperationException(
SR.GetString(SR.ChannelIsOpen)
));
}
this.contextManagementEnabled = value;
}
}
public IDictionary<string, string> GetContext()
{
if (!this.contextManagementEnabled)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
new InvalidOperationException(
SR.GetString(SR.ContextManagementNotEnabled)
));
}
return new Dictionary<string, string>(this.GetCurrentContext().Context);
}
public override void OnIncomingMessage(Message message)
{
if (message == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("message");
}
ContextMessageProperty incomingContext = null;
if (this.ContextExchangeMechanism == ContextExchangeMechanism.HttpCookie)
{
incomingContext = this.OnReceiveHttpCookies(message);
}
else
{
incomingContext = this.OnReceiveSoapContextHeader(message);
}
if (incomingContext != null)
{
if (this.contextManagementEnabled)
{
EnsureInvariants(true, incomingContext);
}
else
{
incomingContext.AddOrReplaceInMessage(message);
}
}
// verify that the callback context was not sent on an incoming message
if (message.Headers.FindHeader(CallbackContextMessageHeader.CallbackContextHeaderName, CallbackContextMessageHeader.CallbackContextHeaderNamespace) != -1)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperWarning(new ProtocolException(SR.GetString(SR.CallbackContextNotExpectedOnIncomingMessageAtClient, message.Headers.Action, CallbackContextMessageHeader.CallbackContextHeaderName, CallbackContextMessageHeader.CallbackContextHeaderNamespace)));
}
}
public override void OnOutgoingMessage(Message message, RequestContext requestContext)
{
if (message == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("message");
}
ContextMessageProperty outgoingContext = null;
if (ContextMessageProperty.TryGet(message, out outgoingContext))
{
if (this.contextManagementEnabled)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
new InvalidOperationException(
SR.GetString(SR.InvalidMessageContext)));
}
}
if (this.ContextExchangeMechanism == ContextExchangeMechanism.ContextSoapHeader)
{
if (this.contextManagementEnabled)
{
outgoingContext = GetCurrentContext();
}
if (outgoingContext != null)
{
this.OnSendSoapContextHeader(message, outgoingContext);
}
}
else if (this.ContextExchangeMechanism == ContextExchangeMechanism.HttpCookie)
{
if (this.contextManagementEnabled)
{
this.OnSendHttpCookies(message, null);
}
else
{
this.OnSendHttpCookies(message, outgoingContext);
}
}
// serialize the callback context if the property was supplied
CallbackContextMessageProperty callbackContext;
if (CallbackContextMessageProperty.TryGet(message, out callbackContext))
{
// see if the callbackaddress is already set on the CCMP, if it is set use that
// else if callbackaddress is set on the binding, use that
EndpointAddress callbackAddress = callbackContext.CallbackAddress;
if (callbackAddress == null && this.callbackAddress != null)
{
callbackAddress = callbackContext.CreateCallbackAddress(this.callbackAddress);
}
// add the CallbackContextMessageHeader only if we have a valid CallbackAddress
if (callbackAddress != null)
{
if (this.ContextExchangeMechanism != ContextExchangeMechanism.ContextSoapHeader)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.CallbackContextOnlySupportedInSoap)));
}
message.Headers.Add(new CallbackContextMessageHeader(callbackAddress, message.Version.Addressing));
}
}
}
public void SetContext(IDictionary<string, string> context)
{
if (context == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("context");
}
ContextMessageProperty newContext = new ContextMessageProperty(context);
EnsureInvariants(false, newContext);
if (this.ContextExchangeMechanism == ContextExchangeMechanism.HttpCookie)
{
lock (this.cookieContainer)
{
this.cookieContainer.SetCookies(this.Uri, GetCookieHeaderFromContext(newContext));
}
}
}
//Called to update local context
//1) From SetContext(to update client provided context)
//2) From OnReceive*(to update server issued)
void EnsureInvariants(bool isServerIssued, ContextMessageProperty newContext)
{
//Cannot SetContext when ContextManagement not enabled.
if (!this.contextManagementEnabled)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
new InvalidOperationException(
SR.GetString(SR.ContextManagementNotEnabled)
));
}
//Cannot reset context after initialized in server case.
if ((isServerIssued && !this.contextInitialized) ||
(this.owner.State == CommunicationState.Created))
{
lock (this.thisLock)
{
if ((isServerIssued && !this.contextInitialized) ||
(this.owner.State == CommunicationState.Created))
{
this.context = newContext;
this.contextInitialized = true;
return;
}
}
}
if (isServerIssued)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
new ProtocolException(
SR.GetString(SR.InvalidContextReceived)
));
}
else
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
new InvalidOperationException(
SR.GetString(SR.CachedContextIsImmutable)
));
}
}
string GetCookieHeaderFromContext(ContextMessageProperty contextMessageProperty)
{
if (contextMessageProperty.Context.Count == 0)
{
return HttpCookieToolbox.RemoveContextHttpCookieHeader;
}
else
{
return HttpCookieToolbox.EncodeContextAsHttpSetCookieHeader(contextMessageProperty, this.Uri);
}
}
ContextMessageProperty GetCurrentContext()
{
ContextMessageProperty result;
if (this.cookieContainer != null)
{
lock (this.cookieContainer)
{
// This is to allow for the possibility of that the cookie has expired
if (this.cookieContainer.GetCookies(this.Uri)[HttpCookieToolbox.ContextHttpCookieName] == null)
{
result = ContextMessageProperty.Empty;
}
else
{
result = this.context;
}
}
}
else
{
result = this.context;
}
return result;
}
ContextMessageProperty OnReceiveHttpCookies(Message message)
{
ContextMessageProperty newContext = null;
object property;
if (message.Properties.TryGetValue(HttpResponseMessageProperty.Name, out property))
{
HttpResponseMessageProperty httpResponse = property as HttpResponseMessageProperty;
if (httpResponse != null)
{
string setCookieHeader = httpResponse.Headers[HttpResponseHeader.SetCookie];
if (!string.IsNullOrEmpty(setCookieHeader))
{
lock (this.cookieContainer)
{
if (!string.IsNullOrEmpty(setCookieHeader))
{
this.cookieContainer.SetCookies(this.Uri, setCookieHeader);
HttpCookieToolbox.TryCreateFromHttpCookieHeader(setCookieHeader, out newContext);
}
if (!this.contextManagementEnabled)
{
this.cookieContainer.SetCookies(this.Uri, HttpCookieToolbox.RemoveContextHttpCookieHeader);
}
}
}
}
}
return newContext;
}
ContextMessageProperty OnReceiveSoapContextHeader(Message message)
{
ContextMessageProperty messageProperty = ContextMessageHeader.GetContextFromHeaderIfExists(message);
if (messageProperty != null)
{
if (DiagnosticUtility.ShouldTraceVerbose)
{
TraceUtility.TraceEvent(System.Diagnostics.TraceEventType.Verbose,
TraceCode.ContextProtocolContextRetrievedFromMessage, SR.GetString(SR.TraceCodeContextProtocolContextRetrievedFromMessage),
this);
}
}
return messageProperty;
}
void OnSendHttpCookies(Message message, ContextMessageProperty context)
{
string cookieHeader = null;
if (this.contextManagementEnabled || context == null)
{
Fx.Assert(context == null, "Context should be null");
lock (this.cookieContainer)
{
cookieHeader = this.cookieContainer.GetCookieHeader(this.Uri);
}
}
else
{
if (context != null) //User provided context is not null.
{
string contextCookieHeader = this.GetCookieHeaderFromContext(context);
lock (this.cookieContainer)
{
this.cookieContainer.SetCookies(this.Uri, contextCookieHeader);
cookieHeader = this.cookieContainer.GetCookieHeader(this.Uri);
this.cookieContainer.SetCookies(this.Uri, HttpCookieToolbox.RemoveContextHttpCookieHeader);
}
}
}
if (!string.IsNullOrEmpty(cookieHeader))
{
object tmpProperty;
HttpRequestMessageProperty property = null;
if (message.Properties.TryGetValue(HttpRequestMessageProperty.Name, out tmpProperty))
{
property = tmpProperty as HttpRequestMessageProperty;
}
if (property == null)
{
property = new HttpRequestMessageProperty();
message.Properties.Add(HttpRequestMessageProperty.Name, property);
}
property.Headers.Add(HttpRequestHeader.Cookie, cookieHeader);
}
}
}
}