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); } }