mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
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
382 lines
14 KiB
C#
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);
|
|
}
|
|
}
|
|
}
|
|
}
|