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
390 lines
14 KiB
C#
390 lines
14 KiB
C#
//------------------------------------------------------------
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
//------------------------------------------------------------
|
|
|
|
namespace System.ServiceModel.Channels
|
|
{
|
|
using System;
|
|
using System.Runtime;
|
|
using System.ServiceModel.Diagnostics;
|
|
using System.Xml;
|
|
using System.IO;
|
|
using System.Runtime.Diagnostics;
|
|
using SMTD = System.ServiceModel.Diagnostics.Application.TD;
|
|
using System.Diagnostics;
|
|
|
|
class ByteStreamMessageEncoder : MessageEncoder, IStreamedMessageEncoder, IWebMessageEncoderHelper, ITraceSourceStringProvider
|
|
{
|
|
string traceSourceString;
|
|
string maxReceivedMessageSizeExceededResourceString;
|
|
string maxSentMessageSizeExceededResourceString;
|
|
XmlDictionaryReaderQuotas quotas;
|
|
XmlDictionaryReaderQuotas bufferedReadReaderQuotas;
|
|
|
|
/// <summary>
|
|
/// Specifies if this encoder produces Messages that provide a body reader (with the Message.GetReaderAtBodyContents() method) positioned on content.
|
|
/// See the comments on 'IWebMessageEncoderHelper' for more info.
|
|
/// </summary>
|
|
bool moveBodyReaderToContent = false; // false because we want the ByteStreamMessageEncoder to be compatible with previous releases
|
|
|
|
public ByteStreamMessageEncoder(XmlDictionaryReaderQuotas quotas)
|
|
{
|
|
this.quotas = new XmlDictionaryReaderQuotas();
|
|
quotas.CopyTo(this.quotas);
|
|
|
|
this.bufferedReadReaderQuotas = EncoderHelpers.GetBufferedReadQuotas(this.quotas);
|
|
|
|
this.maxSentMessageSizeExceededResourceString = SR.MaxSentMessageSizeExceeded("{0}");
|
|
this.maxReceivedMessageSizeExceededResourceString = SR.MaxReceivedMessageSizeExceeded("{0}");
|
|
}
|
|
|
|
void IWebMessageEncoderHelper.EnableBodyReaderMoveToContent()
|
|
{
|
|
this.moveBodyReaderToContent = true;
|
|
}
|
|
|
|
public override string ContentType
|
|
{
|
|
get { return null; }
|
|
}
|
|
|
|
public override string MediaType
|
|
{
|
|
get { return null; }
|
|
}
|
|
|
|
public override MessageVersion MessageVersion
|
|
{
|
|
get { return MessageVersion.None; }
|
|
}
|
|
|
|
public override bool IsContentTypeSupported(string contentType)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
public override Message ReadMessage(Stream stream, int maxSizeOfHeaders, string contentType)
|
|
{
|
|
if (stream == null)
|
|
{
|
|
throw FxTrace.Exception.ArgumentNull("stream");
|
|
}
|
|
|
|
if (TD.ByteStreamMessageDecodingStartIsEnabled())
|
|
{
|
|
TD.ByteStreamMessageDecodingStart();
|
|
}
|
|
|
|
Message message = ByteStreamMessage.CreateMessage(stream, this.quotas, this.moveBodyReaderToContent);
|
|
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 Message ReadMessage(ArraySegment<byte> buffer, BufferManager bufferManager, string contentType)
|
|
{
|
|
if (buffer.Array == null)
|
|
{
|
|
throw FxTrace.Exception.ArgumentNull("buffer.Array");
|
|
}
|
|
|
|
if (bufferManager == null)
|
|
{
|
|
throw FxTrace.Exception.ArgumentNull("bufferManager");
|
|
}
|
|
|
|
if (TD.ByteStreamMessageDecodingStartIsEnabled())
|
|
{
|
|
TD.ByteStreamMessageDecodingStart();
|
|
}
|
|
|
|
ByteStreamBufferedMessageData messageData = new ByteStreamBufferedMessageData(buffer, bufferManager);
|
|
|
|
Message message = ByteStreamMessage.CreateMessage(messageData, this.bufferedReadReaderQuotas, this.moveBodyReaderToContent);
|
|
message.Properties.Encoder = this;
|
|
|
|
if (SMTD.MessageReadByEncoderIsEnabled())
|
|
{
|
|
SMTD.MessageReadByEncoder(
|
|
EventTraceActivityHelper.TryExtractActivity(message, true),
|
|
buffer.Count,
|
|
this);
|
|
}
|
|
|
|
if (MessageLogger.LogMessagesAtTransportLevel)
|
|
{
|
|
MessageLogger.LogMessage(ref message, MessageLoggingSource.TransportReceive);
|
|
}
|
|
|
|
return message;
|
|
}
|
|
|
|
public override void WriteMessage(Message message, Stream stream)
|
|
{
|
|
if (message == null)
|
|
{
|
|
throw FxTrace.Exception.ArgumentNull("message");
|
|
}
|
|
if (stream == null)
|
|
{
|
|
throw FxTrace.Exception.ArgumentNull("stream");
|
|
}
|
|
|
|
ThrowIfMismatchedMessageVersion(message);
|
|
|
|
EventTraceActivity eventTraceActivity = null;
|
|
if (TD.ByteStreamMessageEncodingStartIsEnabled())
|
|
{
|
|
eventTraceActivity = EventTraceActivityHelper.TryExtractActivity(message);
|
|
TD.ByteStreamMessageEncodingStart(eventTraceActivity);
|
|
}
|
|
|
|
message.Properties.Encoder = this;
|
|
|
|
if (MessageLogger.LogMessagesAtTransportLevel)
|
|
{
|
|
MessageLogger.LogMessage(ref message, MessageLoggingSource.TransportSend);
|
|
}
|
|
|
|
using (XmlWriter writer = new XmlByteStreamWriter(stream, false))
|
|
{
|
|
message.WriteMessage(writer);
|
|
writer.Flush();
|
|
}
|
|
|
|
if (SMTD.StreamedMessageWrittenByEncoderIsEnabled())
|
|
{
|
|
SMTD.StreamedMessageWrittenByEncoder(eventTraceActivity ?? EventTraceActivityHelper.TryExtractActivity(message));
|
|
}
|
|
}
|
|
|
|
public override IAsyncResult BeginWriteMessage(Message message, Stream stream, AsyncCallback callback, object state)
|
|
{
|
|
if (message == null)
|
|
{
|
|
throw FxTrace.Exception.ArgumentNull("message");
|
|
}
|
|
if (stream == null)
|
|
{
|
|
throw FxTrace.Exception.ArgumentNull("stream");
|
|
}
|
|
|
|
ThrowIfMismatchedMessageVersion(message);
|
|
message.Properties.Encoder = this;
|
|
|
|
if (MessageLogger.LogMessagesAtTransportLevel)
|
|
{
|
|
MessageLogger.LogMessage(ref message, MessageLoggingSource.TransportSend);
|
|
}
|
|
|
|
return new WriteMessageAsyncResult(message, stream, callback, state);
|
|
}
|
|
|
|
public override void EndWriteMessage(IAsyncResult result)
|
|
{
|
|
WriteMessageAsyncResult.End(result);
|
|
}
|
|
|
|
public override ArraySegment<byte> WriteMessage(Message message, int maxMessageSize, BufferManager bufferManager, int messageOffset)
|
|
{
|
|
if (message == null)
|
|
{
|
|
throw FxTrace.Exception.ArgumentNull("message");
|
|
}
|
|
if (bufferManager == null)
|
|
{
|
|
throw FxTrace.Exception.ArgumentNull("bufferManager");
|
|
}
|
|
if (maxMessageSize < 0)
|
|
{
|
|
throw FxTrace.Exception.ArgumentOutOfRange("maxMessageSize", maxMessageSize, SR.ArgumentOutOfMinRange(0));
|
|
}
|
|
if (messageOffset < 0)
|
|
{
|
|
throw FxTrace.Exception.ArgumentOutOfRange("messageOffset", messageOffset, SR.ArgumentOutOfMinRange(0));
|
|
}
|
|
|
|
EventTraceActivity eventTraceActivity = null;
|
|
if (TD.ByteStreamMessageEncodingStartIsEnabled())
|
|
{
|
|
eventTraceActivity = EventTraceActivityHelper.TryExtractActivity(message);
|
|
TD.ByteStreamMessageEncodingStart(eventTraceActivity);
|
|
}
|
|
|
|
ThrowIfMismatchedMessageVersion(message);
|
|
message.Properties.Encoder = this;
|
|
|
|
ArraySegment<byte> messageBuffer;
|
|
int size;
|
|
|
|
using (BufferManagerOutputStream stream = new BufferManagerOutputStream(maxSentMessageSizeExceededResourceString, 0, maxMessageSize, bufferManager))
|
|
{
|
|
stream.Skip(messageOffset);
|
|
using (XmlWriter writer = new XmlByteStreamWriter(stream, true))
|
|
{
|
|
message.WriteMessage(writer);
|
|
writer.Flush();
|
|
byte[] bytes = stream.ToArray(out size);
|
|
messageBuffer = new ArraySegment<byte>(bytes, messageOffset, size - messageOffset);
|
|
}
|
|
}
|
|
|
|
if (SMTD.MessageWrittenByEncoderIsEnabled())
|
|
{
|
|
SMTD.MessageWrittenByEncoder(
|
|
eventTraceActivity ?? EventTraceActivityHelper.TryExtractActivity(message),
|
|
messageBuffer.Count,
|
|
this);
|
|
}
|
|
|
|
if (MessageLogger.LogMessagesAtTransportLevel)
|
|
{
|
|
// DevDiv#486728
|
|
// Don't pass in a buffer manager to avoid returning 'messageBuffer" to the bufferManager twice.
|
|
ByteStreamBufferedMessageData messageData = new ByteStreamBufferedMessageData(messageBuffer, null);
|
|
using (XmlReader reader = new XmlBufferedByteStreamReader(messageData, this.quotas))
|
|
{
|
|
MessageLogger.LogMessage(ref message, reader, MessageLoggingSource.TransportSend);
|
|
}
|
|
}
|
|
|
|
return messageBuffer;
|
|
}
|
|
|
|
public override string ToString()
|
|
{
|
|
return ByteStreamMessageUtility.EncoderName;
|
|
}
|
|
|
|
public Stream GetResponseMessageStream(Message message)
|
|
{
|
|
if (message == null)
|
|
{
|
|
throw FxTrace.Exception.ArgumentNull("message");
|
|
}
|
|
|
|
ThrowIfMismatchedMessageVersion(message);
|
|
|
|
if (!ByteStreamMessage.IsInternalByteStreamMessage(message))
|
|
{
|
|
return null;
|
|
}
|
|
|
|
return message.GetBody<Stream>();
|
|
}
|
|
|
|
string ITraceSourceStringProvider.GetSourceString()
|
|
{
|
|
// Other MessageEncoders use base.GetTraceSourceString but that would require a public api change in MessageEncoder
|
|
// as ByteStreamMessageEncoder is in a different assemly. The same logic is reimplemented here.
|
|
if (this.traceSourceString == null)
|
|
{
|
|
this.traceSourceString = DiagnosticTraceBase.CreateDefaultSourceString(this);
|
|
}
|
|
|
|
return this.traceSourceString;
|
|
}
|
|
|
|
class WriteMessageAsyncResult : AsyncResult
|
|
{
|
|
Message message;
|
|
Stream stream;
|
|
static Action<IAsyncResult, Exception> onCleanup;
|
|
XmlByteStreamWriter writer;
|
|
EventTraceActivity eventTraceActivity;
|
|
|
|
public WriteMessageAsyncResult(Message message, Stream stream, AsyncCallback callback, object state)
|
|
: base(callback, state)
|
|
{
|
|
this.message = message;
|
|
this.stream = stream;
|
|
this.writer = new XmlByteStreamWriter(stream, false);
|
|
if (onCleanup == null)
|
|
{
|
|
onCleanup = new Action<IAsyncResult, Exception>(Cleanup);
|
|
}
|
|
this.OnCompleting += onCleanup;
|
|
Exception completionException = null;
|
|
bool completeSelf = false;
|
|
|
|
this.eventTraceActivity = null;
|
|
if (TD.ByteStreamMessageEncodingStartIsEnabled())
|
|
{
|
|
this.eventTraceActivity = EventTraceActivityHelper.TryExtractActivity(message);
|
|
TD.ByteStreamMessageEncodingStart(this.eventTraceActivity);
|
|
}
|
|
|
|
try
|
|
{
|
|
IAsyncResult result = message.BeginWriteMessage(writer, PrepareAsyncCompletion(HandleWriteMessage), this);
|
|
completeSelf = SyncContinue(result);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
if (Fx.IsFatal(ex))
|
|
{
|
|
throw;
|
|
}
|
|
completeSelf = true;
|
|
completionException = ex;
|
|
}
|
|
|
|
if (completeSelf)
|
|
{
|
|
this.Complete(true, completionException);
|
|
}
|
|
}
|
|
|
|
static bool HandleWriteMessage(IAsyncResult result)
|
|
{
|
|
WriteMessageAsyncResult thisPtr = (WriteMessageAsyncResult)result.AsyncState;
|
|
|
|
thisPtr.message.EndWriteMessage(result);
|
|
thisPtr.writer.Flush();
|
|
|
|
if (SMTD.MessageWrittenAsynchronouslyByEncoderIsEnabled())
|
|
{
|
|
SMTD.MessageWrittenAsynchronouslyByEncoder(
|
|
thisPtr.eventTraceActivity ?? EventTraceActivityHelper.TryExtractActivity(thisPtr.message));
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
static void Cleanup(IAsyncResult result, Exception ex)
|
|
{
|
|
WriteMessageAsyncResult thisPtr = (WriteMessageAsyncResult)result;
|
|
bool success = false;
|
|
try
|
|
{
|
|
thisPtr.writer.Close();
|
|
success = true;
|
|
}
|
|
finally
|
|
{
|
|
if (!success)
|
|
{
|
|
FxTrace.Exception.TraceHandledException(ex, TraceEventType.Information);
|
|
}
|
|
}
|
|
}
|
|
|
|
public static void End(IAsyncResult result)
|
|
{
|
|
AsyncResult.End<WriteMessageAsyncResult>(result);
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|