///<summary>Fill this instance from the given byte buffer stream.
///</summary>
public ulong ReadFrom(NetworkBinaryReader reader)
{
reader.ReadUInt16(); // weight - not currently used
ulong bodySize = reader.ReadUInt64();
ReadPropertiesFrom(new ContentHeaderPropertyReader(reader));
return bodySize;
}
public static byte[] ReadLongstr(NetworkBinaryReader reader)
{
uint byteCount = reader.ReadUInt32();
if (byteCount > int.MaxValue)
{
throw new SyntaxError("Long string too long; " +
"byte length=" + byteCount + ", max=" + int.MaxValue);
}
return reader.ReadBytes((int)byteCount);
}
///<summary>Fill this instance from the given byte buffer
///stream. Throws BodyTooLongException, which is the reason
///for the channelNumber parameter.</summary>
///<remarks>
///<para>
/// It might be better to do the body length check in our
/// caller, currently CommandAssembler, which would avoid
/// passing in the otherwise unrequired channelNumber
/// parameter.
///</para>
///</remarks>
public ulong ReadFrom(int channelNumber, NetworkBinaryReader reader)
{
reader.ReadUInt16(); // weight - not currently used
ulong bodySize = reader.ReadUInt64();
if (bodySize > MaximumPermittedReceivableBodySize)
{
throw new BodyTooLongException(channelNumber, bodySize);
}
ReadPropertiesFrom(new ContentHeaderPropertyReader(reader));
return bodySize;
}
public static bool ReadBool(NetworkBinaryReader reader) {
object value = ReadNonnullObject("bool", reader);
if (value is bool) {
return (bool) value;
}
if (value is string) {
return PrimitiveParser.ParseBool((string) value);
}
PrimitiveParser.InvalidConversion("bool", value);
return false;
}
public static int ReadInt32(NetworkBinaryReader reader) {
object value = ReadNonnullObject("int", reader);
if (value is int || value is short || value is byte) {
return (int) value;
}
if (value is string) {
return PrimitiveParser.ParseInt((string) value);
}
PrimitiveParser.InvalidConversion("int", value);
return 0;
}
public SocketFrameHandler_0_9(AmqpTcpEndpoint endpoint)
{
m_endpoint = endpoint;
m_socket = new TcpClient();
m_socket.Connect(endpoint.HostName, endpoint.Port);
// disable Nagle's algorithm, for more consistently low latency
m_socket.NoDelay = true;
Stream netstream = m_socket.GetStream();
m_reader = new NetworkBinaryReader(netstream);
m_writer = new NetworkBinaryWriter(netstream);
}
public static bool ReadBool(NetworkBinaryReader reader)
{
object value = ReadNonnullObject("bool", reader);
if (value is bool)
{
return (bool) value;
}
if (value is string)
{
return PrimitiveParser.ParseBool((string) value);
}
throw PrimitiveParser.CreateProtocolViolationException("bool", value);
}
public static IDictionary<string, object> ReadMap(NetworkBinaryReader reader) {
int entryCount = BytesWireFormatting.ReadInt32(reader);
if (entryCount < 0) {
string message = string.Format("Invalid (negative) entryCount: {0}", entryCount);
throw new ProtocolViolationException(message);
}
IDictionary<string, object> table = new Dictionary<string, object>(entryCount);
for (int entryIndex = 0; entryIndex < entryCount; entryIndex++) {
string key = StreamWireFormatting.ReadUntypedString(reader);
object value = StreamWireFormatting.ReadObject(reader);
table[key] = value;
}
return table;
}
public static Frame ReadFrom(NetworkBinaryReader reader)
{
int type;
int channel;
try
{
type = reader.ReadByte();
}
catch (IOException ioe)
{
// If it's a WSAETIMEDOUT SocketException, unwrap it.
// This might happen when the limit of half-open connections is
// reached.
if (ioe.InnerException == null ||
!(ioe.InnerException is SocketException) ||
((SocketException)ioe.InnerException).SocketErrorCode != SocketError.TimedOut)
throw ioe;
throw ioe.InnerException;
}
if (type == 'A')
{
// Probably an AMQP protocol header, otherwise meaningless
ProcessProtocolHeader(reader);
}
channel = reader.ReadUInt16();
int payloadSize = reader.ReadInt32(); // FIXME - throw exn on unreasonable value
byte[] payload = reader.ReadBytes(payloadSize);
if (payload.Length != payloadSize)
{
// Early EOF.
throw new MalformedFrameException("Short frame - expected " +
payloadSize + " bytes, got " +
payload.Length + " bytes");
}
int frameEndMarker = reader.ReadByte();
if (frameEndMarker != CommonFraming.Constants.FrameEnd)
{
throw new MalformedFrameException("Bad frame end marker: " + frameEndMarker);
}
return new Frame(type, channel, payload);
}
public static string ReadShortstr(NetworkBinaryReader reader)
{
int byteCount = reader.ReadByte();
return Encoding.UTF8.GetString(reader.ReadBytes(byteCount));
}
public static ushort ReadShort(NetworkBinaryReader reader)
{
return reader.ReadUInt16();
}
public static byte ReadOctet(NetworkBinaryReader reader)
{
return reader.ReadByte();
}
public static ulong ReadLonglong(NetworkBinaryReader reader)
{
return reader.ReadUInt64();
}
///<exception cref="ProtocolViolationException"/>
public static object ReadNonnullObject(string target, NetworkBinaryReader reader) {
object value = ReadObject(reader);
if (value == null) {
throw new ProtocolViolationException(string.Format("Null {0} value not permitted",
target));
}
return value;
}
public static void ProcessProtocolHeader(NetworkBinaryReader reader)
{
try
{
byte b1 = reader.ReadByte();
byte b2 = reader.ReadByte();
byte b3 = reader.ReadByte();
if (b1 != 'M' || b2 != 'Q' || b3 != 'P')
{
throw new MalformedFrameException("Invalid AMQP protocol header from server");
}
int transportHigh = reader.ReadByte();
int transportLow = reader.ReadByte();
int serverMajor = reader.ReadByte();
int serverMinor = reader.ReadByte();
throw new PacketNotRecognizedException(transportHigh,
transportLow,
serverMajor,
serverMinor);
}
catch (EndOfStreamException)
{
// Ideally we'd wrap the EndOfStreamException in the
// MalformedFrameException, but unfortunately the
// design of MalformedFrameException's superclass,
// ProtocolViolationException, doesn't permit
// this. Fortunately, the call stack in the
// EndOfStreamException is largely irrelevant at this
// point, so can safely be ignored.
throw new MalformedFrameException("Invalid AMQP protocol header from server");
}
}
public static IList ReadArray(NetworkBinaryReader reader)
{
IList array = new ArrayList();
long arrayLength = reader.ReadUInt32();
Stream backingStream = reader.BaseStream;
long startPosition = backingStream.Position;
while ((backingStream.Position - startPosition) < arrayLength)
{
object value = ReadFieldValue(reader);
array.Add(value);
}
return array;
}
public MethodArgumentReader(NetworkBinaryReader reader)
{
m_reader = reader;
ClearBits();
}
public abstract ContentHeaderBase DecodeContentHeaderFrom(NetworkBinaryReader reader);
public abstract MethodBase DecodeMethodFrom(NetworkBinaryReader reader);
public static byte[] ReadBytes(NetworkBinaryReader reader) {
object value = ReadObject(reader);
if (value == null) {
return null;
}
if (value is byte[]) {
return (byte[]) value;
}
PrimitiveParser.InvalidConversion("byte[]", value);
return null;
}
public static string ReadUntypedString(NetworkBinaryReader reader) {
BinaryWriter buffer = NetworkBinaryWriter.TemporaryBinaryWriter(256);
while (true) {
byte b = reader.ReadByte();
if (b == 0) {
return Encoding.UTF8.GetString(NetworkBinaryWriter.TemporaryContents(buffer));
} else {
buffer.Write(b);
}
}
}
///<exception cref="EndOfStreamException"/>
///<exception cref="ProtocolViolationException"/>
public static object ReadObject(NetworkBinaryReader reader) {
int typeTag = reader.ReadByte();
switch (typeTag) {
case -1:
throw new EndOfStreamException("End of StreamMessage reached");
case (int) StreamWireFormattingTag.Bool: {
byte value = reader.ReadByte();
switch (value) {
case 0x00: return false;
case 0x01: return true;
default: {
string message =
string.Format("Invalid boolean value in StreamMessage: {0}", value);
throw new ProtocolViolationException(message);
}
}
}
case (int) StreamWireFormattingTag.Byte:
return reader.ReadByte();
case (int) StreamWireFormattingTag.Bytes: {
int length = reader.ReadInt32();
if (length == -1) {
return null;
} else {
return reader.ReadBytes(length);
}
}
case (int) StreamWireFormattingTag.Int16:
return reader.ReadInt16();
case (int) StreamWireFormattingTag.Char:
return (char) reader.ReadUInt16();
case (int) StreamWireFormattingTag.Int32:
return reader.ReadInt32();
case (int) StreamWireFormattingTag.Int64:
return reader.ReadInt64();
case (int) StreamWireFormattingTag.Single:
return reader.ReadSingle();
case (int) StreamWireFormattingTag.Double:
return reader.ReadDouble();
case (int) StreamWireFormattingTag.String:
return ReadUntypedString(reader);
case (int) StreamWireFormattingTag.Null:
return null;
default: {
string message = string.Format("Invalid type tag in StreamMessage: {0}",
typeTag);
throw new ProtocolViolationException(message);
}
}
}
///<summary>Reads an AMQP "table" definition from the reader.</summary>
///<remarks>
/// Supports the AMQP 0-8/0-9 standard entry types S, I, D, T
/// and F, as well as the QPid-0-8 specific b, d, f, l, s, t,
/// x and V types and the AMQP 0-9-1 A type.
///</remarks>
public static IDictionary ReadTable(NetworkBinaryReader reader)
{
Hashtable table = new Hashtable();
long tableLength = reader.ReadUInt32();
Stream backingStream = reader.BaseStream;
long startPosition = backingStream.Position;
while ((backingStream.Position - startPosition) < tableLength)
{
string key = ReadShortstr(reader);
object value = ReadFieldValue(reader);
if (!table.ContainsKey(key))
{
table[key] = value;
}
}
return table;
}
public static decimal ReadDecimal(NetworkBinaryReader reader)
{
byte scale = ReadOctet(reader);
uint unsignedMantissa = ReadLong(reader);
return AmqpToDecimal(scale, unsignedMantissa);
}
public static AmqpTimestamp ReadTimestamp(NetworkBinaryReader reader)
{
ulong stamp = ReadLonglong(reader);
// 0-9 is afaict silent on the signedness of the timestamp.
// See also MethodArgumentWriter.WriteTimestamp and AmqpTimestamp itself
return new AmqpTimestamp((long)stamp);
}
public static object ReadFieldValue(NetworkBinaryReader reader)
{
object value = null;
byte discriminator = reader.ReadByte();
switch ((char)discriminator)
{
case 'S':
value = ReadLongstr(reader);
break;
case 'I':
value = reader.ReadInt32();
break;
case 'D':
value = ReadDecimal(reader);
break;
case 'T':
value = ReadTimestamp(reader);
break;
case 'F':
value = ReadTable(reader);
break;
case 'A':
value = ReadArray(reader);
break;
case 'b':
value = ReadOctet(reader);
break;
case 'd':
value = reader.ReadDouble();
break;
case 'f':
value = reader.ReadSingle();
break;
case 'l':
value = reader.ReadInt64();
break;
case 's':
value = reader.ReadInt16();
break;
case 't':
value = (ReadOctet(reader) != 0);
break;
case 'x':
value = new BinaryTableValue(ReadLongstr(reader));
break;
case 'V':
value = null;
break;
default:
throw new SyntaxError("Unrecognised type in table: " +
(char) discriminator);
}
return value;
}
public static Frame ReadFrom(NetworkBinaryReader reader)
{
int type;
int channel;
type = reader.ReadByte();
if (type == 'A')
{
// Probably an AMQP protocol header, otherwise meaningless
ProcessProtocolHeader(reader);
}
channel = reader.ReadUInt16();
int payloadSize = reader.ReadInt32(); // FIXME - throw exn on unreasonable value
byte[] payload = reader.ReadBytes(payloadSize);
if (payload.Length != payloadSize)
{
// Early EOF.
throw new MalformedFrameException("Short frame - expected " +
payloadSize + " bytes, got " +
payload.Length + " bytes");
}
int frameEndMarker = reader.ReadByte();
if (frameEndMarker != CommonFraming.Constants.FrameEnd)
{
throw new MalformedFrameException("Bad frame end marker: " + frameEndMarker);
}
return new Frame(type, channel, payload);
}
public static uint ReadLong(NetworkBinaryReader reader)
{
return reader.ReadUInt32();
}
public SocketFrameHandler(AmqpTcpEndpoint endpoint,
ConnectionFactory.ObtainSocket socketFactory,
int timeout)
{
m_endpoint = endpoint;
m_socket = null;
if (Socket.OSSupportsIPv6)
{
try
{
m_socket = socketFactory(AddressFamily.InterNetworkV6);
Connect(m_socket, endpoint, timeout);
}
catch (ConnectFailureException) // could not connect using IPv6
{
m_socket = null;
}
catch (SocketException) // Mono might raise a SocketException when using IPv4 addresses on an OS that supports IPv6
{
m_socket = null;
}
}
if (m_socket == null)
{
m_socket = socketFactory(AddressFamily.InterNetwork);
Connect(m_socket, endpoint, timeout);
}
Stream netstream = m_socket.GetStream();
if (endpoint.Ssl.Enabled)
{
try
{
netstream = SslHelper.TcpUpgrade(netstream, endpoint.Ssl, timeout);
}
catch (Exception)
{
Close();
throw;
}
}
m_reader = new NetworkBinaryReader(new BufferedStream(netstream));
m_writer = new NetworkBinaryWriter(new BufferedStream(netstream));
}
public static string ReadString(NetworkBinaryReader reader) {
object value = ReadObject(reader);
if (value == null) {
return null;
}
if (value is byte[]) {
PrimitiveParser.InvalidConversion("string", value);
return null;
}
return value.ToString();
}
