1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
|
//------------------------------------------------------------
// 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;
}
}
}
|
