public void ExtractFrameBuffers(ByteBuffer buffer, SerializedWorker <ByteBuffer> bufferHandler)
{
if (this.currentFrameBuffer != null)
{
int num = Math.Min(this.currentFrameBuffer.Size, buffer.Length);
AmqpBitConverter.WriteBytes(this.currentFrameBuffer, buffer.Buffer, buffer.Offset, num);
buffer.Complete(num);
if (this.currentFrameBuffer.Size == 0)
{
ByteBuffer byteBuffer = this.currentFrameBuffer;
this.currentFrameBuffer = null;
bufferHandler.DoWork(byteBuffer);
}
}
while (buffer.Length >= AmqpCodec.MinimumFrameDecodeSize)
{
int frameSize = AmqpCodec.GetFrameSize(buffer);
if (frameSize < AmqpCodec.MinimumFrameDecodeSize || frameSize > this.maxFrameSize)
{
throw new AmqpException(AmqpError.FramingError, SRClient.InvalidFrameSize(frameSize, this.maxFrameSize));
}
int num1 = Math.Min(frameSize, buffer.Length);
this.currentFrameBuffer = new ByteBuffer(frameSize, false);
AmqpBitConverter.WriteBytes(this.currentFrameBuffer, buffer.Buffer, buffer.Offset, num1);
buffer.Complete(num1);
if (frameSize != num1)
{
break;
}
ByteBuffer byteBuffer1 = this.currentFrameBuffer;
this.currentFrameBuffer = null;
bufferHandler.DoWork(byteBuffer1);
}
}
public static void WriteObject(ByteBuffer buffer, object value, bool smallEncoding = true)
{
if (value == null)
{
AmqpBitConverter.WriteUByte(buffer, FormatCode.Null);
}
else
{
Encode encoder;
Decode decoder;
if (TryGetCodec(value.GetType(), out encoder, out decoder))
{
encoder(buffer, value, smallEncoding);
}
else if (value is Described)
{
((Described)value).Encode(buffer);
}
else
{
throw new AmqpException(ErrorCode.NotImplemented,
Fx.Format(SRAmqp.EncodingTypeNotSupported, value.GetType()));
}
}
}
public static ByteBuffer ReadFrameBuffer(ITransport transport, byte[] sizeBuffer, uint maxFrameSize)
{
if (!ReadBuffer(transport, sizeBuffer, 0, FixedWidth.UInt))
{
return(null);
}
int size = AmqpBitConverter.ReadInt(sizeBuffer, 0);
if ((uint)size > maxFrameSize)
{
throw new AmqpException(ErrorCode.InvalidField,
Fx.Format(SRAmqp.InvalidFrameSize, size, maxFrameSize));
}
ByteBuffer frameBuffer = new ByteBuffer(size, true);
AmqpBitConverter.WriteInt(frameBuffer, size);
if (!ReadBuffer(transport, frameBuffer.Buffer, frameBuffer.Length, frameBuffer.Size))
{
return(null);
}
frameBuffer.Append(frameBuffer.Size);
return(frameBuffer);
}
static string ReadString(ByteBuffer buffer, byte formatCode, byte code8, byte code32, string type)
{
if (formatCode == FormatCode.Null)
{
return(null);
}
int count;
if (formatCode == code8)
{
count = AmqpBitConverter.ReadUByte(buffer);
}
else if (formatCode == code32)
{
count = (int)AmqpBitConverter.ReadUInt(buffer);
}
else
{
throw DecodeException(formatCode, buffer.Offset);
}
buffer.Validate(false, count);
string value = new string(Encoding.UTF8.GetChars(buffer.Buffer, buffer.Offset, count));
buffer.Complete(count);
return(value);
}
public static ByteBuffer EncodeCommand(FrameType type, ushort channel, Performative command, int payloadSize)
{
int frameSize = HeaderSize;
if (command != null)
{
frameSize += AmqpCodec.GetSerializableEncodeSize(command);
}
frameSize += payloadSize;
ByteBuffer buffer = new ByteBuffer(frameSize, false, false);
AmqpBitConverter.WriteUInt(buffer, (uint)frameSize);
AmqpBitConverter.WriteUByte(buffer, DefaultDataOffset);
AmqpBitConverter.WriteUByte(buffer, (byte)type);
AmqpBitConverter.WriteUShort(buffer, channel);
if (command != null)
{
AmqpCodec.EncodeSerializable(command, buffer);
}
return(buffer);
}
int GetCount(byte formatCode, ByteBuffer buffer)
{
int count;
if (formatCode >= 0xA0)
{
//bin8 a0 10100001
//str8 a1 10100001
//sym8 a3 10100011
//list8 c0 11000000
//map8 c1 11000001
//arr8 e0 11100000
//bin32 b0 10110000
//str32 b1 10110001
//sym32 b3 10110011
//lit32 d0 11010000
//map32 d1 11010001
//arr32 f0 11110000
if ((formatCode & 0x10) == 0)
{
count = AmqpBitConverter.ReadUByte(buffer);
}
else
{
count = AmqpBitConverter.ReadInt(buffer);
}
}
else
{
count = (1 << ((formatCode >> 4) - 4)) >> 1;
}
return(count);
}
public static ByteBuffer Encode(FrameType type, ushort channel, Transfer transfer,
ByteBuffer payload, int maxFrameSize, out int payloadSize)
{
int bufferSize = cmdBufferSize + payload.Length;
if (bufferSize > maxFrameSize)
{
bufferSize = maxFrameSize;
}
bool more = false; // estimate it first
if (payload.Length > bufferSize - 32)
{
transfer.More = more = true;
}
ByteBuffer buffer = new ByteBuffer(bufferSize, false);
EncodeFrame(buffer, type, channel, transfer);
if (more && payload.Length <= buffer.Size)
{
// guessed it wrong. correct it
transfer.More = false;
buffer.Reset();
EncodeFrame(buffer, type, channel, transfer);
}
payloadSize = Math.Min(payload.Length, buffer.Size);
AmqpBitConverter.WriteBytes(buffer, payload.Buffer, payload.Offset, payloadSize);
payload.Complete(payloadSize);
AmqpBitConverter.WriteInt(buffer.Buffer, 0, buffer.Length);
return(buffer);
}
void Pump(Stream stream)
{
try
{
while (pumpEnabled)
{
byte[] buffer = new byte[8];
Read(stream, buffer, 0, 8);
testAmqpPeer.OnHeader(stream, buffer);
while (pumpEnabled)
{
Read(stream, buffer, 0, 4);
int len = AmqpBitConverter.ReadInt(buffer, 0);
byte[] frame = new byte[len - 4];
Read(stream, frame, 0, frame.Length);
if (!OnFrame(stream, new ByteBuffer(frame, 0, frame.Length, frame.Length)))
{
break;
}
}
}
}
catch (Exception e)
{
Logger.Info(e);
stream.Dispose();
}
}
ByteBuffer IIoHandler.CreateBuffer(int frameSize)
{
var buffer = new ByteBuffer(frameSize, false);
AmqpBitConverter.WriteUInt(buffer, (uint)frameSize);
return(buffer);
}
void Pump(Stream stream)
{
try
{
while (true)
{
byte[] buffer = new byte[8];
Read(stream, buffer, 0, 8);
OnHeader(stream, buffer);
while (true)
{
Read(stream, buffer, 0, 4);
int len = AmqpBitConverter.ReadInt(buffer, 0);
byte[] frame = new byte[len - 4];
Read(stream, frame, 0, frame.Length);
if (!OnFrame(stream, new ByteBuffer(frame, 0, frame.Length, frame.Length)))
{
break;
}
}
}
}
catch
{
stream.Dispose();
}
}
internal override void OnTransfer(Delivery delivery, Transfer transfer, ByteBuffer buffer)
{
if (delivery != null)
{
this.deliveryCount++;
if (!transfer.More)
{
// single transfer message - the most common case
delivery.Buffer = buffer;
this.DeliverMessage(delivery);
}
else
{
delivery.Buffer = new ByteBuffer(buffer.Length * 2, true);
AmqpBitConverter.WriteBytes(delivery.Buffer, buffer.Buffer, buffer.Offset, buffer.Length);
this.deliveryCurrent = delivery;
}
}
else
{
delivery = this.deliveryCurrent;
if (!transfer.More)
{
AmqpBitConverter.WriteBytes(delivery.Buffer, buffer.Buffer, buffer.Offset, buffer.Length);
this.deliveryCurrent = null;
this.DeliverMessage(delivery);
}
else
{
AmqpBitConverter.WriteBytes(delivery.Buffer, buffer.Buffer, buffer.Offset, buffer.Length);
}
}
}
public static Frame Decode(ByteBuffer buffer, bool fullBody = true)
{
Frame frame = new Frame();
frame.RawBuffer = buffer.Array;
// Header
frame.size = (int)AmqpBitConverter.ReadUInt(buffer);
frame.dataOffset = AmqpBitConverter.ReadUByte(buffer);
frame.Type = (FrameType)AmqpBitConverter.ReadUByte(buffer);
frame.Channel = AmqpBitConverter.ReadUShort(buffer);
// skip extended header
buffer.Complete(frame.dataOffset * 4 - Frame.HeaderSize);
// Command
if (buffer.Length > 0)
{
frame.Command = (Performative)AmqpCodec.CreateAmqpDescribed(buffer);
if (fullBody)
{
frame.Command.DecodeValue(buffer);
}
}
return(frame);
}
public static byte[] ReadBinary(ByteBuffer buffer, byte formatCode)
{
if (formatCode == FormatCode.Null)
{
return(null);
}
int count;
if (formatCode == FormatCode.Binary8)
{
count = AmqpBitConverter.ReadUByte(buffer);
}
else if (formatCode == FormatCode.Binary32)
{
count = (int)AmqpBitConverter.ReadUInt(buffer);
}
else
{
throw DecodeException(formatCode, buffer.Offset);
}
buffer.Validate(false, count);
byte[] value = new byte[count];
Array.Copy(buffer.Buffer, buffer.Offset, value, 0, count);
buffer.Complete(count);
return(value);
}
internal override void DecodeValue(ByteBuffer buffer)
{
int offset = buffer.Offset;
byte formatCode = Encoder.ReadFormatCode(buffer);
if (formatCode == FormatCode.Binary8)
{
this.binaryOffset = 2;
}
else if (formatCode == FormatCode.Binary32)
{
this.binaryOffset = 5;
}
else
{
while (formatCode == FormatCode.Described)
{
Encoder.ReadObject(buffer);
formatCode = Encoder.ReadFormatCode(buffer);
}
}
int count;
if (formatCode >= 0xA0)
{
//bin8 a0 10100001
//str8 a1 10100001
//sym8 a3 10100011
//list8 c0 11000000
//map8 c1 11000001
//arr8 e0 11100000
//bin32 b0 10110000
//str32 b1 10110001
//sym32 b3 10110011
//lit32 d0 11010000
//map32 d1 11010001
//arr32 f0 11110000
if ((formatCode & 0x10) == 0)
{
count = AmqpBitConverter.ReadUByte(buffer);
}
else
{
count = AmqpBitConverter.ReadInt(buffer);
}
}
else
{
count = (1 << ((formatCode >> 4) - 4)) >> 1;
}
buffer.Validate(false, count);
buffer.Complete(count);
int size = buffer.Offset - offset;
this.valueBuffer = new ByteBuffer(buffer.Buffer, offset, size, size);
}
static void EncodeFrame(ByteBuffer buffer, FrameType type, ushort channel, DescribedList command)
{
AmqpBitConverter.WriteUInt(buffer, 0u);
AmqpBitConverter.WriteUByte(buffer, DOF);
AmqpBitConverter.WriteUByte(buffer, (byte)type);
AmqpBitConverter.WriteUShort(buffer, channel);
Codec.Encode(command, buffer);
}
public static ByteBuffer Encode(FrameType type, ushort channel, DescribedList command)
{
ByteBuffer buffer = new ByteBuffer(cmdBufferSize, true);
EncodeFrame(buffer, type, channel, command);
AmqpBitConverter.WriteInt(buffer.Buffer, 0, buffer.Length);
return(buffer);
}
public void Encode(ByteBuffer buffer)
{
AmqpBitConverter.WriteUInt(buffer, AmqpPrefix);
AmqpBitConverter.WriteUByte(buffer, (byte)this.protocolId);
AmqpBitConverter.WriteUByte(buffer, this.version.Major);
AmqpBitConverter.WriteUByte(buffer, this.version.Minor);
AmqpBitConverter.WriteUByte(buffer, this.version.Revision);
}
private void DecodeHeader(ByteBuffer buffer)
{
this.Size = (int)AmqpBitConverter.ReadUInt(buffer);
this.DataOffset = AmqpBitConverter.ReadUByte(buffer);
this.Type = (FrameType)AmqpBitConverter.ReadUByte(buffer);
this.Channel = AmqpBitConverter.ReadUShort(buffer);
buffer.Complete(this.DataOffset * 4 - 8);
}
public static ushort?Decode(ByteBuffer buffer, FormatCode formatCode)
{
if (formatCode == 0 && (formatCode = AmqpEncoding.ReadFormatCode(buffer)) == FormatCode.Null)
{
return(null);
}
return(AmqpBitConverter.ReadUShort(buffer));
}
bool HandleReadComplete(TransportAsyncCallbackArgs args)
{
bool completed = true;
Exception exception = null;
if (args.Exception != null)
{
exception = args.Exception;
}
else if (args.BytesTransfered == 0)
{
exception = new ObjectDisposedException(this.transport.ToString());
}
else if (args.BytesTransfered < args.Count)
{
args.SetBuffer(args.Buffer, args.Offset + args.BytesTransfered, args.Count - args.BytesTransfered);
completed = false;
}
if (completed)
{
if (exception != null || object.ReferenceEquals(args.CompletedCallback, onFrameComplete))
{
ByteBuffer buffer = null;
if (exception == null)
{
buffer = new ByteBuffer(args.Buffer, 0, args.Buffer.Length);
this.parent.OnReceiveBuffer(buffer);
}
else
{
this.parent.OnIoFault(exception);
}
}
else
{
// read size completed ok
uint size = AmqpBitConverter.ReadUInt(this.sizeBuffer, 0, this.sizeBuffer.Length);
if (size > this.maxFrameSize)
{
completed = true;
exception = new AmqpException(AmqpErrorCode.FramingError, CommonResources.GetString(CommonResources.InvalidFrameSize, size, this.maxFrameSize));
this.parent.OnIoFault(exception);
}
else
{
byte[] frameBuffer = new byte[size];
Buffer.BlockCopy(this.sizeBuffer, 0, frameBuffer, 0, this.sizeBuffer.Length);
args.SetBuffer(frameBuffer, this.sizeBuffer.Length, (int)size - this.sizeBuffer.Length);
args.CompletedCallback = onFrameComplete;
completed = false;
}
}
}
return(completed);
}
public static void Encode(ByteBuffer buffer, FrameType type, ushort channel, DescribedList command)
{
buffer.Append(4);
AmqpBitConverter.WriteUByte(buffer, 2);
AmqpBitConverter.WriteUByte(buffer, (byte)type);
AmqpBitConverter.WriteUShort(buffer, channel);
command.Encode(buffer);
AmqpBitConverter.WriteInt(buffer.Buffer, buffer.Offset, buffer.Length);
}
public static void Encode(ByteBuffer buffer, ushort channel, Transfer transfer, ByteBuffer payload)
{
Encode(buffer, FrameType.Amqp, channel, transfer);
int payloadSize = payload.Length;
int frameSize = buffer.Length + payloadSize;
AmqpBitConverter.WriteInt(buffer.Buffer, buffer.Offset, frameSize);
AmqpBitConverter.WriteBytes(buffer, payload.Buffer, payload.Offset, payload.Length);
payload.Complete(payload.Length);
}
void DecodeHeader(ByteBuffer buffer)
{
this.Size = (int)AmqpBitConverter.ReadUInt(buffer);
this.DataOffset = AmqpBitConverter.ReadUByte(buffer);
this.Type = (FrameType)AmqpBitConverter.ReadUByte(buffer);
this.Channel = AmqpBitConverter.ReadUShort(buffer);
// skip extended header
buffer.Complete(this.DataOffset * 4 - Frame.HeaderSize);
}
private void HandleFrameSizeReadComplete(TransportAsyncCallbackArgs args)
{
int num = (int)AmqpBitConverter.ReadUInt(this.frameSizeBuffer.Array, this.frameSizeBuffer.Offset, 4);
if (num <= 0 || num > this.maxFrameSize)
{
throw new AmqpException(AmqpError.FramingError, SRClient.InvalidFrameSize(num, this.maxFrameSize));
}
this.SetReadFrameBody(num);
}
private void SetReadFrameBody(int frameSize)
{
ByteBuffer byteBuffer = new ByteBuffer(frameSize, false, false);
AmqpBitConverter.WriteUInt(byteBuffer, (uint)frameSize);
this.readState = AsyncIO.AsyncReader.ReadState.FrameBody;
this.remainingBytes = byteBuffer.Size;
this.readAsyncEventArgs.SetBuffer(byteBuffer.Buffer, byteBuffer.Length, this.remainingBytes);
this.readAsyncEventArgs.UserToken2 = byteBuffer;
}
public override void EncodeObject(object value, bool arrayEncoding, ByteBuffer buffer)
{
if (arrayEncoding)
{
AmqpBitConverter.WriteUShort(buffer, (ushort)value);
}
else
{
UShortEncoding.Encode((ushort)value, buffer);
}
}
public override void EncodeObject(object value, bool arrayEncoding, ByteBuffer buffer)
{
if (arrayEncoding)
{
AmqpBitConverter.WriteFloat(buffer, (float)value);
}
else
{
FloatEncoding.Encode((float)value, buffer);
}
}
public static Guid ReadUuid(ByteBuffer buffer, byte formatCode)
{
if (formatCode == FormatCode.Uuid)
{
return(AmqpBitConverter.ReadUuid(buffer));
}
else
{
throw DecodeException(formatCode, buffer.Offset);
}
}
public static DateTime ReadTimestamp(ByteBuffer buffer, byte formatCode)
{
if (formatCode == FormatCode.TimeStamp)
{
return(new DateTime(epochTicks + AmqpBitConverter.ReadLong(buffer) * ticksPerMillisecond, DateTimeKind.Utc));
}
else
{
throw DecodeException(formatCode, buffer.Offset);
}
}
public static double ReadDouble(ByteBuffer buffer, byte formatCode)
{
if (formatCode == FormatCode.Double)
{
return(AmqpBitConverter.ReadDouble(buffer));
}
else
{
throw DecodeException(formatCode, buffer.Offset);
}
}
