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

627 lines
26 KiB
C#

//------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//------------------------------------------------------------
namespace System.ServiceModel.Channels
{
using System.Globalization;
using System.IO;
using System.Net;
using System.Runtime;
using System.Runtime.Diagnostics;
using System.Runtime.Serialization.Json;
using System.ServiceModel.Diagnostics;
using System.ServiceModel.Web;
using System.Text;
using System.Xml;
using SMTD = System.ServiceModel.Diagnostics.Application.TD;
using WebTD = System.ServiceModel.Web.Diagnostics.Application.TD;
class JsonMessageEncoderFactory : MessageEncoderFactory
{
static readonly TextMessageEncoderFactory.ContentEncoding[] ApplicationJsonContentEncoding = GetContentEncodingMap(JsonGlobals.applicationJsonMediaType);
JsonMessageEncoder messageEncoder;
public JsonMessageEncoderFactory(Encoding writeEncoding, int maxReadPoolSize, int maxWritePoolSize, XmlDictionaryReaderQuotas quotas, bool crossDomainScriptAccessEnabled)
{
messageEncoder = new JsonMessageEncoder(writeEncoding, maxReadPoolSize, maxWritePoolSize, quotas, crossDomainScriptAccessEnabled);
}
public override MessageEncoder Encoder
{
get { return messageEncoder; }
}
public override MessageVersion MessageVersion
{
get { return messageEncoder.MessageVersion; }
}
internal static string GetContentType(WebMessageEncodingBindingElement encodingElement)
{
if (encodingElement == null)
{
return WebMessageEncoderFactory.GetContentType(JsonGlobals.applicationJsonMediaType, TextEncoderDefaults.Encoding);
}
else
{
return WebMessageEncoderFactory.GetContentType(JsonGlobals.applicationJsonMediaType, encodingElement.WriteEncoding);
}
}
static TextMessageEncoderFactory.ContentEncoding[] GetContentEncodingMap(string mediaType)
{
Encoding[] readEncodings = TextMessageEncoderFactory.GetSupportedEncodings();
TextMessageEncoderFactory.ContentEncoding[] map = new TextMessageEncoderFactory.ContentEncoding[readEncodings.Length];
for (int i = 0; i < readEncodings.Length; i++)
{
TextMessageEncoderFactory.ContentEncoding contentEncoding = new TextMessageEncoderFactory.ContentEncoding();
contentEncoding.contentType = WebMessageEncoderFactory.GetContentType(mediaType, readEncodings[i]);
contentEncoding.encoding = readEncodings[i];
map[i] = contentEncoding;
}
return map;
}
class JsonMessageEncoder : MessageEncoder
{
const int maxPooledXmlReadersPerMessage = 2;
// Double-checked locking pattern requires volatile for read/write synchronization
volatile SynchronizedPool<JsonBufferedMessageData> bufferedReaderPool;
volatile SynchronizedPool<JsonBufferedMessageWriter> bufferedWriterPool;
string contentType;
int maxReadPoolSize;
int maxWritePoolSize;
OnXmlDictionaryReaderClose onStreamedReaderClose;
XmlDictionaryReaderQuotas readerQuotas;
XmlDictionaryReaderQuotas bufferedReadReaderQuotas;
// Double-checked locking pattern requires volatile for read/write synchronization
volatile SynchronizedPool<RecycledMessageState> recycledStatePool;
volatile SynchronizedPool<XmlDictionaryReader> streamedReaderPool;
volatile SynchronizedPool<XmlDictionaryWriter> streamedWriterPool;
object thisLock;
Encoding writeEncoding;
bool crossDomainScriptAccessEnabled;
byte[] encodedClosingFunctionCall;
public JsonMessageEncoder(Encoding writeEncoding, int maxReadPoolSize, int maxWritePoolSize, XmlDictionaryReaderQuotas quotas, bool crossDomainScriptAccessEnabled)
{
if (writeEncoding == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("writeEncoding");
}
thisLock = new object();
TextEncoderDefaults.ValidateEncoding(writeEncoding);
this.writeEncoding = writeEncoding;
this.maxReadPoolSize = maxReadPoolSize;
this.maxWritePoolSize = maxWritePoolSize;
this.readerQuotas = new XmlDictionaryReaderQuotas();
this.onStreamedReaderClose = new OnXmlDictionaryReaderClose(ReturnStreamedReader);
quotas.CopyTo(this.readerQuotas);
this.bufferedReadReaderQuotas = EncoderHelpers.GetBufferedReadQuotas(this.readerQuotas);
this.contentType = WebMessageEncoderFactory.GetContentType(JsonGlobals.applicationJsonMediaType, writeEncoding);
this.crossDomainScriptAccessEnabled = crossDomainScriptAccessEnabled;
this.encodedClosingFunctionCall = this.writeEncoding.GetBytes(");");
}
public override string ContentType
{
get { return contentType; }
}
public override string MediaType
{
get { return JsonGlobals.applicationJsonMediaType; }
}
public override MessageVersion MessageVersion
{
get { return MessageVersion.None; }
}
SynchronizedPool<RecycledMessageState> RecycledStatePool
{
get
{
if (recycledStatePool == null)
{
lock (ThisLock)
{
if (recycledStatePool == null)
{
recycledStatePool = new SynchronizedPool<RecycledMessageState>(maxReadPoolSize);
}
}
}
return recycledStatePool;
}
}
object ThisLock
{
get { return thisLock; }
}
public override bool IsContentTypeSupported(string contentType)
{
if (contentType == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("contentType");
}
return IsJsonContentType(contentType);
}
public override Message ReadMessage(ArraySegment<byte> buffer, BufferManager bufferManager, string contentType)
{
if (bufferManager == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("bufferManager"));
}
if (WebTD.JsonMessageDecodingStartIsEnabled())
{
WebTD.JsonMessageDecodingStart();
}
Message message;
JsonBufferedMessageData messageData = TakeBufferedReader();
messageData.Encoding = TextMessageEncoderFactory.GetEncodingFromContentType(contentType, JsonMessageEncoderFactory.ApplicationJsonContentEncoding);
messageData.Open(buffer, bufferManager);
RecycledMessageState messageState = messageData.TakeMessageState();
if (messageState == null)
{
messageState = new RecycledMessageState();
}
message = new BufferedMessage(messageData, messageState);
message.Properties.Encoder = this;
if (SMTD.MessageReadByEncoderIsEnabled() && buffer != null)
{
SMTD.MessageReadByEncoder(
EventTraceActivityHelper.TryExtractActivity(message, true),
buffer.Count,
this);
}
if (MessageLogger.LogMessagesAtTransportLevel)
{
MessageLogger.LogMessage(ref message, MessageLoggingSource.TransportReceive);
}
return message;
}
public override Message ReadMessage(Stream stream, int maxSizeOfHeaders, string contentType)
{
if (stream == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("stream"));
}
if (WebTD.JsonMessageDecodingStartIsEnabled())
{
WebTD.JsonMessageDecodingStart();
}
XmlReader reader = TakeStreamedReader(stream, TextMessageEncoderFactory.GetEncodingFromContentType(contentType, JsonMessageEncoderFactory.ApplicationJsonContentEncoding));
Message message = Message.CreateMessage(reader, maxSizeOfHeaders, MessageVersion.None);
message.Properties.Encoder = this;
if (SMTD.StreamedMessageReadByEncoderIsEnabled())
{
SMTD.StreamedMessageReadByEncoder(EventTraceActivityHelper.TryExtractActivity(message, true));
}
if (MessageLogger.LogMessagesAtTransportLevel)
{
MessageLogger.LogMessage(ref message, MessageLoggingSource.TransportReceive);
}
return message;
}
public override ArraySegment<byte> WriteMessage(Message message, int maxMessageSize, BufferManager bufferManager, int messageOffset)
{
if (message == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("message"));
}
if (bufferManager == null)
{
throw TraceUtility.ThrowHelperError(new ArgumentNullException("bufferManager"), message);
}
if (maxMessageSize < 0)
{
throw TraceUtility.ThrowHelperError(new ArgumentOutOfRangeException("maxMessageSize", maxMessageSize,
SR2.GetString(SR2.ValueMustBeNonNegative)), message);
}
if (messageOffset < 0 || messageOffset > maxMessageSize)
{
throw TraceUtility.ThrowHelperError(new ArgumentOutOfRangeException("messageOffset", messageOffset,
SR2.GetString(SR2.JsonValueMustBeInRange, 0, maxMessageSize)), message);
}
EventTraceActivity eventTraceActivity = null;
if (WebTD.JsonMessageEncodingStartIsEnabled())
{
eventTraceActivity = EventTraceActivityHelper.TryExtractActivity(message);
WebTD.JsonMessageEncodingStart(eventTraceActivity);
}
ThrowIfMismatchedMessageVersion(message);
message.Properties.Encoder = this;
JsonBufferedMessageWriter messageWriter = TakeBufferedWriter();
JavascriptCallbackResponseMessageProperty javascriptResponseMessageProperty;
if (message.Properties.TryGetValue<JavascriptCallbackResponseMessageProperty>(JavascriptCallbackResponseMessageProperty.Name, out javascriptResponseMessageProperty) &&
javascriptResponseMessageProperty != null)
{
if (this.crossDomainScriptAccessEnabled)
{
messageWriter.SetJavascriptCallbackProperty(javascriptResponseMessageProperty);
}
else
{
throw TraceUtility.ThrowHelperError(new InvalidOperationException(SR2.JavascriptCallbackNotEnabled), message);
}
}
ArraySegment<byte> messageData = messageWriter.WriteMessage(message, bufferManager, messageOffset, maxMessageSize);
ReturnMessageWriter(messageWriter);
if (SMTD.MessageWrittenByEncoderIsEnabled() && messageData != null)
{
SMTD.MessageWrittenByEncoder(
eventTraceActivity ?? EventTraceActivityHelper.TryExtractActivity(message),
messageData.Count,
this);
}
if (MessageLogger.LogMessagesAtTransportLevel)
{
XmlDictionaryReader xmlDictionaryReader = JsonReaderWriterFactory.CreateJsonReader(
messageData.Array, messageData.Offset, messageData.Count, null, XmlDictionaryReaderQuotas.Max, null);
MessageLogger.LogMessage(ref message, xmlDictionaryReader, MessageLoggingSource.TransportSend);
}
return messageData;
}
public override void WriteMessage(Message message, Stream stream)
{
if (message == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("message"));
}
if (stream == null)
{
throw TraceUtility.ThrowHelperError(new ArgumentNullException("stream"), message);
}
ThrowIfMismatchedMessageVersion(message);
EventTraceActivity eventTraceActivity = null;
if (WebTD.JsonMessageEncodingStartIsEnabled())
{
eventTraceActivity = EventTraceActivityHelper.TryExtractActivity(message);
WebTD.JsonMessageEncodingStart(eventTraceActivity);
}
message.Properties.Encoder = this;
XmlDictionaryWriter xmlWriter = TakeStreamedWriter(stream);
JavascriptCallbackResponseMessageProperty javascriptResponseMessageProperty;
if (message.Properties.TryGetValue<JavascriptCallbackResponseMessageProperty>(JavascriptCallbackResponseMessageProperty.Name, out javascriptResponseMessageProperty)
&& javascriptResponseMessageProperty != null
&& !String.IsNullOrEmpty(javascriptResponseMessageProperty.CallbackFunctionName))
{
if (!this.crossDomainScriptAccessEnabled)
{
throw TraceUtility.ThrowHelperError(new InvalidOperationException(SR2.JavascriptCallbackNotEnabled), message);
}
byte[] buffer = this.writeEncoding.GetBytes(String.Format(CultureInfo.InvariantCulture, "{0}(", javascriptResponseMessageProperty.CallbackFunctionName));
stream.Write(buffer, 0, buffer.Length);
}
xmlWriter.WriteStartDocument();
message.WriteMessage(xmlWriter);
xmlWriter.WriteEndDocument();
xmlWriter.Flush();
ReturnStreamedWriter(xmlWriter);
if (javascriptResponseMessageProperty != null
&& !String.IsNullOrEmpty(javascriptResponseMessageProperty.CallbackFunctionName))
{
if (javascriptResponseMessageProperty.StatusCode != null && (int)javascriptResponseMessageProperty.StatusCode != 200)
{
byte[] buffer = this.writeEncoding.GetBytes(String.Format(CultureInfo.InvariantCulture, ",{0}", (int)javascriptResponseMessageProperty.StatusCode));
stream.Write(buffer, 0, buffer.Length);
}
stream.Write(this.encodedClosingFunctionCall, 0, this.encodedClosingFunctionCall.Length);
}
if (SMTD.StreamedMessageWrittenByEncoderIsEnabled())
{
SMTD.StreamedMessageWrittenByEncoder(
eventTraceActivity ?? EventTraceActivityHelper.TryExtractActivity(message));
}
if (MessageLogger.LogMessagesAtTransportLevel)
{
MessageLogger.LogMessage(ref message, MessageLoggingSource.TransportSend);
}
}
internal override bool IsCharSetSupported(string charSet)
{
Encoding tmp;
return TextEncoderDefaults.TryGetEncoding(charSet, out tmp);
}
bool IsJsonContentType(string contentType)
{
return IsContentTypeSupported(contentType, JsonGlobals.applicationJsonMediaType, JsonGlobals.applicationJsonMediaType) || IsContentTypeSupported(contentType, JsonGlobals.textJsonMediaType, JsonGlobals.textJsonMediaType);
}
void ReturnBufferedData(JsonBufferedMessageData messageData)
{
bufferedReaderPool.Return(messageData);
}
void ReturnMessageWriter(JsonBufferedMessageWriter messageWriter)
{
bufferedWriterPool.Return(messageWriter);
}
void ReturnStreamedReader(XmlDictionaryReader xmlReader)
{
streamedReaderPool.Return(xmlReader);
}
void ReturnStreamedWriter(XmlWriter xmlWriter)
{
xmlWriter.Close();
streamedWriterPool.Return((XmlDictionaryWriter)xmlWriter);
}
JsonBufferedMessageData TakeBufferedReader()
{
if (bufferedReaderPool == null)
{
lock (ThisLock)
{
if (bufferedReaderPool == null)
{
bufferedReaderPool = new SynchronizedPool<JsonBufferedMessageData>(maxReadPoolSize);
}
}
}
JsonBufferedMessageData messageData = bufferedReaderPool.Take();
if (messageData == null)
{
messageData = new JsonBufferedMessageData(this, maxPooledXmlReadersPerMessage);
}
return messageData;
}
JsonBufferedMessageWriter TakeBufferedWriter()
{
if (bufferedWriterPool == null)
{
lock (ThisLock)
{
if (bufferedWriterPool == null)
{
bufferedWriterPool = new SynchronizedPool<JsonBufferedMessageWriter>(maxWritePoolSize);
}
}
}
JsonBufferedMessageWriter messageWriter = bufferedWriterPool.Take();
if (messageWriter == null)
{
messageWriter = new JsonBufferedMessageWriter(this);
}
return messageWriter;
}
XmlDictionaryReader TakeStreamedReader(Stream stream, Encoding enc)
{
if (streamedReaderPool == null)
{
lock (ThisLock)
{
if (streamedReaderPool == null)
{
streamedReaderPool = new SynchronizedPool<XmlDictionaryReader>(maxReadPoolSize);
}
}
}
XmlDictionaryReader xmlReader = streamedReaderPool.Take();
if (xmlReader == null)
{
xmlReader = JsonReaderWriterFactory.CreateJsonReader(stream, enc, this.readerQuotas, this.onStreamedReaderClose);
}
else
{
((IXmlJsonReaderInitializer)xmlReader).SetInput(stream, enc, this.readerQuotas, this.onStreamedReaderClose);
}
return xmlReader;
}
XmlDictionaryWriter TakeStreamedWriter(Stream stream)
{
if (streamedWriterPool == null)
{
lock (ThisLock)
{
if (streamedWriterPool == null)
{
streamedWriterPool = new SynchronizedPool<XmlDictionaryWriter>(maxWritePoolSize);
}
}
}
XmlDictionaryWriter xmlWriter = streamedWriterPool.Take();
if (xmlWriter == null)
{
xmlWriter = JsonReaderWriterFactory.CreateJsonWriter(stream, this.writeEncoding, false);
}
else
{
((IXmlJsonWriterInitializer)xmlWriter).SetOutput(stream, this.writeEncoding, false);
}
return xmlWriter;
}
class JsonBufferedMessageData : BufferedMessageData
{
Encoding encoding;
JsonMessageEncoder messageEncoder;
OnXmlDictionaryReaderClose onClose;
Pool<XmlDictionaryReader> readerPool;
public JsonBufferedMessageData(JsonMessageEncoder messageEncoder, int maxReaderPoolSize)
: base(messageEncoder.RecycledStatePool)
{
this.messageEncoder = messageEncoder;
readerPool = new Pool<XmlDictionaryReader>(maxReaderPoolSize);
onClose = new OnXmlDictionaryReaderClose(OnXmlReaderClosed);
}
public override MessageEncoder MessageEncoder
{
get { return messageEncoder; }
}
public override XmlDictionaryReaderQuotas Quotas
{
get { return messageEncoder.bufferedReadReaderQuotas; }
}
internal Encoding Encoding
{
set
{
this.encoding = value;
}
}
protected override void OnClosed()
{
messageEncoder.ReturnBufferedData(this);
}
protected override void ReturnXmlReader(XmlDictionaryReader xmlReader)
{
if (xmlReader != null)
{
readerPool.Return(xmlReader);
}
}
protected override XmlDictionaryReader TakeXmlReader()
{
ArraySegment<byte> buffer = this.Buffer;
XmlDictionaryReader xmlReader = readerPool.Take();
if (xmlReader == null)
{
xmlReader = JsonReaderWriterFactory.CreateJsonReader(buffer.Array, buffer.Offset, buffer.Count, this.encoding, this.Quotas, onClose);
}
else
{
((IXmlJsonReaderInitializer)xmlReader).SetInput(buffer.Array, buffer.Offset, buffer.Count, this.encoding, this.Quotas, onClose);
}
return xmlReader;
}
}
class JsonBufferedMessageWriter : BufferedMessageWriter
{
JsonMessageEncoder messageEncoder;
XmlDictionaryWriter returnedWriter;
JavascriptXmlWriterWrapper javascriptWrapper;
public JsonBufferedMessageWriter(JsonMessageEncoder messageEncoder)
{
this.messageEncoder = messageEncoder;
}
public void SetJavascriptCallbackProperty(JavascriptCallbackResponseMessageProperty javascriptResponseMessageProperty)
{
if (this.javascriptWrapper == null)
{
this.javascriptWrapper = new JavascriptXmlWriterWrapper(this.messageEncoder.writeEncoding)
{
JavascriptResponseMessageProperty = javascriptResponseMessageProperty
};
}
else
{
this.javascriptWrapper.JavascriptResponseMessageProperty = javascriptResponseMessageProperty;
}
}
protected override void OnWriteEndMessage(XmlDictionaryWriter writer)
{
writer.WriteEndDocument();
}
protected override void OnWriteStartMessage(XmlDictionaryWriter writer)
{
writer.WriteStartDocument();
}
protected override void ReturnXmlWriter(XmlDictionaryWriter writer)
{
writer.Close();
if (writer is JavascriptXmlWriterWrapper)
{
if (this.javascriptWrapper == null)
{
this.javascriptWrapper = (JavascriptXmlWriterWrapper)writer;
this.javascriptWrapper.JavascriptResponseMessageProperty = null;
writer = this.javascriptWrapper.XmlJsonWriter;
}
}
if (this.returnedWriter == null)
{
this.returnedWriter = writer;
}
}
protected override XmlDictionaryWriter TakeXmlWriter(Stream stream)
{
XmlDictionaryWriter writer = null;
if (this.returnedWriter == null)
{
writer = JsonReaderWriterFactory.CreateJsonWriter(stream, messageEncoder.writeEncoding, false);
}
else
{
writer = this.returnedWriter;
((IXmlJsonWriterInitializer)writer).SetOutput(stream, messageEncoder.writeEncoding, false);
this.returnedWriter = null;
}
if (this.javascriptWrapper != null && this.javascriptWrapper.JavascriptResponseMessageProperty != null)
{
this.javascriptWrapper.SetOutput(stream, writer);
writer = this.javascriptWrapper;
this.javascriptWrapper = null;
}
return writer;
}
}
}
}
}