public static InboundFrame ReadFrom(NetworkBinaryReader reader)
{
int type;
try
{
type = reader.ReadByte();
}
catch (IOException ioe) when(
ioe.InnerException != null &&
(ioe.InnerException is SocketException) &&
((SocketException)ioe.InnerException).SocketErrorCode == SocketError.TimedOut)
{
throw ioe.InnerException;
}
if (type == 'A')
{
// Probably an AMQP protocol header, otherwise meaningless
ProcessProtocolHeader(reader);
}
int 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 != Constants.FrameEnd)
{
throw new MalformedFrameException("Bad frame end marker: " + frameEndMarker);
}
return(new InboundFrame((FrameType)type, channel, payload));
}
public static List <PDataTF> ReadPDataTFs(NetworkBinaryReader dr)
{
var pDatas = new List <PDataTF>();
do
{
try
{
PDataTF pdu;
pdu = PDUReader.ReadPDFData(dr).Payload;
pDatas.Add(pdu);
}
catch (Exception e)
{
throw new Exception("Problem reading PDataTF chain.\n" + e.Message);
}
} while (!pDatas.Any(p => p.Items.Any(it => it.Fragment.IsLastItem)));
return(pDatas);
}
public SocketFrameHandler(AmqpTcpEndpoint endpoint,
Func <StreamSocket> socketFactory,
int connectionTimeout,
int _readTimeout,
int _writeTimeout)
{
Endpoint = endpoint;
m_socket = socketFactory();
Connect(m_socket, endpoint, connectionTimeout);
if (endpoint.Ssl.Enabled)
{
IAsyncAction ar = null;
try
{
var cts = new CancellationTokenSource();
if (this.defaultTimeout.HasValue)
{
cts.CancelAfter(this.defaultTimeout.Value);
}
ar = this.m_socket.UpgradeToSslAsync(
SocketProtectionLevel.Ssl, new HostName(endpoint.Ssl.ServerName));
ar.AsTask(cts.Token).Wait();
ar.GetResults();
}
catch (Exception)
{
Close();
throw;
}
finally
{
if (ar != null)
{
ar.Close();
}
}
}
m_reader = new NetworkBinaryReader(m_socket.InputStream.AsStreamForRead());
m_writer = new NetworkBinaryWriter(m_socket.OutputStream.AsStreamForWrite());
}
public SocketFrameHandler(AmqpTcpEndpoint endpoint,
Func <AddressFamily, ITcpClient> socketFactory,
int connectionTimeout, int readTimeout, int writeTimeout)
{
Endpoint = endpoint;
if (ShouldTryIPv6(endpoint))
{
try {
m_socket = ConnectUsingIPv6(endpoint, socketFactory, connectionTimeout);
} catch (ConnectFailureException)
{
m_socket = null;
}
}
if (m_socket == null && endpoint.AddressFamily != AddressFamily.InterNetworkV6)
{
m_socket = ConnectUsingIPv4(endpoint, socketFactory, connectionTimeout);
}
Stream netstream = m_socket.GetStream();
netstream.ReadTimeout = readTimeout;
netstream.WriteTimeout = writeTimeout;
if (endpoint.Ssl.Enabled)
{
try
{
netstream = SslHelper.TcpUpgrade(netstream, endpoint.Ssl);
}
catch (Exception)
{
Close();
throw;
}
}
m_reader = new NetworkBinaryReader(new BufferedStream(netstream));
m_writer = new NetworkBinaryWriter(new BufferedStream(netstream));
m_writeableStateTimeout = writeTimeout;
}
private async Task <InboundFrame> ReadFrom(Stream reader)
{
var buffer = _emptyBuffer;
await ReadAsync(reader, buffer);
NetworkBinaryReader headerReader = null;
int type = buffer[0];
try
{
if (type == 'A')
{
throw new MalformedFrameException("Invalid AMQP protocol header from server");
}
var headerReaderBuffer = new byte[6];
Array.Copy(buffer, 1, headerReaderBuffer, 0, 6);
headerReader = new NetworkBinaryReader(new MemoryStream(headerReaderBuffer));
int channel = headerReader.ReadUInt16();
int payloadSize = headerReader.ReadInt32(); // FIXME - throw exn on unreasonable value
byte[] payload = new byte[payloadSize];
await ReadAsync(reader, payload);
var frameEndMarkerbuffer = new byte[1];
await ReadAsync(reader, frameEndMarkerbuffer);
int frameEndMarker = frameEndMarkerbuffer[0];
if (frameEndMarker != Constants.FrameEnd)
{
throw new MalformedFrameException("Bad frame end marker: " + frameEndMarker);
}
return(new InboundFrame((FrameType)type, channel, payload));
}
finally
{
headerReader?.Dispose();
}
}
///<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>
/// <returns>A <seealso cref="System.Collections.Generic.IDictionary{TKey,TValue}"/>.</returns>
public static IDictionary <string, object> ReadTable(NetworkBinaryReader reader)
{
IDictionary <string, object> table = new Dictionary <string, object>();
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 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);
}
private static AbstractDIMSE ProcessCommand(List <PDataTF> pDatas, Association asc)
{
DICOMObject dcm = GetCommandObject(pDatas);
AbstractDIMSE dimse;
bool success = DIMSEReader.TryReadDIMSE(dcm, out dimse);
if (!success)
{
asc.Logger.Log("DIMSE could not be read!");
}
if (dimse.HasData)
{
NetworkBinaryReader dr = asc.Reader;
List <PDataTF> dataPds = ReadPDataTFs(dr);
int id;
var txSyntax = GetTransferSyntax(asc, dataPds, out id);
dimse.DataPresentationContextId = id;
dimse.Data = GetDataObject(dataPds, txSyntax);
}
DIMSEProcessor.Process(dimse, asc);
return(dimse);
}
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();
if (endpoint.Ssl.Enabled)
{
try {
netstream = SslHelper.TcpUpgrade(netstream, endpoint.Ssl);
} catch (Exception) {
Close();
throw;
}
}
m_reader = new NetworkBinaryReader(new BufferedStream(netstream));
m_writer = new NetworkBinaryWriter(new BufferedStream(netstream));
}
public static object ReadFieldValue(NetworkBinaryReader reader)
{
byte discriminator = reader.ReadByte();
return(((char)discriminator) switch
{
'S' => ReadLongstr(reader),
'I' => reader.ReadInt32(),
'i' => reader.ReadUInt32(),
'D' => ReadDecimal(reader),
'T' => ReadTimestamp(reader),
'F' => ReadTable(reader),
'A' => ReadArray(reader),
'B' => reader.ReadByte(),
'b' => reader.ReadSByte(),
'd' => reader.ReadDouble(),
'f' => reader.ReadSingle(),
'l' => reader.ReadInt64(),
's' => reader.ReadInt16(),
't' => (ReadOctet(reader) != 0),
'x' => new BinaryTableValue(ReadLongstr(reader)),
'V' => null,
_ => throw new SyntaxException("Unrecognised type in table: " + (char)discriminator),
});
public abstract ContentHeaderBase DecodeContentHeaderFrom(NetworkBinaryReader reader);
public abstract MethodBase DecodeMethodFrom(NetworkBinaryReader reader);
public static ushort ReadShort(NetworkBinaryReader reader)
{
return(reader.ReadUInt16());
}
public static ulong ReadLonglong(NetworkBinaryReader reader)
{
return(reader.ReadUInt64());
}
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 = reader.ReadSByte();
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 double ReadDouble(NetworkBinaryReader reader)
{
return(reader.ReadDouble());
}
public static char ReadChar(NetworkBinaryReader reader)
{
return((char)reader.ReadUInt16());
}
public static byte[] ReadBytes(NetworkBinaryReader reader, int count)
{
return(reader.ReadBytes(count));
}
public static int Read(NetworkBinaryReader reader, byte[] target, int offset, int count)
{
return(reader.Read(target, offset, count));
}
public MethodArgumentReader(NetworkBinaryReader reader)
{
BaseReader = reader;
ClearBits();
}
/// <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);
}
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);
}
}
}
public ContentHeaderPropertyReader(NetworkBinaryReader reader)
{
BaseReader = reader;
m_flagWord = 1; // just the continuation bit
m_bitCount = 15; // the correct position to force a m_flagWord read
}
public static int ReadInt32(NetworkBinaryReader reader)
{
return(reader.ReadInt32());
}
public static uint ReadLong(NetworkBinaryReader reader)
{
return(reader.ReadUInt32());
}
public static long ReadInt64(NetworkBinaryReader reader)
{
return(reader.ReadInt64());
}
public static byte ReadOctet(NetworkBinaryReader reader)
{
return(reader.ReadByte());
}
public static float ReadSingle(NetworkBinaryReader reader)
{
return(reader.ReadSingle());
}
public static short ReadInt16(NetworkBinaryReader reader)
{
return(reader.ReadInt16());
}
public Command HandleFrame(InboundFrame f)
{
switch (m_state)
{
case AssemblyState.ExpectingMethod:
{
if (!f.IsMethod())
{
throw new UnexpectedFrameException(f);
}
m_method = m_protocol.DecodeMethodFrom(f.GetReader());
m_state = m_method.HasContent
? AssemblyState.ExpectingContentHeader
: AssemblyState.Complete;
return(CompletedCommand());
}
case AssemblyState.ExpectingContentHeader:
{
if (!f.IsHeader())
{
throw new UnexpectedFrameException(f);
}
NetworkBinaryReader reader = f.GetReader();
m_header = m_protocol.DecodeContentHeaderFrom(reader);
var totalBodyBytes = m_header.ReadFrom(reader);
if (totalBodyBytes > MaxArrayOfBytesSize)
{
throw new UnexpectedFrameException(f);
}
m_remainingBodyBytes = (int)totalBodyBytes;
m_body = new byte[m_remainingBodyBytes];
m_bodyStream = new MemoryStream(m_body, true);
UpdateContentBodyState();
return(CompletedCommand());
}
case AssemblyState.ExpectingContentBody:
{
if (!f.IsBody())
{
throw new UnexpectedFrameException(f);
}
if (f.Payload.Length > m_remainingBodyBytes)
{
throw new MalformedFrameException
(string.Format("Overlong content body received - {0} bytes remaining, {1} bytes received",
m_remainingBodyBytes,
f.Payload.Length));
}
m_bodyStream.Write(f.Payload, 0, f.Payload.Length);
m_remainingBodyBytes -= f.Payload.Length;
UpdateContentBodyState();
return(CompletedCommand());
}
case AssemblyState.Complete:
default:
#if NETFX_CORE
Debug.WriteLine("Received frame in invalid state {0}; {1}", m_state, f);
#else
//Trace.Fail(string.Format("Received frame in invalid state {0}; {1}", m_state, f));
#endif
return(null);
}
}
