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
778 lines
31 KiB
C#
778 lines
31 KiB
C#
//------------------------------------------------------------
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
//------------------------------------------------------------
|
|
namespace System.ServiceModel.Channels
|
|
{
|
|
using System.Globalization;
|
|
using System.IO;
|
|
using System.Runtime;
|
|
using System.ServiceModel;
|
|
using System.ServiceModel.Description;
|
|
using System.ServiceModel.Diagnostics;
|
|
using System.Text;
|
|
using System.Threading;
|
|
using System.Xml;
|
|
using System.ServiceModel.Diagnostics.Application;
|
|
using System.Runtime.Diagnostics;
|
|
|
|
class MtomMessageEncoderFactory : MessageEncoderFactory
|
|
{
|
|
MtomMessageEncoder messageEncoder;
|
|
|
|
public MtomMessageEncoderFactory(MessageVersion version, Encoding writeEncoding, int maxReadPoolSize, int maxWritePoolSize, int maxBufferSize, XmlDictionaryReaderQuotas quotas)
|
|
{
|
|
messageEncoder = new MtomMessageEncoder(version, writeEncoding, maxReadPoolSize, maxWritePoolSize, maxBufferSize, quotas);
|
|
}
|
|
|
|
public override MessageEncoder Encoder
|
|
{
|
|
get { return messageEncoder; }
|
|
}
|
|
|
|
public override MessageVersion MessageVersion
|
|
{
|
|
get { return messageEncoder.MessageVersion; }
|
|
}
|
|
|
|
public int MaxWritePoolSize
|
|
{
|
|
get { return messageEncoder.MaxWritePoolSize; }
|
|
}
|
|
|
|
public int MaxReadPoolSize
|
|
{
|
|
get { return messageEncoder.MaxReadPoolSize; }
|
|
}
|
|
|
|
public XmlDictionaryReaderQuotas ReaderQuotas
|
|
{
|
|
get
|
|
{
|
|
return messageEncoder.ReaderQuotas;
|
|
}
|
|
}
|
|
|
|
public int MaxBufferSize
|
|
{
|
|
get { return messageEncoder.MaxBufferSize; }
|
|
}
|
|
|
|
public static Encoding[] GetSupportedEncodings()
|
|
{
|
|
Encoding[] supported = TextEncoderDefaults.SupportedEncodings;
|
|
Encoding[] enc = new Encoding[supported.Length];
|
|
Array.Copy(supported, enc, supported.Length);
|
|
return enc;
|
|
}
|
|
|
|
}
|
|
|
|
// Some notes:
|
|
// The Encoding passed in is used for the SOAP envelope
|
|
class MtomMessageEncoder : MessageEncoder, ITraceSourceStringProvider
|
|
{
|
|
Encoding writeEncoding;
|
|
|
|
// Double-checked locking pattern requires volatile for read/write synchronization
|
|
volatile SynchronizedPool<XmlDictionaryWriter> streamedWriterPool;
|
|
volatile SynchronizedPool<XmlDictionaryReader> streamedReaderPool;
|
|
volatile SynchronizedPool<MtomBufferedMessageData> bufferedReaderPool;
|
|
volatile SynchronizedPool<MtomBufferedMessageWriter> bufferedWriterPool;
|
|
volatile SynchronizedPool<RecycledMessageState> recycledStatePool;
|
|
|
|
object thisLock;
|
|
MessageVersion version;
|
|
const int maxPooledXmlReadersPerMessage = 2;
|
|
int maxReadPoolSize;
|
|
int maxWritePoolSize;
|
|
static UriGenerator mimeBoundaryGenerator;
|
|
XmlDictionaryReaderQuotas readerQuotas;
|
|
XmlDictionaryReaderQuotas bufferedReadReaderQuotas;
|
|
int maxBufferSize;
|
|
OnXmlDictionaryReaderClose onStreamedReaderClose;
|
|
|
|
internal TextMessageEncoderFactory.ContentEncoding[] contentEncodingMap;
|
|
|
|
const string mtomMediaType = "multipart/related";
|
|
const string mtomContentType = mtomMediaType + "; type=\"application/xop+xml\"";
|
|
const string mtomStartUri = NamingHelper.DefaultNamespace + "0";
|
|
|
|
public MtomMessageEncoder(MessageVersion version, Encoding writeEncoding, int maxReadPoolSize, int maxWritePoolSize, int maxBufferSize, XmlDictionaryReaderQuotas quotas)
|
|
{
|
|
if (version == null)
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("version");
|
|
if (writeEncoding == null)
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("writeEncoding");
|
|
|
|
TextEncoderDefaults.ValidateEncoding(writeEncoding);
|
|
this.writeEncoding = writeEncoding;
|
|
|
|
this.maxReadPoolSize = maxReadPoolSize;
|
|
this.maxWritePoolSize = maxWritePoolSize;
|
|
|
|
this.readerQuotas = new XmlDictionaryReaderQuotas();
|
|
quotas.CopyTo(this.readerQuotas);
|
|
|
|
this.bufferedReadReaderQuotas = EncoderHelpers.GetBufferedReadQuotas(this.readerQuotas);
|
|
|
|
this.maxBufferSize = maxBufferSize;
|
|
this.onStreamedReaderClose = new OnXmlDictionaryReaderClose(ReturnStreamedReader);
|
|
|
|
this.thisLock = new object();
|
|
|
|
if (version.Envelope == EnvelopeVersion.Soap12)
|
|
{
|
|
this.contentEncodingMap = TextMessageEncoderFactory.Soap12Content;
|
|
}
|
|
else if (version.Envelope == EnvelopeVersion.Soap11)
|
|
{
|
|
this.contentEncodingMap = TextMessageEncoderFactory.Soap11Content;
|
|
}
|
|
else
|
|
{
|
|
Fx.Assert("Invalid MessageVersion");
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(String.Format(CultureInfo.InvariantCulture, "Invalid MessageVersion")));
|
|
}
|
|
|
|
this.version = version;
|
|
}
|
|
|
|
static UriGenerator MimeBoundaryGenerator
|
|
{
|
|
get
|
|
{
|
|
if (mimeBoundaryGenerator == null)
|
|
mimeBoundaryGenerator = new UriGenerator("uuid", "+");
|
|
return mimeBoundaryGenerator;
|
|
}
|
|
}
|
|
|
|
public override string ContentType
|
|
{
|
|
get { return mtomContentType; }
|
|
}
|
|
|
|
public int MaxWritePoolSize
|
|
{
|
|
get { return maxWritePoolSize; }
|
|
}
|
|
|
|
public int MaxReadPoolSize
|
|
{
|
|
get { return maxReadPoolSize; }
|
|
}
|
|
|
|
public XmlDictionaryReaderQuotas ReaderQuotas
|
|
{
|
|
get
|
|
{
|
|
return readerQuotas;
|
|
}
|
|
}
|
|
|
|
public int MaxBufferSize
|
|
{
|
|
get { return maxBufferSize; }
|
|
}
|
|
|
|
public override string MediaType
|
|
{
|
|
get { return mtomMediaType; }
|
|
}
|
|
|
|
public override MessageVersion MessageVersion
|
|
{
|
|
get { return version; }
|
|
}
|
|
|
|
internal bool IsMTOMContentType(string contentType)
|
|
{
|
|
// check for MTOM contentType: multipart/related; type=\"application/xop+xml\"
|
|
return IsContentTypeSupported(contentType, this.ContentType, this.MediaType);
|
|
}
|
|
|
|
internal bool IsTextContentType(string contentType)
|
|
{
|
|
// check for Text contentType: text/xml or application/soap+xml
|
|
string textMediaType = TextMessageEncoderFactory.GetMediaType(version);
|
|
string textContentType = TextMessageEncoderFactory.GetContentType(textMediaType, writeEncoding);
|
|
return IsContentTypeSupported(contentType, textContentType, textMediaType);
|
|
}
|
|
|
|
public override bool IsContentTypeSupported(string contentType)
|
|
{
|
|
if (contentType == null)
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("contentType"));
|
|
return (IsMTOMContentType(contentType) || IsTextContentType(contentType));
|
|
}
|
|
|
|
internal override bool IsCharSetSupported(string charSet)
|
|
{
|
|
if (charSet == null || charSet.Length == 0)
|
|
return true;
|
|
|
|
Encoding tmp;
|
|
return TextEncoderDefaults.TryGetEncoding(charSet, out tmp);
|
|
}
|
|
|
|
string GenerateStartInfoString()
|
|
{
|
|
return (version.Envelope == EnvelopeVersion.Soap12) ? TextMessageEncoderFactory.Soap12MediaType : TextMessageEncoderFactory.Soap11MediaType;
|
|
}
|
|
|
|
public override Message ReadMessage(ArraySegment<byte> buffer, BufferManager bufferManager, string contentType)
|
|
{
|
|
if (bufferManager == null)
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("bufferManager");
|
|
|
|
if (contentType == this.ContentType)
|
|
contentType = null;
|
|
|
|
if (TD.MtomMessageDecodingStartIsEnabled())
|
|
{
|
|
TD.MtomMessageDecodingStart();
|
|
}
|
|
|
|
MtomBufferedMessageData messageData = TakeBufferedReader();
|
|
messageData.ContentType = contentType;
|
|
messageData.Open(buffer, bufferManager);
|
|
RecycledMessageState messageState = messageData.TakeMessageState();
|
|
if (messageState == null)
|
|
messageState = new RecycledMessageState();
|
|
Message message = new BufferedMessage(messageData, messageState);
|
|
message.Properties.Encoder = this;
|
|
if (MessageLogger.LogMessagesAtTransportLevel)
|
|
MessageLogger.LogMessage(ref message, MessageLoggingSource.TransportReceive);
|
|
|
|
if (TD.MessageReadByEncoderIsEnabled() && buffer != null)
|
|
{
|
|
TD.MessageReadByEncoder(
|
|
EventTraceActivityHelper.TryExtractActivity(message, true),
|
|
buffer.Count,
|
|
this);
|
|
}
|
|
|
|
return message;
|
|
}
|
|
|
|
public override Message ReadMessage(Stream stream, int maxSizeOfHeaders, string contentType)
|
|
{
|
|
if (stream == null)
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("stream"));
|
|
|
|
if (contentType == this.ContentType)
|
|
contentType = null;
|
|
|
|
if (TD.MtomMessageDecodingStartIsEnabled())
|
|
{
|
|
TD.MtomMessageDecodingStart();
|
|
}
|
|
|
|
XmlReader reader = TakeStreamedReader(stream, contentType);
|
|
Message message = Message.CreateMessage(reader, maxSizeOfHeaders, version);
|
|
message.Properties.Encoder = this;
|
|
|
|
if (TD.StreamedMessageReadByEncoderIsEnabled())
|
|
{
|
|
TD.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)
|
|
{
|
|
return WriteMessage(message, maxMessageSize, bufferManager, messageOffset, GenerateStartInfoString(), null, null, true /*writeMessageHeaders*/);
|
|
}
|
|
|
|
internal string GetContentType(out string boundary)
|
|
{
|
|
string startInfo = GenerateStartInfoString();
|
|
boundary = MimeBoundaryGenerator.Next();
|
|
|
|
return FormatContentType(boundary, startInfo);
|
|
}
|
|
|
|
internal string FormatContentType(string boundary, string startInfo)
|
|
{
|
|
return String.Format(CultureInfo.InvariantCulture,
|
|
"{0};start=\"<{1}>\";boundary=\"{2}\";start-info=\"{3}\"",
|
|
mtomContentType, mtomStartUri, boundary, startInfo);
|
|
}
|
|
|
|
internal ArraySegment<byte> WriteMessage(Message message, int maxMessageSize, BufferManager bufferManager, int messageOffset, string boundary)
|
|
{
|
|
return WriteMessage(message, maxMessageSize, bufferManager, messageOffset, GenerateStartInfoString(), boundary, mtomStartUri, false /*writeMessageHeaders*/);
|
|
}
|
|
|
|
ArraySegment<byte> WriteMessage(Message message, int maxMessageSize, BufferManager bufferManager, int messageOffset, string startInfo, string boundary, string startUri, bool writeMessageHeaders)
|
|
{
|
|
if (message == null)
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("message");
|
|
if (bufferManager == null)
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("bufferManager");
|
|
if (maxMessageSize < 0)
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("maxMessageSize", maxMessageSize,
|
|
SR.GetString(SR.ValueMustBeNonNegative)));
|
|
if (messageOffset < 0 || messageOffset > maxMessageSize)
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("messageOffset", messageOffset,
|
|
SR.GetString(SR.ValueMustBeInRange, 0, maxMessageSize)));
|
|
ThrowIfMismatchedMessageVersion(message);
|
|
|
|
EventTraceActivity eventTraceActivity = null;
|
|
if (TD.MtomMessageEncodingStartIsEnabled())
|
|
{
|
|
eventTraceActivity = EventTraceActivityHelper.TryExtractActivity(message);
|
|
TD.MtomMessageEncodingStart(eventTraceActivity);
|
|
}
|
|
|
|
message.Properties.Encoder = this;
|
|
|
|
MtomBufferedMessageWriter messageWriter = TakeBufferedWriter();
|
|
messageWriter.StartInfo = startInfo;
|
|
messageWriter.Boundary = boundary;
|
|
messageWriter.StartUri = startUri;
|
|
messageWriter.WriteMessageHeaders = writeMessageHeaders;
|
|
messageWriter.MaxSizeInBytes = maxMessageSize;
|
|
ArraySegment<byte> messageData = messageWriter.WriteMessage(message, bufferManager, messageOffset, maxMessageSize);
|
|
ReturnMessageWriter(messageWriter);
|
|
|
|
if (TD.MessageWrittenByEncoderIsEnabled() && messageData != null)
|
|
{
|
|
TD.MessageWrittenByEncoder(
|
|
eventTraceActivity ?? EventTraceActivityHelper.TryExtractActivity(message),
|
|
messageData.Count,
|
|
this);
|
|
}
|
|
|
|
if (MessageLogger.LogMessagesAtTransportLevel)
|
|
{
|
|
string contentType = null;
|
|
if (boundary != null)
|
|
contentType = FormatContentType(boundary, startInfo ?? GenerateStartInfoString());
|
|
|
|
XmlDictionaryReader xmlDictionaryReader = XmlDictionaryReader.CreateMtomReader(messageData.Array, messageData.Offset, messageData.Count, MtomMessageEncoderFactory.GetSupportedEncodings(), contentType, XmlDictionaryReaderQuotas.Max, int.MaxValue, null);
|
|
MessageLogger.LogMessage(ref message, xmlDictionaryReader, MessageLoggingSource.TransportSend);
|
|
}
|
|
|
|
return messageData;
|
|
}
|
|
|
|
public override void WriteMessage(Message message, Stream stream)
|
|
{
|
|
WriteMessage(message, stream, GenerateStartInfoString(), null, null, true /*writeMessageHeaders*/);
|
|
}
|
|
|
|
internal void WriteMessage(Message message, Stream stream, string boundary)
|
|
{
|
|
WriteMessage(message, stream, GenerateStartInfoString(), boundary, mtomStartUri, false /*writeMessageHeaders*/);
|
|
}
|
|
|
|
public override IAsyncResult BeginWriteMessage(Message message, Stream stream, AsyncCallback callback, object state)
|
|
{
|
|
return new WriteMessageAsyncResult(message, stream, this, callback, state);
|
|
}
|
|
|
|
internal IAsyncResult BeginWriteMessage(Message message, Stream stream, string boundary, AsyncCallback callback, object state)
|
|
{
|
|
return new WriteMessageAsyncResult(message, stream, boundary, this, callback, state);
|
|
}
|
|
|
|
public override void EndWriteMessage(IAsyncResult result)
|
|
{
|
|
WriteMessageAsyncResult.End(result);
|
|
}
|
|
|
|
void WriteMessage(Message message, Stream stream, string startInfo, string boundary, string startUri, bool writeMessageHeaders)
|
|
{
|
|
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 (TD.MtomMessageEncodingStartIsEnabled())
|
|
{
|
|
eventTraceActivity = EventTraceActivityHelper.TryExtractActivity(message);
|
|
TD.MtomMessageEncodingStart(eventTraceActivity);
|
|
}
|
|
|
|
message.Properties.Encoder = this;
|
|
if (MessageLogger.LogMessagesAtTransportLevel)
|
|
MessageLogger.LogMessage(ref message, MessageLoggingSource.TransportSend);
|
|
XmlDictionaryWriter xmlWriter = TakeStreamedWriter(stream, startInfo, boundary, startUri, writeMessageHeaders);
|
|
if (this.writeEncoding.WebName == "utf-8")
|
|
{
|
|
message.WriteMessage(xmlWriter);
|
|
}
|
|
else
|
|
{
|
|
xmlWriter.WriteStartDocument();
|
|
message.WriteMessage(xmlWriter);
|
|
xmlWriter.WriteEndDocument();
|
|
}
|
|
xmlWriter.Flush();
|
|
ReturnStreamedWriter(xmlWriter);
|
|
|
|
if (TD.StreamedMessageWrittenByEncoderIsEnabled())
|
|
{
|
|
TD.StreamedMessageWrittenByEncoder(eventTraceActivity ?? EventTraceActivityHelper.TryExtractActivity(message));
|
|
}
|
|
}
|
|
|
|
XmlDictionaryWriter TakeStreamedWriter(Stream stream, string startInfo, string boundary, string startUri, bool writeMessageHeaders)
|
|
{
|
|
if (streamedWriterPool == null)
|
|
{
|
|
lock (thisLock)
|
|
{
|
|
if (streamedWriterPool == null)
|
|
{
|
|
streamedWriterPool = new SynchronizedPool<XmlDictionaryWriter>(maxWritePoolSize);
|
|
}
|
|
}
|
|
}
|
|
XmlDictionaryWriter xmlWriter = streamedWriterPool.Take();
|
|
if (xmlWriter == null)
|
|
{
|
|
xmlWriter = XmlDictionaryWriter.CreateMtomWriter(stream, this.writeEncoding, int.MaxValue, startInfo, boundary, startUri, writeMessageHeaders, false);
|
|
if (TD.WritePoolMissIsEnabled())
|
|
{
|
|
TD.WritePoolMiss(xmlWriter.GetType().Name);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
((IXmlMtomWriterInitializer)xmlWriter).SetOutput(stream, this.writeEncoding, int.MaxValue, startInfo, boundary, startUri, writeMessageHeaders, false);
|
|
}
|
|
return xmlWriter;
|
|
}
|
|
|
|
void ReturnStreamedWriter(XmlDictionaryWriter xmlWriter)
|
|
{
|
|
xmlWriter.Close();
|
|
streamedWriterPool.Return(xmlWriter);
|
|
}
|
|
|
|
MtomBufferedMessageWriter TakeBufferedWriter()
|
|
{
|
|
if (bufferedWriterPool == null)
|
|
{
|
|
lock (thisLock)
|
|
{
|
|
if (bufferedWriterPool == null)
|
|
{
|
|
bufferedWriterPool = new SynchronizedPool<MtomBufferedMessageWriter>(maxWritePoolSize);
|
|
}
|
|
}
|
|
}
|
|
|
|
MtomBufferedMessageWriter messageWriter = bufferedWriterPool.Take();
|
|
if (messageWriter == null)
|
|
{
|
|
messageWriter = new MtomBufferedMessageWriter(this);
|
|
if (TD.WritePoolMissIsEnabled())
|
|
{
|
|
TD.WritePoolMiss(messageWriter.GetType().Name);
|
|
}
|
|
}
|
|
return messageWriter;
|
|
}
|
|
|
|
void ReturnMessageWriter(MtomBufferedMessageWriter messageWriter)
|
|
{
|
|
bufferedWriterPool.Return(messageWriter);
|
|
}
|
|
|
|
MtomBufferedMessageData TakeBufferedReader()
|
|
{
|
|
if (bufferedReaderPool == null)
|
|
{
|
|
lock (thisLock)
|
|
{
|
|
if (bufferedReaderPool == null)
|
|
{
|
|
bufferedReaderPool = new SynchronizedPool<MtomBufferedMessageData>(maxReadPoolSize);
|
|
}
|
|
}
|
|
}
|
|
MtomBufferedMessageData messageData = bufferedReaderPool.Take();
|
|
if (messageData == null)
|
|
{
|
|
messageData = new MtomBufferedMessageData(this, maxPooledXmlReadersPerMessage);
|
|
if (TD.ReadPoolMissIsEnabled())
|
|
{
|
|
TD.ReadPoolMiss(messageData.GetType().Name);
|
|
}
|
|
}
|
|
return messageData;
|
|
}
|
|
|
|
void ReturnBufferedData(MtomBufferedMessageData messageData)
|
|
{
|
|
bufferedReaderPool.Return(messageData);
|
|
}
|
|
|
|
XmlReader TakeStreamedReader(Stream stream, string contentType)
|
|
{
|
|
if (streamedReaderPool == null)
|
|
{
|
|
lock (thisLock)
|
|
{
|
|
if (streamedReaderPool == null)
|
|
{
|
|
streamedReaderPool = new SynchronizedPool<XmlDictionaryReader>(maxReadPoolSize);
|
|
}
|
|
}
|
|
}
|
|
XmlDictionaryReader xmlReader = streamedReaderPool.Take();
|
|
try
|
|
{
|
|
if (contentType == null || IsMTOMContentType(contentType))
|
|
{
|
|
if (xmlReader != null && xmlReader is IXmlMtomReaderInitializer)
|
|
{
|
|
((IXmlMtomReaderInitializer)xmlReader).SetInput(stream, MtomMessageEncoderFactory.GetSupportedEncodings(), contentType, this.readerQuotas, this.maxBufferSize, onStreamedReaderClose);
|
|
}
|
|
else
|
|
{
|
|
xmlReader = XmlDictionaryReader.CreateMtomReader(stream, MtomMessageEncoderFactory.GetSupportedEncodings(), contentType, this.readerQuotas, this.maxBufferSize, onStreamedReaderClose);
|
|
if (TD.ReadPoolMissIsEnabled())
|
|
{
|
|
TD.ReadPoolMiss(xmlReader.GetType().Name);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (xmlReader != null && xmlReader is IXmlTextReaderInitializer)
|
|
{
|
|
((IXmlTextReaderInitializer)xmlReader).SetInput(stream, TextMessageEncoderFactory.GetEncodingFromContentType(contentType, this.contentEncodingMap), this.readerQuotas, onStreamedReaderClose);
|
|
}
|
|
else
|
|
{
|
|
xmlReader = XmlDictionaryReader.CreateTextReader(stream, TextMessageEncoderFactory.GetEncodingFromContentType(contentType, this.contentEncodingMap), this.readerQuotas, onStreamedReaderClose);
|
|
if (TD.ReadPoolMissIsEnabled())
|
|
{
|
|
TD.ReadPoolMiss(xmlReader.GetType().Name);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch (FormatException fe)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new CommunicationException(
|
|
SR.GetString(SR.SFxErrorCreatingMtomReader), fe));
|
|
}
|
|
catch (XmlException xe)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new CommunicationException(
|
|
SR.GetString(SR.SFxErrorCreatingMtomReader), xe));
|
|
}
|
|
|
|
return xmlReader;
|
|
}
|
|
|
|
void ReturnStreamedReader(XmlDictionaryReader xmlReader)
|
|
{
|
|
streamedReaderPool.Return(xmlReader);
|
|
}
|
|
|
|
SynchronizedPool<RecycledMessageState> RecycledStatePool
|
|
{
|
|
get
|
|
{
|
|
if (recycledStatePool == null)
|
|
{
|
|
lock (thisLock)
|
|
{
|
|
if (recycledStatePool == null)
|
|
{
|
|
recycledStatePool = new SynchronizedPool<RecycledMessageState>(maxReadPoolSize);
|
|
}
|
|
}
|
|
}
|
|
return recycledStatePool;
|
|
}
|
|
}
|
|
|
|
string ITraceSourceStringProvider.GetSourceString()
|
|
{
|
|
return base.GetTraceSourceString();
|
|
}
|
|
|
|
class MtomBufferedMessageData : BufferedMessageData
|
|
{
|
|
MtomMessageEncoder messageEncoder;
|
|
Pool<XmlDictionaryReader> readerPool;
|
|
internal string ContentType;
|
|
OnXmlDictionaryReaderClose onClose;
|
|
|
|
public MtomBufferedMessageData(MtomMessageEncoder 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; }
|
|
}
|
|
|
|
protected override void OnClosed()
|
|
{
|
|
messageEncoder.ReturnBufferedData(this);
|
|
}
|
|
|
|
protected override XmlDictionaryReader TakeXmlReader()
|
|
{
|
|
try
|
|
{
|
|
ArraySegment<byte> buffer = this.Buffer;
|
|
|
|
XmlDictionaryReader xmlReader = readerPool.Take();
|
|
if (ContentType == null || messageEncoder.IsMTOMContentType(ContentType))
|
|
{
|
|
if (xmlReader != null && xmlReader is IXmlMtomReaderInitializer)
|
|
{
|
|
((IXmlMtomReaderInitializer)xmlReader).SetInput(buffer.Array, buffer.Offset, buffer.Count, MtomMessageEncoderFactory.GetSupportedEncodings(), ContentType, this.Quotas, this.messageEncoder.MaxBufferSize, onClose);
|
|
}
|
|
else
|
|
{
|
|
xmlReader = XmlDictionaryReader.CreateMtomReader(buffer.Array, buffer.Offset, buffer.Count, MtomMessageEncoderFactory.GetSupportedEncodings(), ContentType, this.Quotas, this.messageEncoder.MaxBufferSize, onClose);
|
|
if (TD.ReadPoolMissIsEnabled())
|
|
{
|
|
TD.ReadPoolMiss(xmlReader.GetType().Name);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (xmlReader != null && xmlReader is IXmlTextReaderInitializer)
|
|
{
|
|
((IXmlTextReaderInitializer)xmlReader).SetInput(buffer.Array, buffer.Offset, buffer.Count, TextMessageEncoderFactory.GetEncodingFromContentType(ContentType, this.messageEncoder.contentEncodingMap), this.Quotas, onClose);
|
|
}
|
|
else
|
|
{
|
|
xmlReader = XmlDictionaryReader.CreateTextReader(buffer.Array, buffer.Offset, buffer.Count, TextMessageEncoderFactory.GetEncodingFromContentType(ContentType, this.messageEncoder.contentEncodingMap), this.Quotas, onClose);
|
|
if (TD.ReadPoolMissIsEnabled())
|
|
{
|
|
TD.ReadPoolMiss(xmlReader.GetType().Name);
|
|
}
|
|
}
|
|
}
|
|
return xmlReader;
|
|
}
|
|
catch (FormatException fe)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new CommunicationException(
|
|
SR.GetString(SR.SFxErrorCreatingMtomReader), fe));
|
|
}
|
|
catch (XmlException xe)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new CommunicationException(
|
|
SR.GetString(SR.SFxErrorCreatingMtomReader), xe));
|
|
}
|
|
}
|
|
|
|
protected override void ReturnXmlReader(XmlDictionaryReader xmlReader)
|
|
{
|
|
if (xmlReader != null)
|
|
readerPool.Return(xmlReader);
|
|
}
|
|
}
|
|
|
|
class MtomBufferedMessageWriter : BufferedMessageWriter
|
|
{
|
|
MtomMessageEncoder messageEncoder;
|
|
internal bool WriteMessageHeaders;
|
|
internal string StartInfo;
|
|
internal string StartUri;
|
|
internal string Boundary;
|
|
internal int MaxSizeInBytes = int.MaxValue;
|
|
XmlDictionaryWriter writer;
|
|
|
|
public MtomBufferedMessageWriter(MtomMessageEncoder messageEncoder)
|
|
{
|
|
this.messageEncoder = messageEncoder;
|
|
}
|
|
|
|
protected override XmlDictionaryWriter TakeXmlWriter(Stream stream)
|
|
{
|
|
XmlDictionaryWriter returnedWriter = writer;
|
|
if (returnedWriter == null)
|
|
{
|
|
returnedWriter = XmlDictionaryWriter.CreateMtomWriter(stream, messageEncoder.writeEncoding, MaxSizeInBytes, StartInfo, Boundary, StartUri, WriteMessageHeaders, false);
|
|
}
|
|
else
|
|
{
|
|
writer = null;
|
|
((IXmlMtomWriterInitializer)returnedWriter).SetOutput(stream, messageEncoder.writeEncoding, MaxSizeInBytes, StartInfo, Boundary, StartUri, WriteMessageHeaders, false);
|
|
}
|
|
if (messageEncoder.writeEncoding.WebName != "utf-8")
|
|
returnedWriter.WriteStartDocument();
|
|
return returnedWriter;
|
|
}
|
|
|
|
protected override void ReturnXmlWriter(XmlDictionaryWriter writer)
|
|
{
|
|
writer.Close();
|
|
|
|
if (this.writer == null)
|
|
this.writer = writer;
|
|
}
|
|
}
|
|
|
|
class WriteMessageAsyncResult : ScheduleActionItemAsyncResult
|
|
{
|
|
string boundary;
|
|
MtomMessageEncoder encoder;
|
|
Message message;
|
|
Stream stream;
|
|
bool writeBoundary;
|
|
|
|
public WriteMessageAsyncResult(Message message, Stream stream, MtomMessageEncoder encoder, AsyncCallback callback, object state)
|
|
: base(callback, state)
|
|
{
|
|
Fx.Assert(encoder != null, "encoder should never be null");
|
|
|
|
this.encoder = encoder;
|
|
this.message = message;
|
|
this.stream = stream;
|
|
|
|
Schedule();
|
|
}
|
|
|
|
public WriteMessageAsyncResult(Message message, Stream stream, string boundary, MtomMessageEncoder encoder, AsyncCallback callback, object state)
|
|
: base(callback, state)
|
|
{
|
|
Fx.Assert(encoder != null, "encoder should never be null");
|
|
|
|
this.encoder = encoder;
|
|
this.message = message;
|
|
this.stream = stream;
|
|
this.boundary = boundary;
|
|
|
|
this.writeBoundary = true;
|
|
|
|
Schedule();
|
|
}
|
|
|
|
protected override void OnDoWork()
|
|
{
|
|
this.encoder.WriteMessage(this.message, this.stream, this.encoder.GenerateStartInfoString(), string.IsNullOrEmpty(this.boundary) ? null : this.boundary, this.writeBoundary ? MtomMessageEncoder.mtomStartUri : null, !this.writeBoundary /*writeMessageHeaders*/);
|
|
}
|
|
}
|
|
}
|
|
}
|