private static byte Serialize(MqttSubscribePacket packet, MqttPacketWriter packetWriter)
{
if (!packet.TopicFilters.Any())
{
throw new MqttProtocolViolationException("At least one topic filter must be set [MQTT-3.8.3-3].");
}
if (!packet.PacketIdentifier.HasValue)
{
throw new MqttProtocolViolationException("Subscribe packet has no packet identifier.");
}
packetWriter.Write(packet.PacketIdentifier.Value);
if (packet.TopicFilters?.Count > 0)
{
foreach (var topicFilter in packet.TopicFilters)
{
packetWriter.WriteWithLengthPrefix(topicFilter.Topic);
packetWriter.Write((byte)topicFilter.QualityOfServiceLevel);
}
}
return(MqttPacketWriter.BuildFixedHeader(MqttControlPacketType.Subscribe, 0x02));
}
private byte Serialize(MqttConnAckPacket packet, MqttPacketWriter packetWriter)
{
if (ProtocolVersion == MqttProtocolVersion.V310)
{
packetWriter.Write(0);
}
else if (ProtocolVersion == MqttProtocolVersion.V311)
{
byte connectAcknowledgeFlags = 0x0;
if (packet.IsSessionPresent)
{
connectAcknowledgeFlags |= 0x1;
}
packetWriter.Write(connectAcknowledgeFlags);
}
else
{
throw new MqttProtocolViolationException("Protocol version not supported.");
}
packetWriter.Write((byte)packet.ConnectReturnCode);
return(MqttPacketWriter.BuildFixedHeader(MqttControlPacketType.ConnAck));
}
public ArraySegment <byte> Serialize(MqttBasePacket packet)
{
if (packet == null)
{
throw new ArgumentNullException(nameof(packet));
}
// Leave enough head space for max header size (fixed + 4 variable remaining length = 5 bytes)
_packetWriter.Reset();
_packetWriter.Seek(5);
var fixedHeader = SerializePacket(packet, _packetWriter);
var remainingLength = _packetWriter.Length - 5;
var remainingLengthBuffer = MqttPacketWriter.EncodeRemainingLength(remainingLength);
var headerSize = FixedHeaderSize + remainingLengthBuffer.Count;
var headerOffset = 5 - headerSize;
// Position cursor on correct offset on beginining of array (has leading 0x0)
_packetWriter.Seek(headerOffset);
_packetWriter.Write(fixedHeader);
_packetWriter.Write(remainingLengthBuffer.Array, remainingLengthBuffer.Offset, remainingLengthBuffer.Count);
var buffer = _packetWriter.GetBuffer();
return(new ArraySegment <byte>(buffer, headerOffset, _packetWriter.Length - headerOffset));
}
private byte SerializePacket(MqttBasePacket packet, MqttPacketWriter packetWriter)
{
switch (packet)
{
case MqttConnectPacket connectPacket: return(Serialize(connectPacket, packetWriter));
case MqttConnAckPacket connAckPacket: return(Serialize(connAckPacket, packetWriter));
case MqttDisconnectPacket _: return(SerializeEmptyPacket(MqttControlPacketType.Disconnect));
case MqttPingReqPacket _: return(SerializeEmptyPacket(MqttControlPacketType.PingReq));
case MqttPingRespPacket _: return(SerializeEmptyPacket(MqttControlPacketType.PingResp));
case MqttPublishPacket publishPacket: return(Serialize(publishPacket, packetWriter));
case MqttPubAckPacket pubAckPacket: return(Serialize(pubAckPacket, packetWriter));
case MqttPubRecPacket pubRecPacket: return(Serialize(pubRecPacket, packetWriter));
case MqttPubRelPacket pubRelPacket: return(Serialize(pubRelPacket, packetWriter));
case MqttPubCompPacket pubCompPacket: return(Serialize(pubCompPacket, packetWriter));
case MqttSubscribePacket subscribePacket: return(Serialize(subscribePacket, packetWriter));
case MqttSubAckPacket subAckPacket: return(Serialize(subAckPacket, packetWriter));
case MqttUnsubscribePacket unsubscribePacket: return(Serialize(unsubscribePacket, packetWriter));
case MqttUnsubAckPacket unsubAckPacket: return(Serialize(unsubAckPacket, packetWriter));
default: throw new MqttProtocolViolationException("Packet type invalid.");
}
}
private static byte Serialize(MqttUnsubAckPacket packet, MqttPacketWriter packetWriter)
{
if (!packet.PacketIdentifier.HasValue)
{
throw new MqttProtocolViolationException("UnsubAck packet has no packet identifier.");
}
packetWriter.Write(packet.PacketIdentifier.Value);
return(MqttPacketWriter.BuildFixedHeader(MqttControlPacketType.UnsubAck));
}
private static byte Serialize(MqttPublishPacket packet, MqttPacketWriter packetWriter)
{
ValidatePublishPacket(packet);
packetWriter.WriteWithLengthPrefix(packet.Topic);
if (packet.QualityOfServiceLevel > MqttQualityOfServiceLevel.AtMostOnce)
{
if (!packet.PacketIdentifier.HasValue)
{
throw new MqttProtocolViolationException("Publish packet has no packet identifier.");
}
packetWriter.Write(packet.PacketIdentifier.Value);
}
else
{
if (packet.PacketIdentifier > 0)
{
throw new MqttProtocolViolationException("Packet identifier must be empty if QoS == 0 [MQTT-2.3.1-5].");
}
}
if (packet.Payload?.Length > 0)
{
packetWriter.Write(packet.Payload, 0, packet.Payload.Length);
}
byte fixedHeader = 0;
if (packet.Retain)
{
fixedHeader |= 0x01;
}
fixedHeader |= (byte)((byte)packet.QualityOfServiceLevel << 1);
if (packet.Dup)
{
fixedHeader |= 0x08;
}
return(MqttPacketWriter.BuildFixedHeader(MqttControlPacketType.Publish, fixedHeader));
}
private static byte Serialize(MqttSubAckPacket packet, MqttPacketWriter packetWriter)
{
if (!packet.PacketIdentifier.HasValue)
{
throw new MqttProtocolViolationException("SubAck packet has no packet identifier.");
}
packetWriter.Write(packet.PacketIdentifier.Value);
if (packet.SubscribeReturnCodes?.Any() == true)
{
foreach (var packetSubscribeReturnCode in packet.SubscribeReturnCodes)
{
packetWriter.Write((byte)packetSubscribeReturnCode);
}
}
return(MqttPacketWriter.BuildFixedHeader(MqttControlPacketType.SubAck));
}
private static byte Serialize(MqttUnsubscribePacket packet, MqttPacketWriter packetWriter)
{
if (!packet.TopicFilters.Any())
{
throw new MqttProtocolViolationException("At least one topic filter must be set [MQTT-3.10.3-2].");
}
if (!packet.PacketIdentifier.HasValue)
{
throw new MqttProtocolViolationException("Unsubscribe packet has no packet identifier.");
}
packetWriter.Write(packet.PacketIdentifier.Value);
if (packet.TopicFilters?.Any() == true)
{
foreach (var topicFilter in packet.TopicFilters)
{
packetWriter.WriteWithLengthPrefix(topicFilter);
}
}
return(MqttPacketWriter.BuildFixedHeader(MqttControlPacketType.Unsubscibe, 0x02));
}
private static byte SerializeEmptyPacket(MqttControlPacketType type)
{
return(MqttPacketWriter.BuildFixedHeader(type));
}
private byte Serialize(MqttConnectPacket packet, MqttPacketWriter packetWriter)
{
ValidateConnectPacket(packet);
// Write variable header
if (ProtocolVersion == MqttProtocolVersion.V311)
{
packetWriter.WriteWithLengthPrefix("MQTT");
packetWriter.Write(4); // 3.1.2.2 Protocol Level 4
}
else
{
packetWriter.WriteWithLengthPrefix("MQIsdp");
packetWriter.Write(3); // Protocol Level 3
}
byte connectFlags = 0x0;
if (packet.CleanSession)
{
connectFlags |= 0x2;
}
if (packet.WillMessage != null)
{
connectFlags |= 0x4;
connectFlags |= (byte)((byte)packet.WillMessage.QualityOfServiceLevel << 3);
if (packet.WillMessage.Retain)
{
connectFlags |= 0x20;
}
}
if (packet.Password != null && packet.Username == null)
{
throw new MqttProtocolViolationException("If the User Name Flag is set to 0, the Password Flag MUST be set to 0 [MQTT-3.1.2-22].");
}
if (packet.Password != null)
{
connectFlags |= 0x40;
}
if (packet.Username != null)
{
connectFlags |= 0x80;
}
packetWriter.Write(connectFlags);
packetWriter.Write(packet.KeepAlivePeriod);
packetWriter.WriteWithLengthPrefix(packet.ClientId);
if (packet.WillMessage != null)
{
packetWriter.WriteWithLengthPrefix(packet.WillMessage.Topic);
packetWriter.WriteWithLengthPrefix(packet.WillMessage.Payload);
}
if (packet.Username != null)
{
packetWriter.WriteWithLengthPrefix(packet.Username);
}
if (packet.Password != null)
{
packetWriter.WriteWithLengthPrefix(packet.Password);
}
return(MqttPacketWriter.BuildFixedHeader(MqttControlPacketType.Connect));
}