public static ArraySegment<byte> Encode(Uri uri, ArraySegment<byte> messageBuffer, BufferManager bufferManager)
{
byte[] uriBuffer = UnicodeEncoding.Unicode.GetBytes(uri.ToString());
byte[] uriLengthBuffer = EncodeInt(uriBuffer.Length);
byte[] payloadLengthBuffer = EncodeInt(messageBuffer.Count);
// Encode the following fields:
// Uri length (4 bytes)
// Uri (size specified by uri length)
// Payload length (4 bytes)
// Payload (size specified by payload length)
byte[] buffer = bufferManager.TakeBuffer(uriLengthBuffer.Length + uriBuffer.Length +
payloadLengthBuffer.Length + messageBuffer.Count);
int destOffset = 0;
Buffer.BlockCopy(uriLengthBuffer, 0, buffer, destOffset, uriLengthBuffer.Length);
destOffset += uriLengthBuffer.Length;
Buffer.BlockCopy(uriBuffer, 0, buffer, destOffset, uriBuffer.Length);
destOffset += uriBuffer.Length;
Buffer.BlockCopy(payloadLengthBuffer, 0, buffer, destOffset, payloadLengthBuffer.Length);
destOffset += payloadLengthBuffer.Length;
Buffer.BlockCopy(messageBuffer.Array, messageBuffer.Offset, buffer, destOffset, messageBuffer.Count);
bufferManager.ReturnBuffer(messageBuffer.Array);
return new ArraySegment<byte>(buffer);
}
public static IObservable<DisposableByteBuffer> ToFrameStreamObservable(this Stream stream, BufferManager bufferManager)
{
return Observable.Create<DisposableByteBuffer>(async (observer, token) =>
{
var headerBuffer = new byte[sizeof(int)];
try
{
while (!token.IsCancellationRequested)
{
if (await stream.ReadBytesCompletelyAsync(headerBuffer, headerBuffer.Length, token) != headerBuffer.Length)
break;
var length = BitConverter.ToInt32(headerBuffer, 0);
var buffer = bufferManager.TakeBuffer(length);
if (await stream.ReadBytesCompletelyAsync(buffer, length, token) != length)
break;
observer.OnNext(new DisposableByteBuffer(buffer, length, Disposable.Create(() => bufferManager.ReturnBuffer(buffer))));
}
observer.OnCompleted();
}
catch (Exception error)
{
observer.OnError(error);
}
});
}
public LidgrenNetChannel(NetConnection connection, BufferManager bufferManager)
{
_connection = connection;
_bufferManager = bufferManager;
_buffer = _bufferManager.TakeBuffer(1024*1024);
_stream = new MemoryStream(_buffer);
_writer = new BinaryWriter(_stream);
}
/// <summary>
/// Initializes a new buffer instance
/// </summary>
/// <param name="manager">
/// The manager for this buffer
/// </param>
/// <param name="size">
/// The size of the buffer to allocate, in bytes
/// </param>
public ManagedBuffer(BufferManager manager, Int32 size)
{
if (manager == null)
throw new ArgumentNullException("manager");
if (size <= 0)
throw new ArgumentException("data");
this.manager = manager;
this.data = new ArraySegment<Byte>(manager.TakeBuffer(size));
}
public override ArraySegment <byte> WriteMessage(Message message, int maxMessageSize, BufferManager bufferManager, int messageOffset)
{
if (message == null)
{
throw new ArgumentNullException("message");
}
if (bufferManager == null)
{
throw new ArgumentNullException("bufferManager");
}
if (maxMessageSize < 0)
{
throw new ArgumentOutOfRangeException("maxMessageSize");
}
if (messageOffset < 0)
{
throw new ArgumentOutOfRangeException("messageOffset");
}
if (messageOffset > maxMessageSize)
{
throw new ArgumentException(
string.Format(
CultureInfo.CurrentCulture,
SR.ParameterMustBeLessThanOrEqualSecondParameter,
"messageOffset",
"maxMessageSize"));
}
message.Properties.Encoder = this;
HttpResponseMessage response = GetHttpResponseMessageOrThrow(message);
if (response.Content == null)
{
return(new ArraySegment <byte>());
}
byte[] messageBytes = response.Content.ReadAsByteArray();
int messageLength = messageBytes.Length;
int totalLength = messageLength + messageOffset;
if (totalLength > maxMessageSize)
{
throw new QuotaExceededException();
}
byte[] totalBytes = bufferManager.TakeBuffer(totalLength);
Array.Copy(messageBytes, 0, totalBytes, messageOffset, totalLength - messageOffset);
return(new ArraySegment <byte>(totalBytes, messageOffset, messageLength));
}
private void EnsureBufferAllocated()
{
if (_buffer == null)
{
if (_bufferManager != null)
{
_buffer = _bufferManager.TakeBuffer(_bufferSize);
}
else
{
_buffer = new byte[_bufferSize];
}
}
}
public BufferedMemoryStream(BufferManager bufferManager, int capacity)
{
if (bufferManager == null)
throw new ArgumentNullException("bufferManager");
if (capacity < 0)
throw new ArgumentOutOfRangeException("capacity", "Must be positive.");
_bufferManager = bufferManager;
_isWriter = true;
_buffer = _bufferManager.TakeBuffer(capacity);
_capacity = _buffer.Length;
_length = 0;
_isOpen = true;
}
private ArraySegment <byte> AddSessionInformationToMessage(ArraySegment <byte> messageData, BufferManager bufferManager, int maxMessageSize)
{
int num = 0;
byte[] array = messageData.Array;
if (this.writerSession.HasNewStrings)
{
IList <XmlDictionaryString> newStrings = this.writerSession.GetNewStrings();
for (int i = 0; i < newStrings.Count; i++)
{
int byteCount = Encoding.UTF8.GetByteCount(newStrings[i].Value);
num += IntEncoder.GetEncodedSize(byteCount) + byteCount;
}
int num4 = messageData.Offset + messageData.Count;
int num5 = maxMessageSize - num4;
if ((num5 - num) < 0)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new QuotaExceededException(System.ServiceModel.SR.GetString("MaxSentMessageSizeExceeded", new object[] { maxMessageSize })));
}
int bufferSize = (messageData.Offset + messageData.Count) + num;
if (array.Length < bufferSize)
{
byte[] dst = bufferManager.TakeBuffer(bufferSize);
Buffer.BlockCopy(array, messageData.Offset, dst, messageData.Offset, messageData.Count);
bufferManager.ReturnBuffer(array);
array = dst;
}
Buffer.BlockCopy(array, messageData.Offset, array, messageData.Offset + num, messageData.Count);
int num7 = messageData.Offset;
for (int j = 0; j < newStrings.Count; j++)
{
string s = newStrings[j].Value;
int num9 = Encoding.UTF8.GetByteCount(s);
num7 += IntEncoder.Encode(num9, array, num7);
num7 += Encoding.UTF8.GetBytes(s, 0, s.Length, array, num7);
}
this.writerSession.ClearNewStrings();
}
int encodedSize = IntEncoder.GetEncodedSize(num);
int offset = messageData.Offset - encodedSize;
int count = (encodedSize + messageData.Count) + num;
IntEncoder.Encode(num, array, offset);
return(new ArraySegment <byte>(array, offset, count));
}
public override ArraySegment<byte> WriteMessage(Message message, int maxMessageSize, BufferManager bufferManager, int messageOffset)
{
MemoryStream stream = new MemoryStream();
XmlWriter writer = XmlWriter.Create(stream, this.writerSettings);
message.WriteMessage(writer);
writer.Close();
byte[] messageBytes = stream.GetBuffer();
int messageLength = (int)stream.Position;
stream.Close();
int totalLength = messageLength + messageOffset;
byte[] totalBytes = bufferManager.TakeBuffer(totalLength);
Array.Copy(messageBytes, 0, totalBytes, messageOffset, messageLength);
ArraySegment<byte> byteArray = new ArraySegment<byte>(totalBytes, messageOffset, messageLength);
return byteArray;
}
public override Message ReadMessage(ArraySegment<byte> buffer, BufferManager bufferManager, string contentType)
{
var bytes = new byte[buffer.Count];
Array.Copy(buffer.Array, buffer.Offset, bytes, 0, bytes.Length);
var message = new UTF8Encoding(true).GetString(bytes);
// Сохраняем ответ в файл содержащий actor
File.WriteAllText("D:\\TrueClientResponseActor.xml", message);
var m = message.Replace("s:actor=\"" + SMEVActor + "\"", "");
var bytes2 = new UTF8Encoding().GetBytes(m);
// Сохраняем ответ в файл уже без actor
File.WriteAllBytes("D:\\TrueClientResponse.xml", bytes2);
var length = bytes2.Length;
const int zero = 0;
var num = length + zero;
var array = bufferManager.TakeBuffer(num);
Array.Copy(bytes2, 0, array, zero, num);
buffer = new ArraySegment<byte>(array, zero, num);
return innerEncoder.ReadMessage(buffer, bufferManager, contentType);
}
public override ArraySegment <byte> WriteMessage(
Message message, int maxMessageSize,
BufferManager bufferManager, int messageOffset)
{
VerifyMessageVersion(message);
ArraySegment <byte> seg = new ArraySegment <byte> (
bufferManager.TakeBuffer(maxMessageSize),
messageOffset, maxMessageSize);
XmlWriterSettings s = new XmlWriterSettings();
s.Encoding = encoding;
using (XmlWriter w = XmlWriter.Create(
new MemoryStream(seg.Array, seg.Offset, seg.Count), s)) {
message.WriteMessage(
XmlDictionaryWriter.CreateDictionaryWriter(w));
}
return(seg);
}
public ArraySegment<byte> WriteMessage(MessageEncoder encoder, Message message, int maxMessageSize, BufferManager bufferManager, int messageOffset)
{
MemoryStream stream = new MemoryStream();
var writer = new StreamWriter(stream);
writer = xmlToCvsTranslator.Translate(message.GetReaderAtBodyContents(), writer);
writer.Flush();
byte[] messageBytes = stream.GetBuffer();
int messageLength = (int)stream.Position;
int totalLength = messageLength + messageOffset;
byte[] totalBytes = bufferManager.TakeBuffer(totalLength);
Array.Copy(messageBytes, 0, totalBytes, messageOffset, messageLength);
ArraySegment<byte> byteArray = new ArraySegment<byte>(totalBytes, messageOffset, messageLength);
writer.Close();
return byteArray;
}
public void Reinitialize(int initialSize, int maxSizeQuota, int effectiveMaxSize, BufferManager bufferManager)
{
Contract.Assert(!_initialized, "Clear must be called before re-initializing stream");
if (bufferManager == null)
{
throw Error.ArgumentNull("bufferManager");
}
_theMaxSizeQuota = maxSizeQuota;
_maxSize = effectiveMaxSize;
_bufferManager = bufferManager;
_currentChunk = bufferManager.TakeBuffer(initialSize);
_currentChunkSize = 0;
_totalSize = 0;
_chunkCount = 1;
_chunks[0] = _currentChunk;
_initialized = true;
}
internal static void DecompressBuffer(ref ArraySegment <byte> buffer, BufferManager bufferManager, CompressionFormat compressionFormat, long maxReceivedMessageSize)
{
MemoryStream memoryStream = new MemoryStream(buffer.Array, buffer.Offset, buffer.Count);
int maxDecompressedSize = (int)Math.Min(maxReceivedMessageSize, int.MaxValue);
using (BufferManagerOutputStream bufferedOutStream = new BufferManagerOutputStream(SR.MaxReceivedMessageSizeExceeded, 1024, maxDecompressedSize, bufferManager))
{
bufferedOutStream.Write(buffer.Array, 0, buffer.Offset);
byte[] tempBuffer = bufferManager.TakeBuffer(DecompressBlockSize);
try
{
using (Stream ds = compressionFormat == CompressionFormat.GZip ?
(Stream) new GZipStream(memoryStream, CompressionMode.Decompress) :
(Stream) new DeflateStream(memoryStream, CompressionMode.Decompress))
{
while (true)
{
int bytesRead = ds.Read(tempBuffer, 0, DecompressBlockSize);
if (bytesRead > 0)
{
bufferedOutStream.Write(tempBuffer, 0, bytesRead);
}
else
{
break;
}
}
}
}
finally
{
bufferManager.ReturnBuffer(tempBuffer);
}
int length = 0;
byte[] decompressedBytes = bufferedOutStream.ToArray(out length);
bufferManager.ReturnBuffer(buffer.Array);
buffer = new ArraySegment <byte>(decompressedBytes, buffer.Offset, length - buffer.Offset);
}
}
internal static void DecompressBuffer(ref ArraySegment<byte> buffer, BufferManager bufferManager, CompressionFormat compressionFormat, long maxReceivedMessageSize)
{
MemoryStream memoryStream = new MemoryStream(buffer.Array, buffer.Offset, buffer.Count);
int maxDecompressedSize = (int)Math.Min(maxReceivedMessageSize, int.MaxValue);
using (BufferManagerOutputStream bufferedOutStream = new BufferManagerOutputStream(SR.MaxReceivedMessageSizeExceeded, 1024, maxDecompressedSize, bufferManager))
{
bufferedOutStream.Write(buffer.Array, 0, buffer.Offset);
byte[] tempBuffer = bufferManager.TakeBuffer(DecompressBlockSize);
try
{
using (Stream ds = compressionFormat == CompressionFormat.GZip ?
(Stream)new GZipStream(memoryStream, CompressionMode.Decompress) :
(Stream)new DeflateStream(memoryStream, CompressionMode.Decompress))
{
while (true)
{
int bytesRead = ds.Read(tempBuffer, 0, DecompressBlockSize);
if (bytesRead > 0)
{
bufferedOutStream.Write(tempBuffer, 0, bytesRead);
}
else
{
break;
}
}
}
}
finally
{
bufferManager.ReturnBuffer(tempBuffer);
}
int length = 0;
byte[] decompressedBytes = bufferedOutStream.ToArray(out length);
bufferManager.ReturnBuffer(buffer.Array);
buffer = new ArraySegment<byte>(decompressedBytes, buffer.Offset, length - buffer.Offset);
}
}
public string TestSendUDPToService(string ipaddress,int port)
{
Socket socket = new Socket(SocketType.Dgram, ProtocolType.Udp);
m_bufferManager = BufferManager.CreateBufferManager(100 * 1024, 1024);
for(int i =0 ;i<=50;i++)
{
AsyncClientToken asyncClientToken = new AsyncClientToken();
//asyncClientToken.HandlerReturnData = handlerReturnData;
asyncClientToken.Socket = socket;
//asyncClientToken.MessageID = messageID;
asyncClientToken.IP = ipaddress;
asyncClientToken.Port = port;
asyncClientToken.Buffer = m_bufferManager.TakeBuffer(1024);
IPEndPoint ipe = new IPEndPoint(IPAddress.Parse(asyncClientToken.IP), asyncClientToken.Port);
int sendCount = Encoding.UTF8.GetBytes("TestSendUDPToService" + i.ToString(), 0, ("TestSendUDPToService" + i.ToString()).Length, asyncClientToken.Buffer, 0);
CommonVariables.LogTool.Log(DateTime.Now.ToString(CommonFlag.F_DateTimeFormat) + " Send:" + asyncClientToken.IP + asyncClientToken.Port.ToString() + "TestSendUDPToService" + i.ToString());
socket.BeginSendTo(asyncClientToken.Buffer, 0, sendCount, SocketFlags.None, ipe, new AsyncCallback(SendCallback), asyncClientToken);
}
return null;
}
public ArraySegment<byte> WriteMessage(MessageEncoder encoder, Message message, int maxMessageSize, BufferManager bufferManager, int messageOffset)
{
MemoryStream stream = new MemoryStream();
StreamWriter sw = new StreamWriter(stream);
string methodName = null;
if (message.Properties.ContainsKey(JSONPBehavior.Name))
{
methodName = ((JSONPMessageProperty) (message.Properties[JSONPBehavior.Name])).MethodName;
}
if (methodName != null)
{
sw.Write(methodName + "( ");
sw.Flush();
}
XmlWriter writer = JsonReaderWriterFactory.CreateJsonWriter(stream);
message.WriteMessage(writer);
writer.Flush();
if (methodName != null)
{
sw.Write(" );");
sw.Flush();
}
byte[] messageBytes = stream.GetBuffer();
int messageLength = (int) stream.Position;
int totalLength = messageLength + messageOffset;
byte[] totalBytes = bufferManager.TakeBuffer(totalLength);
Array.Copy(messageBytes, 0, totalBytes, messageOffset, messageLength);
ArraySegment<byte> byteArray = new ArraySegment<byte>(totalBytes, messageOffset, messageLength);
writer.Close();
return byteArray;
}
public static IObservable<DisposableByteBuffer> ToFrameClientObservable(this Socket socket, SocketFlags socketFlags, BufferManager bufferManager, Selector selector)
{
return Observable.Create<DisposableByteBuffer>(observer =>
{
var headerState = new BufferState(new byte[sizeof(int)], 0, sizeof(int));
var contentState = new BufferState(null, 0, -1);
var selectMode = socketFlags.HasFlag(SocketFlags.OutOfBand) ? SelectMode.SelectError : SelectMode.SelectRead;
selector.AddCallback(selectMode, socket, _ =>
{
try
{
if (headerState.Length > 0)
{
headerState.Advance(socket.Receive(headerState.Bytes, headerState.Offset, headerState.Length, socketFlags));
if (headerState.Length == 0)
{
contentState.Length = BitConverter.ToInt32(headerState.Bytes, 0);
contentState.Offset = 0;
contentState.Bytes = bufferManager.TakeBuffer(contentState.Length);
}
}
if (contentState.Bytes != null)
{
contentState.Advance(socket.Receive(contentState.Bytes, contentState.Offset, contentState.Length, socketFlags));
if (contentState.Length == 0)
{
var managedBuffer = contentState.Bytes;
var length = contentState.Offset;
observer.OnNext(new DisposableByteBuffer(managedBuffer, length, Disposable.Create(() => bufferManager.ReturnBuffer(managedBuffer))));
contentState.Bytes = null;
headerState.Length = headerState.Offset;
headerState.Offset = 0;
}
}
}
catch (Exception exception)
{
if (!exception.IsWouldBlock())
observer.OnError(exception);
}
});
return Disposable.Create(() => selector.RemoveCallback(SelectMode.SelectRead, socket));
});
}
//Helper method to decompress an array of bytes
static ArraySegment<byte> DecompressBuffer(ArraySegment<byte> buffer, BufferManager bufferManager)
{
MemoryStream memoryStream = new MemoryStream(buffer.Array, buffer.Offset, buffer.Count);
MemoryStream decompressedStream = new MemoryStream();
int totalRead = 0;
int blockSize = 1024;
byte[] tempBuffer = bufferManager.TakeBuffer(blockSize);
using (GZipStream gzStream = new GZipStream(memoryStream, CompressionMode.Decompress))
{
while (true)
{
int bytesRead = gzStream.Read(tempBuffer, 0, blockSize);
if (bytesRead == 0)
break;
decompressedStream.Write(tempBuffer, 0, bytesRead);
totalRead += bytesRead;
}
}
bufferManager.ReturnBuffer(tempBuffer);
byte[] decompressedBytes = decompressedStream.ToArray();
byte[] bufferManagerBuffer = bufferManager.TakeBuffer(decompressedBytes.Length + buffer.Offset);
Array.Copy(buffer.Array, 0, bufferManagerBuffer, 0, buffer.Offset);
Array.Copy(decompressedBytes, 0, bufferManagerBuffer, buffer.Offset, decompressedBytes.Length);
ArraySegment<byte> byteArray = new ArraySegment<byte>(bufferManagerBuffer, buffer.Offset, decompressedBytes.Length);
bufferManager.ReturnBuffer(buffer.Array);
return byteArray;
}
/// <summary>
/// Decompress a buffer
/// </summary>
/// <param name="buffer"></param>
/// <param name="bufferManager"></param>
/// <returns></returns>
private static ArraySegment<byte> DecompressBuffer(ArraySegment<byte> buffer, BufferManager bufferManager)
{
// Create a new memory stream, and copy into it the buffer to decompress
MemoryStream memoryStream = new MemoryStream(buffer.Array, buffer.Offset, buffer.Count);
// Create a memory stream to store the decompressed data
MemoryStream decompressedStream = new MemoryStream();
// The totalRead stores the number of decompressed bytes
int totalRead = 0;
int blockSize = 1024;
// Allocate a temporary buffer to use with the decompression
byte[] tempBuffer = bufferManager.TakeBuffer(blockSize);
// Uncompress the compressed data
using (GZipStream gzStream = new GZipStream(memoryStream, CompressionMode.Decompress))
{
while (true)
{
// Read from the compressed data stream
int bytesRead = gzStream.Read(tempBuffer, 0, blockSize);
if (bytesRead == 0)
break;
// Write to the decompressed data stream
decompressedStream.Write(tempBuffer, 0, bytesRead);
totalRead += bytesRead;
}
}
// Release the temporary buffer
bufferManager.ReturnBuffer(tempBuffer);
// Convert the decompressed data stream into bytes array
byte[] decompressedBytes = decompressedStream.ToArray();
// Allocate a new buffer to store the message
byte[] bufferManagerBuffer = bufferManager.TakeBuffer(decompressedBytes.Length + buffer.Offset);
// Copy the bytes that comes before the compressed message in the buffer argument
Array.Copy(buffer.Array, 0, bufferManagerBuffer, 0, buffer.Offset);
// Copy the decompressed data
Array.Copy(decompressedBytes, 0, bufferManagerBuffer, buffer.Offset, decompressedBytes.Length);
// Create a new ArraySegment that points to the new message buffer
ArraySegment<byte> byteArray = new ArraySegment<byte>(bufferManagerBuffer, buffer.Offset, decompressedBytes.Length);
// Release the original message buffer
bufferManager.ReturnBuffer(buffer.Array);
return byteArray;
}
public override ArraySegment<byte> WriteMessage(Message message, int maxMessageSize, BufferManager bufferManager, int messageOffset)
{
if (message == null)
{
throw new ArgumentNullException("message");
}
if (bufferManager == null)
{
throw new ArgumentNullException("bufferManager");
}
if (maxMessageSize < 0)
{
throw new ArgumentOutOfRangeException("maxMessageSize");
}
if (messageOffset < 0)
{
throw new ArgumentOutOfRangeException("messageOffset");
}
if (messageOffset > maxMessageSize)
{
throw new ArgumentException(
string.Format(
CultureInfo.CurrentCulture,
SR.ParameterMustBeLessThanOrEqualSecondParameter,
"messageOffset",
"maxMessageSize"));
}
message.Properties.Encoder = this;
HttpResponseMessage response = GetHttpResponseMessageOrThrow(message);
if (response.Content == null)
{
return new ArraySegment<byte>();
}
byte[] messageBytes = response.Content.ReadAsByteArray();
int messageLength = messageBytes.Length;
int totalLength = messageLength + messageOffset;
if (totalLength > maxMessageSize)
{
throw new QuotaExceededException();
}
byte[] totalBytes = bufferManager.TakeBuffer(totalLength);
Array.Copy(messageBytes, 0, totalBytes, messageOffset, totalLength - messageOffset);
return new ArraySegment<byte>(totalBytes, messageOffset, messageLength);
}
//Helper method to compress an array of bytes
private static ArraySegment<byte> CompressBuffer(ArraySegment<byte> buffer, BufferManager bufferManager,
int messageOffset,
CompressionAlgorithm compressionAlgorithm)
{
var memoryStream = new MemoryStream();
using (Stream compressedStream = compressionAlgorithm == CompressionAlgorithm.GZip
? new GZipStream(memoryStream, CompressionMode.Compress, true)
: (Stream)
new DeflateStream(memoryStream, CompressionMode.Compress, true)
)
{
compressedStream.Write(buffer.Array, buffer.Offset, buffer.Count);
}
byte[] compressedBytes = memoryStream.ToArray();
int totalLength = messageOffset + compressedBytes.Length;
byte[] bufferedBytes = bufferManager.TakeBuffer(totalLength);
Array.Copy(compressedBytes, 0, bufferedBytes, messageOffset, compressedBytes.Length);
bufferManager.ReturnBuffer(buffer.Array);
var byteArray = new ArraySegment<byte>(bufferedBytes, messageOffset,
compressedBytes.Length);
return byteArray;
}
private byte[] EnsureReadAsSize(Stream stream, int size, BufferManager manager)
{
byte[] buffer = manager.TakeBuffer(size);
int byteRead = 0;
int totalRead = 0;
int sizeLeft = size;
do
{
byteRead = stream.Read(buffer, totalRead, sizeLeft);
totalRead += byteRead;
if (totalRead == size)
{
break;
}
sizeLeft = sizeLeft - byteRead;
} while (true);
return buffer;
}
protected override Message DecodeMessage(byte[] buffer, ref int offset, ref int size, ref bool isAtEOF, TimeSpan timeout)
{
while (size > 0)
{
int bytesRead = _decoder.Decode(buffer, offset, size);
if (bytesRead > 0)
{
if (EnvelopeBuffer != null)
{
if (!object.ReferenceEquals(buffer, EnvelopeBuffer))
{
System.Buffer.BlockCopy(buffer, offset, EnvelopeBuffer, EnvelopeOffset, bytesRead);
}
EnvelopeOffset += bytesRead;
}
offset += bytesRead;
size -= bytesRead;
}
switch (_decoder.CurrentState)
{
case ClientFramingDecoderState.Fault:
_channel.Session.CloseOutputSession(_channel.GetInternalCloseTimeout());
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(FaultStringDecoder.GetFaultException(_decoder.Fault, _channel.RemoteAddress.Uri.ToString(), _messageEncoder.ContentType));
case ClientFramingDecoderState.End:
isAtEOF = true;
return(null); // we're done
case ClientFramingDecoderState.EnvelopeStart:
int envelopeSize = _decoder.EnvelopeSize;
if (envelopeSize > _maxBufferSize)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
ExceptionHelper.CreateMaxReceivedMessageSizeExceededException(_maxBufferSize));
}
EnvelopeBuffer = _bufferManager.TakeBuffer(envelopeSize);
EnvelopeOffset = 0;
EnvelopeSize = envelopeSize;
break;
case ClientFramingDecoderState.EnvelopeEnd:
if (EnvelopeBuffer != null)
{
Message message = null;
try
{
IDisposable activity = ClientDuplexConnectionReader.CreateProcessActionActivity();
using (activity)
{
message = _messageEncoder.ReadMessage(new ArraySegment <byte>(EnvelopeBuffer, 0, EnvelopeSize), _bufferManager);
}
}
catch (XmlException xmlException)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
new ProtocolException(SR.MessageXmlProtocolError, xmlException));
}
EnvelopeBuffer = null;
return(message);
}
break;
}
}
return(null);
}
private ArraySegment<byte> AddSessionInformationToMessage(ArraySegment<byte> messageData, BufferManager bufferManager, int maxMessageSize)
{
int dictionarySize = 0;
byte[] buffer = messageData.Array;
if (_writerSession.HasNewStrings)
{
IList<XmlDictionaryString> newStrings = _writerSession.GetNewStrings();
for (int i = 0; i < newStrings.Count; i++)
{
int utf8ValueSize = Encoding.UTF8.GetByteCount(newStrings[i].Value);
dictionarySize += IntEncoder.GetEncodedSize(utf8ValueSize) + utf8ValueSize;
}
int messageSize = messageData.Offset + messageData.Count;
int remainingMessageSize = maxMessageSize - messageSize;
if (remainingMessageSize - dictionarySize < 0)
{
string excMsg = SR.Format(SR.MaxSentMessageSizeExceeded, maxMessageSize);
if (WcfEventSource.Instance.MaxSentMessageSizeExceededIsEnabled())
{
WcfEventSource.Instance.MaxSentMessageSizeExceeded(excMsg);
}
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new QuotaExceededException(excMsg));
}
int requiredBufferSize = messageData.Offset + messageData.Count + dictionarySize;
if (buffer.Length < requiredBufferSize)
{
byte[] newBuffer = bufferManager.TakeBuffer(requiredBufferSize);
Buffer.BlockCopy(buffer, messageData.Offset, newBuffer, messageData.Offset, messageData.Count);
bufferManager.ReturnBuffer(buffer);
buffer = newBuffer;
}
Buffer.BlockCopy(buffer, messageData.Offset, buffer, messageData.Offset + dictionarySize, messageData.Count);
int offset = messageData.Offset;
for (int i = 0; i < newStrings.Count; i++)
{
string newString = newStrings[i].Value;
int utf8ValueSize = Encoding.UTF8.GetByteCount(newString);
offset += IntEncoder.Encode(utf8ValueSize, buffer, offset);
offset += Encoding.UTF8.GetBytes(newString, 0, newString.Length, buffer, offset);
}
_writerSession.ClearNewStrings();
}
int headerSize = IntEncoder.GetEncodedSize(dictionarySize);
int newOffset = messageData.Offset - headerSize;
int newSize = headerSize + messageData.Count + dictionarySize;
IntEncoder.Encode(dictionarySize, buffer, newOffset);
return new ArraySegment<byte>(buffer, newOffset, newSize);
}
public override ArraySegment<byte> WriteMessage(Message message, int maxMessageSize, BufferManager bufferManager, int messageOffset)
{
var array = innerEncoder.WriteMessage(message, maxMessageSize, bufferManager, messageOffset).Array;
var messageText = Encoding.UTF8.GetString(array);
var xmlDocument = new XmlDocument();
// Сохраняем запрос без actor
File.WriteAllText("D:\\TrueClientRequest.xml", messageText);
xmlDocument.LoadXml(messageText);
var prefixOfNamespace = xmlDocument.FirstChild.GetPrefixOfNamespace(Soap11Namespace);
if (string.IsNullOrEmpty(prefixOfNamespace))
throw new XmlException(string.Format("Не найден префикс пространста имен {0}", Soap11Namespace));
var elementsByTagName = xmlDocument.GetElementsByTagName("Security", "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd");
if (elementsByTagName.Count == 0)
throw new NullReferenceException("Не найден подпись под документом.");
var attribute = xmlDocument.CreateAttribute(prefixOfNamespace + ":actor", Soap11Namespace);
attribute.Value = SMEVActor;
var xmlAttributeCollection = elementsByTagName[0].Attributes;
if (xmlAttributeCollection != null)
{
xmlAttributeCollection.Append(attribute);
}
var memoryStream = new MemoryStream();
var w = XmlWriter.Create(memoryStream);
xmlDocument.Save(w);
// Сохраняем запрос с actor
File.WriteAllText("D:\\TrueClientRequestActor.xml", xmlDocument.InnerXml);
w.Flush();
var buffer = memoryStream.GetBuffer();
var num = (int)memoryStream.Position;
memoryStream.Close();
var bufferSize = num + messageOffset;
var array2 = bufferManager.TakeBuffer(bufferSize);
Array.Copy(buffer, 0, array2, messageOffset, num);
return new ArraySegment<byte>(array2, messageOffset, num);
}
private static byte[] ReadBytes(Stream stream, IndexRange rangeToRead, BufferManager manager)
{
stream.Seek(rangeToRead.StartIndex, SeekOrigin.Begin);
var bufferSize = (int)rangeToRead.Length;
var buffer = manager.TakeBuffer(bufferSize);
for (int bytesRead = stream.Read(buffer, 0, bufferSize);
bytesRead < bufferSize;
bytesRead += stream.Read(buffer, bytesRead, bufferSize - bytesRead))
{
}
return buffer;
}
public override byte[] TakeBuffer(int bufferSize)
{
return(_innerBufferManager.TakeBuffer(bufferSize));
}
public override ArraySegment<byte> WriteMessage(Message message, int maxMessageSize, BufferManager bufferManager, int messageOffset)
{
ArraySegment<byte> byteArray = new ArraySegment<byte>();
MemoryStream stream = new MemoryStream();
StreamWriter sw = new StreamWriter(stream);
XmlWriter writer = null;
byte[] messageBytes = null;
int messageLength = 0;
int totalLength = 0;
byte[] totalBytes = null;
string methodName = null;
string headerType = null;
if (message.Properties.ContainsKey(JSONPMessageProperty.Name))
{
methodName = ((JSONPMessageProperty)(message.Properties[JSONPMessageProperty.Name])).MethodName;
headerType = ((JSONPMessageProperty)(message.Properties[JSONPMessageProperty.Name])).HeaderType;
}
if (headerType == null)
{
writer = XmlWriter.Create(sw);
message.WriteMessage(writer);
writer.Close();
messageBytes = stream.GetBuffer();
messageLength = (int)stream.Position;
stream.Close();
totalLength = messageLength + messageOffset;
totalBytes = bufferManager.TakeBuffer(totalLength);
Array.Copy(messageBytes, 0, totalBytes, messageOffset, messageLength);
byteArray = new ArraySegment<byte>(totalBytes, messageOffset, messageLength);
}
else
{
if (methodName == null)
{
if (headerType.Contains("text/xml") || headerType.Contains("application/xml"))
{
writer = XmlWriter.Create(sw);
message.WriteMessage(writer);
writer.Close();
messageBytes = stream.GetBuffer();
messageLength = (int)stream.Position;
stream.Close();
totalLength = messageLength + messageOffset;
totalBytes = bufferManager.TakeBuffer(totalLength);
Array.Copy(messageBytes, 0, totalBytes, messageOffset, messageLength);
byteArray = new ArraySegment<byte>(totalBytes, messageOffset, messageLength);
}
else if (headerType.Contains("application/json"))
{
writer = JsonReaderWriterFactory.CreateJsonWriter(stream);
message.WriteMessage(writer);
writer.Flush();
messageBytes = stream.GetBuffer();
messageLength = (int)stream.Position;
stream.Close();
writer.Close();
totalLength = messageLength + messageOffset;
totalBytes = bufferManager.TakeBuffer(totalLength);
Array.Copy(messageBytes, 0, totalBytes, messageOffset, messageLength);
byteArray = new ArraySegment<byte>(totalBytes, messageOffset, messageLength);
}
}
else //if there is a JSONP request - check header
{
sw.Write(methodName + "( ");
sw.Flush();
writer = JsonReaderWriterFactory.CreateJsonWriter(stream);
message.WriteMessage(writer);
writer.Flush();
sw.Write(" );");
sw.Flush();
messageBytes = stream.GetBuffer();
messageLength = (int)stream.Position;
totalLength = messageLength + messageOffset;
totalBytes = bufferManager.TakeBuffer(totalLength);
Array.Copy(messageBytes, 0, totalBytes, messageOffset, messageLength);
byteArray = new ArraySegment<byte>(totalBytes, messageOffset, messageLength);
writer.Close();
}
}
return byteArray;
}
//Helper method to decompress an array of bytes
private static ArraySegment<byte> DecompressBuffer(ArraySegment<byte> buffer, BufferManager bufferManager,
CompressionAlgorithm compressionAlgorithm)
{
var memoryStream = new MemoryStream(buffer.Array, buffer.Offset, buffer.Count);
var decompressedStream = new MemoryStream();
//int totalRead = 0;
const int blockSize = 1024;
byte[] tempBuffer = bufferManager.TakeBuffer(blockSize);
using (Stream compressedStream = compressionAlgorithm == CompressionAlgorithm.GZip
? new GZipStream(memoryStream, CompressionMode.Decompress)
: (Stream)
new DeflateStream(memoryStream, CompressionMode.Decompress))
{
while (true)
{
int bytesRead = compressedStream.Read(tempBuffer, 0, blockSize);
if (bytesRead == 0)
break;
decompressedStream.Write(tempBuffer, 0, bytesRead);
//totalRead += bytesRead;
}
}
bufferManager.ReturnBuffer(tempBuffer);
byte[] decompressedBytes = decompressedStream.ToArray();
byte[] bufferManagerBuffer = bufferManager.TakeBuffer(decompressedBytes.Length + buffer.Offset);
Array.Copy(buffer.Array, 0, bufferManagerBuffer, 0, buffer.Offset);
Array.Copy(decompressedBytes, 0, bufferManagerBuffer, buffer.Offset, decompressedBytes.Length);
var byteArray = new ArraySegment<byte>(bufferManagerBuffer, buffer.Offset,
decompressedBytes.Length);
bufferManager.ReturnBuffer(buffer.Array);
return byteArray;
}
/// <summary>
/// Compress a buffer
/// </summary>
/// <param name="buffer"></param>
/// <param name="bufferManager"></param>
/// <param name="messageOffset"></param>
/// <returns></returns>
private static ArraySegment<byte> CompressBuffer(ArraySegment<byte> buffer, BufferManager bufferManager, int messageOffset)
{
// Create a memory stream for the final message
MemoryStream memoryStream = new MemoryStream();
// Copy the bytes that should not be compressed into the stream
memoryStream.Write(buffer.Array, 0, messageOffset);
// Compress the message into the stream
using (GZipStream gzStream = new GZipStream(memoryStream, CompressionMode.Compress, true))
{
gzStream.Write(buffer.Array, messageOffset, buffer.Count);
}
// Convert the stream into a bytes array
byte[] compressedBytes = memoryStream.ToArray();
// Allocate a new buffer to hold the new bytes array
byte[] bufferedBytes = bufferManager.TakeBuffer(compressedBytes.Length);
// Copy the compressed data into the allocated buffer
Array.Copy(compressedBytes, 0, bufferedBytes, 0, compressedBytes.Length);
// Release the original buffer we got as an argument
bufferManager.ReturnBuffer(buffer.Array);
// Create a new ArraySegment that points to the new message buffer
ArraySegment<byte> byteArray = new ArraySegment<byte>(bufferedBytes, messageOffset, compressedBytes.Length - messageOffset);
return byteArray;
}
public override Message ReadMessage(ArraySegment<byte> buffer, BufferManager bufferManager, string contentType)
{
var msgContents = new byte[buffer.Count];
Array.Copy(buffer.Array, buffer.Offset, msgContents, 0, msgContents.Length);
var reader = XmlReader.Create(new MemoryStream(msgContents));
var xmlDocument = new XmlDocument
{
PreserveWhitespace = true
};
xmlDocument.Load(reader);
LogMessage(xmlDocument, true);
var nodeList = xmlDocument.GetElementsByTagName(
"Security", "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd");
#if DEBUG
// Для тестов должна быть как минимум 1 подпись
if (nodeList.Count < 1)
{
return CreateErrorMessage(bufferManager, contentType, "SMEV-100008",
"Не найдена подпись документа");
}
#endif
#if (!DEBUG)
// В сообщении из СМЭВ должно быть как минимум 2 подписи
if (nodeList.Count < 2)
{
return CreateErrorMessage(bufferManager, contentType, "SMEV-100008",
"Не найдена подпись документа");
}
#endif
var xmlDocument2 = new XmlDocument
{
PreserveWhitespace = false
};
xmlDocument2.LoadXml(xmlDocument.OuterXml);
// Проверяем подпись
if (!(Signer.CheckSignature(xmlDocument) || Signer.CheckSignature(xmlDocument2)))
{
return CreateErrorMessage(bufferManager, contentType, "SMEV-100003",
"Неверная ЭП сообщения");
}
var bytes = new UTF8Encoding().GetBytes(xmlDocument.OuterXml);
var length = bytes.Length;
var array = bufferManager.TakeBuffer(length);
Array.Copy(bytes, 0, array, 0, length);
buffer = new ArraySegment<byte>(array, 0, length);
return _innerEncoder.ReadMessage(buffer, bufferManager, contentType);
}
public override ArraySegment<byte> WriteMessage (
Message message, int maxMessageSize,
BufferManager bufferManager, int messageOffset)
{
VerifyMessageVersion (message);
ArraySegment<byte> seg = new ArraySegment<byte> (
bufferManager.TakeBuffer (maxMessageSize),
messageOffset, maxMessageSize);
XmlWriterSettings s = new XmlWriterSettings ();
s.Encoding = encoding;
s.CheckCharacters = false;
using (XmlWriter w = XmlWriter.Create (
new MemoryStream (seg.Array, seg.Offset, seg.Count), s)) {
message.WriteMessage (
XmlDictionaryWriter.CreateDictionaryWriter (w));
}
return seg;
}
private Message CreateMessage(XmlDocument xmlDocument, BufferManager bufferManager, string contentType)
{
var bytes = new UTF8Encoding().GetBytes(xmlDocument.InnerXml);
var length = bytes.Length;
const int destinationIndex = 0;
var bufferSize = length + destinationIndex;
var buffer4 = bufferManager.TakeBuffer(bufferSize);
Array.Copy(bytes, 0, buffer4, destinationIndex, bufferSize);
var buffer = new ArraySegment<byte>(buffer4, destinationIndex, bufferSize);
return _innerEncoder.ReadMessage(buffer, bufferManager, contentType);
}
/// <inheritdoc />
public override ArraySegment<byte> WriteMessage(Message message, int maxMessageSize, BufferManager bufferManager, int messageOffset)
{
// Produce the basic stream
var stream = new MemoryStream();
message.XmlToStream(writerSettings, stream);
// Apply the transformers
stream = Transform(stream);
// Now produce the final version of the message.
var streamBuffer = stream.GetBuffer();
var messageLength = (int)stream.Position;
// And log it
LogMessage(stream);
stream.Close();
var totalLength = messageLength + messageOffset;
var wcfBuffer = bufferManager.TakeBuffer(totalLength);
Array.Copy(streamBuffer, 0, wcfBuffer, messageOffset, messageLength);
var byteArray = new ArraySegment<byte>(wcfBuffer, messageOffset, messageLength);
return byteArray;
}
public override ArraySegment<byte> WriteMessage(Message message, int maxMessageSize, BufferManager bufferManager, int messageOffset)
{
var arraySegment = _innerEncoder.WriteMessage(message, maxMessageSize, bufferManager, messageOffset);
var buffer1 = new byte[arraySegment.Count];
Array.Copy(arraySegment.Array, arraySegment.Offset, buffer1, 0, buffer1.Length);
var reader = XmlReader.Create(new MemoryStream(buffer1));
var xmlDocument = new XmlDocument();
xmlDocument.Load(reader);
var memoryStream = new MemoryStream();
var w = XmlWriter.Create(memoryStream, new XmlWriterSettings
{
OmitXmlDeclaration = true,
Encoding = new UTF8Encoding(false)
});
xmlDocument.Save(w);
LogMessage(xmlDocument, false);
w.Flush();
var buffer2 = memoryStream.GetBuffer();
var num = (int)memoryStream.Position;
memoryStream.Close();
var bufferSize = num + messageOffset;
var array = bufferManager.TakeBuffer(bufferSize);
Array.Copy(buffer2, 0, array, messageOffset, num);
return new ArraySegment<byte>(array, messageOffset, num);
}
//Helper method to compress an array of bytes
static ArraySegment<byte> CompressBuffer(ArraySegment<byte> buffer, BufferManager bufferManager, int messageOffset)
{
MemoryStream memoryStream = new MemoryStream();
using (GZipStream gzStream = new GZipStream(memoryStream, CompressionMode.Compress, true))
{
gzStream.Write(buffer.Array, buffer.Offset, buffer.Count);
}
byte[] compressedBytes = memoryStream.ToArray();
int totalLength = messageOffset + compressedBytes.Length;
byte[] bufferedBytes = bufferManager.TakeBuffer(totalLength);
Array.Copy(compressedBytes, 0, bufferedBytes, messageOffset, compressedBytes.Length);
bufferManager.ReturnBuffer(buffer.Array);
ArraySegment<byte> byteArray = new ArraySegment<byte>(bufferedBytes, messageOffset, bufferedBytes.Length - messageOffset);
return byteArray;
}
public byte[] Take(int bufferSize)
{
return(_internalBufferManager.TakeBuffer(bufferSize));
}
