129 lines
4.0 KiB
C#
129 lines
4.0 KiB
C#
//------------------------------------------------------------
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
//------------------------------------------------------------
|
|
namespace System.ServiceModel.Channels
|
|
{
|
|
using System.IO;
|
|
using System.ServiceModel;
|
|
using System.Diagnostics;
|
|
using System.ServiceModel.Diagnostics.Application;
|
|
|
|
class MaxMessageSizeStream : DelegatingStream
|
|
{
|
|
long maxMessageSize;
|
|
long totalBytesRead;
|
|
long bytesWritten;
|
|
|
|
public MaxMessageSizeStream(Stream stream, long maxMessageSize)
|
|
: base(stream)
|
|
{
|
|
this.maxMessageSize = maxMessageSize;
|
|
}
|
|
|
|
public override IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
|
|
{
|
|
count = PrepareRead(count);
|
|
return base.BeginRead(buffer, offset, count, callback, state);
|
|
}
|
|
|
|
public override IAsyncResult BeginWrite(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
|
|
{
|
|
PrepareWrite(count);
|
|
return base.BeginWrite(buffer, offset, count, callback, state);
|
|
}
|
|
|
|
public override int EndRead(IAsyncResult result)
|
|
{
|
|
return FinishRead(base.EndRead(result));
|
|
}
|
|
|
|
public override int Read(byte[] buffer, int offset, int count)
|
|
{
|
|
count = PrepareRead(count);
|
|
return FinishRead(base.Read(buffer, offset, count));
|
|
}
|
|
|
|
public override int ReadByte()
|
|
{
|
|
PrepareRead(1);
|
|
int i = base.ReadByte();
|
|
if (i != -1)
|
|
FinishRead(1);
|
|
return i;
|
|
}
|
|
|
|
public override void Write(byte[] buffer, int offset, int count)
|
|
{
|
|
PrepareWrite(count);
|
|
base.Write(buffer, offset, count);
|
|
}
|
|
|
|
public override void WriteByte(byte value)
|
|
{
|
|
PrepareWrite(1);
|
|
base.WriteByte(value);
|
|
}
|
|
|
|
internal static Exception CreateMaxReceivedMessageSizeExceededException(long maxMessageSize)
|
|
{
|
|
string message = SR.GetString(SR.MaxReceivedMessageSizeExceeded, maxMessageSize);
|
|
Exception inner = new QuotaExceededException(message);
|
|
|
|
if (TD.MaxReceivedMessageSizeExceededIsEnabled())
|
|
{
|
|
TD.MaxReceivedMessageSizeExceeded(message);
|
|
}
|
|
|
|
return new CommunicationException(message, inner);
|
|
}
|
|
|
|
internal static Exception CreateMaxSentMessageSizeExceededException(long maxMessageSize)
|
|
{
|
|
string message = SR.GetString(SR.MaxSentMessageSizeExceeded, maxMessageSize);
|
|
Exception inner = new QuotaExceededException(message);
|
|
|
|
if (TD.MaxSentMessageSizeExceededIsEnabled())
|
|
{
|
|
TD.MaxSentMessageSizeExceeded(message);
|
|
}
|
|
|
|
return new CommunicationException(message, inner);
|
|
}
|
|
|
|
int PrepareRead(int bytesToRead)
|
|
{
|
|
if (totalBytesRead >= maxMessageSize)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(CreateMaxReceivedMessageSizeExceededException(maxMessageSize));
|
|
}
|
|
|
|
long bytesRemaining = maxMessageSize - totalBytesRead;
|
|
|
|
if (bytesRemaining > int.MaxValue)
|
|
{
|
|
return bytesToRead;
|
|
}
|
|
else
|
|
{
|
|
return Math.Min(bytesToRead, (int)(maxMessageSize - totalBytesRead));
|
|
}
|
|
}
|
|
|
|
int FinishRead(int bytesRead)
|
|
{
|
|
totalBytesRead += bytesRead;
|
|
return bytesRead;
|
|
}
|
|
|
|
void PrepareWrite(int bytesToWrite)
|
|
{
|
|
if (bytesWritten + bytesToWrite > maxMessageSize)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(CreateMaxSentMessageSizeExceededException(maxMessageSize));
|
|
}
|
|
|
|
bytesWritten += bytesToWrite;
|
|
}
|
|
}
|
|
}
|