private byte[] Read()
{
var header = new MqttFixedHeader();
var headerByte = new byte[1];
int receivedSize;
INetworkStream stream = GetStream();
// Read the fixed header
do
{
receivedSize = stream.Receive(headerByte, 0, 1);
} while (receivedSize > 0 && header.AppendByte(headerByte[0]));
if (!header.IsComplete)
{
_logger.LogMessage("Socket", LogLevel.Error, "Header data invalid for incoming message.");
throw new IOException("Unable to receive the MQTT fixed header.");
}
_logger.LogMessage("Socket", LogLevel.Verbose, "Begin reading payload for incoming message type: " + header.MessageType);
// Create a buffer and read the remaining message
var completeBuffer = header.CreateMessageBuffer();
receivedSize = 0;
while (receivedSize < header.RemainingLength)
{
receivedSize += stream.Receive(completeBuffer, header.HeaderSize + receivedSize, header.RemainingLength - receivedSize);
}
return(completeBuffer);
}
private Packet DecodePacketInternal(IByteBuffer buffer, byte packetSignature, ref int remainingLength)
{
var fixedHeader = new MqttFixedHeader(packetSignature, remainingLength);
Packet packet = fixedHeader.PacketType switch
{
PacketType.CONNECT => new ConnectPacket(),
PacketType.CONNACK => new ConnAckPacket(),
PacketType.DISCONNECT => new DisconnectPacket(),
PacketType.PINGREQ => new PingReqPacket(),
PacketType.PINGRESP => new PingRespPacket(),
PacketType.PUBACK => new PubAckPacket(),
PacketType.PUBCOMP => new PubCompPacket(),
PacketType.PUBLISH => new PublishPacket(),
PacketType.PUBREC => new PubRecPacket(),
PacketType.PUBREL => new PubRelPacket(),
PacketType.SUBSCRIBE => new SubscribePacket(),
PacketType.SUBACK => new SubAckPacket(),
PacketType.UNSUBSCRIBE => new UnsubscribePacket(),
PacketType.UNSUBACK => new UnsubscribePacket(),
_ => throw new DecoderException("Unsupported Message Type"),
};
packet.FixedHeader = fixedHeader;
packet.Decode(buffer);
remainingLength = packet.RemaingLength;
return(packet);
}
private byte[] ReadFromInputStreamAsync(Stream stream, string clientUid, CancellationToken token)
{
var header = new MqttFixedHeader();
var headerByte = new byte[1];
int receivedSize;
// Read the fixed header
do
{
receivedSize = stream.Read(headerByte, 0, headerByte.Length);
} while (receivedSize > 0 && header.AppendByte(headerByte[0]));
if (!header.IsComplete)
{
_logger.LogMessage("Socket", LogLevel.Error,
string.Format("Read header operation could not read header, aborting."));
return(null);
}
_logger.LogMessage("Socket", LogLevel.Verbose,
string.Format("Received message header type '{0}' from client {1}.", header.MessageType, clientUid));
//_logger.LogMessage("Socket", LogLevel.Warning,
// string.Format("Received message header=0x{0:X}, Remaining length={1}.", header.Buffer[0], header.RemainingLength));
// Create a buffer and read the remaining message
var completeBuffer = header.CreateMessageBuffer();
receivedSize = 0;
while (receivedSize < header.RemainingLength)
{
receivedSize += stream.Read(completeBuffer, header.HeaderSize + receivedSize, header.RemainingLength - receivedSize);
}
//_logger.LogMessage("Socket", LogLevel.Warning,
// string.Format(" Bytes read= {0}.", receivedSize));
if (token.IsCancellationRequested)
{
// Operation was cancelled
_logger.LogMessage("Socket", LogLevel.Verbose, string.Format("Read header operation cancelled."));
return(null);
}
return(completeBuffer);
}
private async Task <byte[]> ReadFromInputStreamAsync(StreamSocket socket, CancellationToken token)
{
var header = new MqttFixedHeader();
uint bytesRead;
using (var reader = new DataReader(socket.InputStream))
{
reader.InputStreamOptions = InputStreamOptions.Partial;
// Read the fixed header
var headerByte = new byte[1];
do
{
bytesRead = await reader.LoadAsync(1);
if (bytesRead > 0)
{
reader.ReadBytes(headerByte);
}
} while (bytesRead > 0 && header.AppendByte(headerByte[0]));
reader.DetachStream();
if (token.IsCancellationRequested)
{
// Operation was cancelled
return(null);
}
if (!header.IsComplete)
{
_logger.LogMessage("Socket", LogLevel.Verbose, "Read header operation could not read header, aborting.");
return(null);
}
_logger.LogMessage("Socket", LogLevel.Verbose, string.Format("Received message header type '{0}' from server.", header.MessageType));
}
var msgBuffer = header.CreateMessageBuffer();
//_logger.LogMessage("Socket", LogLevel.Verbose,
// string.Format("Received message header=0x{0:X}, Remaining length={1}.", header.Buffer[0], header.RemainingLength));
using (var reader = new DataReader(socket.InputStream))
{
if (header.RemainingLength > 0)
{
// Create a buffer and read the remaining message
bytesRead = await reader.LoadAsync((uint)header.RemainingLength);
//_logger.LogMessage("Socket", LogLevel.Verbose,
// string.Format(" Bytes read= {0}.", bytesRead));
if (bytesRead > 0)
{
var remainingBuffer = new byte[reader.UnconsumedBufferLength];
reader.ReadBytes(remainingBuffer);
// Merge the fixed header and remaining buffers together
Array.ConstrainedCopy(remainingBuffer, 0, msgBuffer, header.HeaderSize, remainingBuffer.Length);
}
}
reader.DetachStream();
if (token.IsCancellationRequested)
{
// Operation was cancelled
return(null);
}
return(msgBuffer);
}
}
private void _read()
{
_header = new MqttFixedHeader(m_io, this, m_root);
switch (Header.MessageType)
{
case MqttMessageType.PingRequest: {
__raw_body = m_io.ReadBytes(Header.Length.Value);
var io___raw_body = new KaitaiStream(__raw_body);
_body = new MqttMessagePingRequest(io___raw_body, this, m_root);
break;
}
case MqttMessageType.PublishAck: {
__raw_body = m_io.ReadBytes(Header.Length.Value);
var io___raw_body = new KaitaiStream(__raw_body);
_body = new MqttMessagePublishAck(io___raw_body, this, m_root);
break;
}
case MqttMessageType.Disconnect: {
__raw_body = m_io.ReadBytes(Header.Length.Value);
var io___raw_body = new KaitaiStream(__raw_body);
_body = new MqttMessageDisconnect(io___raw_body, this, m_root);
break;
}
case MqttMessageType.PublishComp: {
__raw_body = m_io.ReadBytes(Header.Length.Value);
var io___raw_body = new KaitaiStream(__raw_body);
_body = new MqttMessagePublishComp(io___raw_body, this, m_root);
break;
}
case MqttMessageType.PublishRel: {
__raw_body = m_io.ReadBytes(Header.Length.Value);
var io___raw_body = new KaitaiStream(__raw_body);
_body = new MqttMessagePublishRel(io___raw_body, this, m_root);
break;
}
case MqttMessageType.SubscribeAck: {
__raw_body = m_io.ReadBytes(Header.Length.Value);
var io___raw_body = new KaitaiStream(__raw_body);
_body = new MqttMessageSubscribeAck(io___raw_body, this, m_root);
break;
}
case MqttMessageType.Connect: {
__raw_body = m_io.ReadBytes(Header.Length.Value);
var io___raw_body = new KaitaiStream(__raw_body);
_body = new MqttMessageConnect(io___raw_body, this, m_root);
break;
}
case MqttMessageType.Publish: {
__raw_body = m_io.ReadBytes(Header.Length.Value);
var io___raw_body = new KaitaiStream(__raw_body);
_body = new MqttMessagePublish(io___raw_body, this, m_root);
break;
}
case MqttMessageType.Connack: {
__raw_body = m_io.ReadBytes(Header.Length.Value);
var io___raw_body = new KaitaiStream(__raw_body);
_body = new MqttMessageConnack(io___raw_body, this, m_root);
break;
}
case MqttMessageType.UnsubscribeAck: {
__raw_body = m_io.ReadBytes(Header.Length.Value);
var io___raw_body = new KaitaiStream(__raw_body);
_body = new MqttMessageUnsubscribeAck(io___raw_body, this, m_root);
break;
}
case MqttMessageType.Unsubscribe: {
__raw_body = m_io.ReadBytes(Header.Length.Value);
var io___raw_body = new KaitaiStream(__raw_body);
_body = new MqttMessageUnsubscribe(io___raw_body, this, m_root);
break;
}
case MqttMessageType.Reserved0: {
__raw_body = m_io.ReadBytes(Header.Length.Value);
var io___raw_body = new KaitaiStream(__raw_body);
_body = new MqttMessageReserved0(io___raw_body, this, m_root);
break;
}
case MqttMessageType.Subscribe: {
__raw_body = m_io.ReadBytes(Header.Length.Value);
var io___raw_body = new KaitaiStream(__raw_body);
_body = new MqttMessageSubscribe(io___raw_body, this, m_root);
break;
}
case MqttMessageType.PublishRec: {
__raw_body = m_io.ReadBytes(Header.Length.Value);
var io___raw_body = new KaitaiStream(__raw_body);
_body = new MqttMessagePublishRec(io___raw_body, this, m_root);
break;
}
case MqttMessageType.Reserved15: {
__raw_body = m_io.ReadBytes(Header.Length.Value);
var io___raw_body = new KaitaiStream(__raw_body);
_body = new MqttMessageReserved15(io___raw_body, this, m_root);
break;
}
case MqttMessageType.PingResponse: {
__raw_body = m_io.ReadBytes(Header.Length.Value);
var io___raw_body = new KaitaiStream(__raw_body);
_body = new MqttMessageResponse(io___raw_body, this, m_root);
break;
}
default: {
_body = m_io.ReadBytes(Header.Length.Value);
break;
}
}
}
