static MqttBasePacket DecodePublishPacket(ReceivedMqttPacket receivedMqttPacket)
{
ThrowIfBodyIsEmpty(receivedMqttPacket.Body);
var retain = (receivedMqttPacket.FixedHeader & 0x1) > 0;
var qualityOfServiceLevel = (MqttQualityOfServiceLevel)(receivedMqttPacket.FixedHeader >> 1 & 0x3);
var dup = (receivedMqttPacket.FixedHeader & 0x8) > 0;
var topic = receivedMqttPacket.Body.ReadStringWithLengthPrefix();
ushort?packetIdentifier = null;
if (qualityOfServiceLevel > MqttQualityOfServiceLevel.AtMostOnce)
{
packetIdentifier = receivedMqttPacket.Body.ReadTwoByteInteger();
}
var packet = new MqttPublishPacket
{
PacketIdentifier = packetIdentifier,
Retain = retain,
Topic = topic,
QualityOfServiceLevel = qualityOfServiceLevel,
Dup = dup
};
if (!receivedMqttPacket.Body.EndOfStream)
{
packet.Payload = receivedMqttPacket.Body.ReadRemainingData();
}
return(packet);
}
private static MqttBasePacket DeserializePublish(ReceivedMqttPacket receivedMqttPacket)
{
ThrowIfBodyIsEmpty(receivedMqttPacket.Body);
var retain = (receivedMqttPacket.FixedHeader & 0x1) > 0;
var qualityOfServiceLevel = (MqttQualityOfServiceLevel)(receivedMqttPacket.FixedHeader >> 1 & 0x3);
var dup = (receivedMqttPacket.FixedHeader & 0x8) > 0;
var topic = receivedMqttPacket.Body.ReadStringWithLengthPrefix();
ushort?packetIdentifier = null;
if (qualityOfServiceLevel > MqttQualityOfServiceLevel.AtMostOnce)
{
packetIdentifier = receivedMqttPacket.Body.ReadUInt16();
}
var packet = new MqttPublishPacket
{
PacketIdentifier = packetIdentifier,
Retain = retain,
Topic = topic,
Payload = receivedMqttPacket.Body.ReadRemainingData().ToArray(),
QualityOfServiceLevel = qualityOfServiceLevel,
Dup = dup
};
return(packet);
}
MqttPacket DecodePublishPacket(ReceivedMqttPacket receivedMqttPacket)
{
ThrowIfBodyIsEmpty(receivedMqttPacket.Body);
_bufferReader.SetBuffer(receivedMqttPacket.Body.Array, receivedMqttPacket.Body.Offset, receivedMqttPacket.Body.Count);
var retain = (receivedMqttPacket.FixedHeader & 0x1) > 0;
var qualityOfServiceLevel = (MqttQualityOfServiceLevel)((receivedMqttPacket.FixedHeader >> 1) & 0x3);
var dup = (receivedMqttPacket.FixedHeader & 0x8) > 0;
var topic = _bufferReader.ReadString();
ushort packetIdentifier = 0;
if (qualityOfServiceLevel > MqttQualityOfServiceLevel.AtMostOnce)
{
packetIdentifier = _bufferReader.ReadTwoByteInteger();
}
var packet = new MqttPublishPacket
{
PacketIdentifier = packetIdentifier,
Retain = retain,
Topic = topic,
QualityOfServiceLevel = qualityOfServiceLevel,
Dup = dup
};
if (!_bufferReader.EndOfStream)
{
packet.Payload = _bufferReader.ReadRemainingData();
}
return(packet);
}
public MqttBasePacket Decode(ReceivedMqttPacket receivedMqttPacket)
{
if (receivedMqttPacket == null)
{
throw new ArgumentNullException(nameof(receivedMqttPacket));
}
return(_decoder.Decode(receivedMqttPacket));
}
public MqttBasePacket Decode(ReceivedMqttPacket receivedMqttPacket)
{
if (receivedMqttPacket == null)
{
throw new ArgumentNullException(nameof(receivedMqttPacket));
}
ThrowIfFormatterNotSet();
return(_formatter.Decode(receivedMqttPacket));
}
public void DetectProtocolVersion(ReceivedMqttPacket receivedMqttPacket)
{
var protocolVersion = ParseProtocolVersion(receivedMqttPacket);
// Reset the position of the stream because the protocol version is part of
// the regular CONNECT packet. So it will not properly deserialized if this
// data is missing.
receivedMqttPacket.Body.Seek(0);
UseProtocolVersion(protocolVersion);
}
public MqttBasePacket Deserialize(ReceivedMqttPacket receivedMqttPacket)
{
if (receivedMqttPacket == null)
{
throw new ArgumentNullException(nameof(receivedMqttPacket));
}
using (var reader = new MqttPacketReader(receivedMqttPacket))
{
return(Deserialize(receivedMqttPacket.Header, reader));
}
}
public MqttBasePacket Decode(ReceivedMqttPacket receivedMqttPacket)
{
if (receivedMqttPacket == null)
{
throw new ArgumentNullException(nameof(receivedMqttPacket));
}
var controlPacketType = receivedMqttPacket.FixedHeader >> 4;
if (controlPacketType < 1 || controlPacketType > 15)
{
throw new MqttProtocolViolationException($"The packet type is invalid ({controlPacketType}).");
}
switch ((MqttControlPacketType)controlPacketType)
{
case MqttControlPacketType.Connect: return(DecodeConnectPacket(receivedMqttPacket.Body));
case MqttControlPacketType.ConnAck: return(DecodeConnAckPacket(receivedMqttPacket.Body));
case MqttControlPacketType.Disconnect: return(DecodeDisconnectPacket(receivedMqttPacket.Body));
case MqttControlPacketType.Publish: return(DecodePublishPacket(receivedMqttPacket.FixedHeader, receivedMqttPacket.Body));
case MqttControlPacketType.PubAck: return(DecodePubAckPacket(receivedMqttPacket.Body));
case MqttControlPacketType.PubRec: return(DecodePubRecPacket(receivedMqttPacket.Body));
case MqttControlPacketType.PubRel: return(DecodePubRelPacket(receivedMqttPacket.Body));
case MqttControlPacketType.PubComp: return(DecodePubCompPacket(receivedMqttPacket.Body));
case MqttControlPacketType.PingReq: return(DecodePingReqPacket());
case MqttControlPacketType.PingResp: return(DecodePingRespPacket());
case MqttControlPacketType.Subscribe: return(DecodeSubscribePacket(receivedMqttPacket.Body));
case MqttControlPacketType.SubAck: return(DecodeSubAckPacket(receivedMqttPacket.Body));
case MqttControlPacketType.Unsubscibe: return(DecodeUnsubscribePacket(receivedMqttPacket.Body));
case MqttControlPacketType.UnsubAck: return(DecodeUnsubAckPacket(receivedMqttPacket.Body));
case MqttControlPacketType.Auth: return(DecodeAuthPacket(receivedMqttPacket.Body));
default: throw new MqttProtocolViolationException($"Packet type ({controlPacketType}) not supported.");
}
}
public void Serialize_LargePacket()
{
var serializer = new MqttPacketSerializer {
ProtocolVersion = MqttProtocolVersion.V311
};
const int payloadLength = 80000;
var payload = new byte[payloadLength];
var value = 0;
for (var i = 0; i < payloadLength; i++)
{
if (value > 255)
{
value = 0;
}
payload[i] = (byte)value;
}
var publishPacket = new MqttPublishPacket
{
Topic = "abcdefghijklmnopqrstuvwxyz0123456789",
Payload = payload
};
var buffer = serializer.Serialize(publishPacket);
var testChannel = new TestMqttChannel(new MemoryStream(buffer.Array, buffer.Offset, buffer.Count));
var header = MqttPacketReader.ReadFixedHeaderAsync(
testChannel,
new byte[2],
new byte[1],
CancellationToken.None).GetAwaiter().GetResult();
var eof = buffer.Offset + buffer.Count;
var receivedPacket = new ReceivedMqttPacket(
header.Flags,
new MqttPacketBodyReader(buffer.Array, eof - header.RemainingLength, buffer.Count + buffer.Offset));
var packet = (MqttPublishPacket)serializer.Deserialize(receivedPacket);
Assert.AreEqual(publishPacket.Topic, packet.Topic);
Assert.IsTrue(publishPacket.Payload.SequenceEqual(packet.Payload));
}
MqttProtocolVersion ParseProtocolVersion(ReceivedMqttPacket receivedMqttPacket)
{
if (receivedMqttPacket.Body.Count < 7)
{
// 2 byte protocol name length
// at least 4 byte protocol name
// 1 byte protocol level
throw new MqttProtocolViolationException("CONNECT packet must have at least 7 bytes.");
}
_bufferReader.SetBuffer(receivedMqttPacket.Body.Array, receivedMqttPacket.Body.Offset, receivedMqttPacket.Body.Count);
var protocolName = _bufferReader.ReadString();
var protocolLevel = _bufferReader.ReadByte();
// Remove the mosquitto try_private flag (MQTT 3.1.1 Bridge).
// This flag is accepted but not yet used.
protocolLevel &= 0x7F;
if (protocolName == "MQTT")
{
if (protocolLevel == 5)
{
return(MqttProtocolVersion.V500);
}
if (protocolLevel == 4)
{
return(MqttProtocolVersion.V311);
}
throw new MqttProtocolViolationException($"Protocol level '{protocolLevel}' not supported.");
}
if (protocolName == "MQIsdp")
{
if (protocolLevel == 3)
{
return(MqttProtocolVersion.V310);
}
throw new MqttProtocolViolationException($"Protocol level '{protocolLevel}' not supported.");
}
throw new MqttProtocolViolationException($"Protocol '{protocolName}' not supported.");
}
static MqttProtocolVersion ParseProtocolVersion(ReceivedMqttPacket receivedMqttPacket)
{
if (receivedMqttPacket == null)
{
throw new ArgumentNullException(nameof(receivedMqttPacket));
}
if (receivedMqttPacket.Body.Length < 7)
{
// 2 byte protocol name length
// at least 4 byte protocol name
// 1 byte protocol level
throw new MqttProtocolViolationException("CONNECT packet must have at least 7 bytes.");
}
var protocolName = receivedMqttPacket.Body.ReadStringWithLengthPrefix();
var protocolLevel = receivedMqttPacket.Body.ReadByte();
if (protocolName == "MQTT")
{
if (protocolLevel == 5)
{
return(MqttProtocolVersion.V500);
}
if (protocolLevel == 4)
{
return(MqttProtocolVersion.V311);
}
throw new MqttProtocolViolationException($"Protocol level '{protocolLevel}' not supported.");
}
if (protocolName == "MQIsdp")
{
if (protocolLevel == 3)
{
return(MqttProtocolVersion.V310);
}
throw new MqttProtocolViolationException($"Protocol level '{protocolLevel}' not supported.");
}
throw new MqttProtocolViolationException($"Protocol '{protocolName}' not supported.");
}
private MqttProtocolVersion DeserializeAndDetectVersion(MqttPacketFormatterAdapter adapter, byte[] buffer)
{
using (var headerStream = new MemoryStream(buffer))
{
var channel = new TestMqttChannel(headerStream);
var fixedHeader = new byte[2];
var header = new MqttPacketReader(channel).ReadFixedHeaderAsync(fixedHeader, CancellationToken.None).GetAwaiter().GetResult().FixedHeader;
using (var bodyStream = new MemoryStream(buffer, (int)headerStream.Position, (int)header.RemainingLength))
{
var reader = ReaderFactory(bodyStream.ToArray());
var packet = new ReceivedMqttPacket(header.Flags, reader, 0);
adapter.DetectProtocolVersion(packet);
return(adapter.ProtocolVersion);
}
}
}
public void Deserialize_10000_Messages()
{
var channel = new BenchmarkMqttChannel(_serializedPacket);
var fixedHeader = new byte[2];
var singleByteBuffer = new byte[1];
for (var i = 0; i < 10000; i++)
{
channel.Reset();
var header = MqttPacketReader.ReadFixedHeaderAsync(channel, fixedHeader, singleByteBuffer, CancellationToken.None).GetAwaiter().GetResult();
var receivedPacket = new ReceivedMqttPacket(
header.Flags,
new MqttPacketBodyReader(_serializedPacket.Array, _serializedPacket.Count - header.RemainingLength, _serializedPacket.Array.Length));
_serializer.Deserialize(receivedPacket);
}
}
MqttProtocolVersion ParseProtocolVersion(ReceivedMqttPacket receivedMqttPacket)
{
if (receivedMqttPacket.Body.Count < 7)
{
// 2 byte protocol name length
// at least 4 byte protocol name
// 1 byte protocol level
throw new MqttProtocolViolationException("CONNECT packet must have at least 7 bytes.");
}
_bufferReader.SetBuffer(receivedMqttPacket.Body.Array, receivedMqttPacket.Body.Offset, receivedMqttPacket.Body.Count);
var protocolName = _bufferReader.ReadString();
var protocolLevel = _bufferReader.ReadByte();
if (protocolName == "MQTT")
{
if (protocolLevel == 5)
{
return(MqttProtocolVersion.V500);
}
if (protocolLevel == 4)
{
return(MqttProtocolVersion.V311);
}
throw new MqttProtocolViolationException($"Protocol level '{protocolLevel}' not supported.");
}
if (protocolName == "MQIsdp")
{
if (protocolLevel == 3)
{
return(MqttProtocolVersion.V310);
}
throw new MqttProtocolViolationException($"Protocol level '{protocolLevel}' not supported.");
}
throw new MqttProtocolViolationException($"Protocol '{protocolName}' not supported.");
}
private MqttProtocolVersion ParseProtocolVersion(ReceivedMqttPacket receivedMqttPacket)
{
if (receivedMqttPacket == null)
{
throw new ArgumentNullException(nameof(receivedMqttPacket));
}
var protocolName = receivedMqttPacket.Body.ReadStringWithLengthPrefix();
var protocolLevel = receivedMqttPacket.Body.ReadByte();
if (protocolName == "MQTT")
{
if (protocolLevel == 5)
{
return(MqttProtocolVersion.V500);
}
if (protocolLevel == 4)
{
return(MqttProtocolVersion.V311);
}
throw new MqttProtocolViolationException($"Protocol level '{protocolLevel}' not supported.");
}
if (protocolName == "MQIsdp")
{
if (protocolLevel == 3)
{
return(MqttProtocolVersion.V310);
}
throw new MqttProtocolViolationException($"Protocol level '{protocolLevel}' not supported.");
}
throw new MqttProtocolViolationException($"Protocol '{protocolName}' not supported.");
}
public MqttPacket Decode(ReceivedMqttPacket receivedMqttPacket)
{
return(_decoder.Decode(receivedMqttPacket));
}
public MqttPacket Decode(ReceivedMqttPacket receivedMqttPacket)
{
if (receivedMqttPacket.TotalLength == 0)
{
return(null);
}
var controlPacketType = receivedMqttPacket.FixedHeader >> 4;
if (controlPacketType < 1 || controlPacketType > 14)
{
throw new MqttProtocolViolationException($"The packet type is invalid ({controlPacketType}).");
}
switch ((MqttControlPacketType)controlPacketType)
{
case MqttControlPacketType.Publish:
return(DecodePublishPacket(receivedMqttPacket));
case MqttControlPacketType.PubAck:
return(DecodePubAckPacket(receivedMqttPacket.Body));
case MqttControlPacketType.PubRec:
return(DecodePubRecPacket(receivedMqttPacket.Body));
case MqttControlPacketType.PubRel:
return(DecodePubRelPacket(receivedMqttPacket.Body));
case MqttControlPacketType.PubComp:
return(DecodePubCompPacket(receivedMqttPacket.Body));
case MqttControlPacketType.PingReq:
return(MqttPingReqPacket.Instance);
case MqttControlPacketType.PingResp:
return(MqttPingRespPacket.Instance);
case MqttControlPacketType.Connect:
return(DecodeConnectPacket(receivedMqttPacket.Body));
case MqttControlPacketType.ConnAck:
if (_mqttProtocolVersion == MqttProtocolVersion.V311)
{
return(DecodeConnAckPacketV311(receivedMqttPacket.Body));
}
else
{
return(DecodeConnAckPacket(receivedMqttPacket.Body));
}
case MqttControlPacketType.Disconnect:
return(DisconnectPacket);
case MqttControlPacketType.Subscribe:
return(DecodeSubscribePacket(receivedMqttPacket.Body));
case MqttControlPacketType.SubAck:
return(DecodeSubAckPacket(receivedMqttPacket.Body));
case MqttControlPacketType.Unsubscibe:
return(DecodeUnsubscribePacket(receivedMqttPacket.Body));
case MqttControlPacketType.UnsubAck:
return(DecodeUnsubAckPacket(receivedMqttPacket.Body));
default:
throw new MqttProtocolViolationException($"Packet type ({controlPacketType}) not supported.");
}
}
public MqttPacketReader(ReceivedMqttPacket receivedMqttPacket)
: base(receivedMqttPacket.Body, Encoding.UTF8, true)
{
_receivedMqttPacket = receivedMqttPacket;
}
public MqttPacket Decode(ReceivedMqttPacket receivedMqttPacket)
{
ThrowIfFormatterNotSet();
return(_formatter.Decode(receivedMqttPacket));
}
public void DetectProtocolVersion(ReceivedMqttPacket receivedMqttPacket)
{
var protocolVersion = ParseProtocolVersion(receivedMqttPacket);
UseProtocolVersion(protocolVersion);
}
