private async Task <MqttBasePacket> DeserializePublishAsync(MqttPacketReader reader)
{
var fixedHeader = new ByteReader(reader.FixedHeader);
var retain = fixedHeader.Read();
var qualityOfServiceLevel = (MqttQualityOfServiceLevel)fixedHeader.Read(2);
var dup = fixedHeader.Read();
var topic = await reader.ReadRemainingDataStringWithLengthPrefixAsync();
ushort packetIdentifier = 0;
if (qualityOfServiceLevel > MqttQualityOfServiceLevel.AtMostOnce)
{
packetIdentifier = await reader.ReadRemainingDataUShortAsync();
}
var packet = new MqttPublishPacket
{
Retain = retain,
QualityOfServiceLevel = qualityOfServiceLevel,
Dup = dup,
Topic = topic,
Payload = await reader.ReadRemainingDataAsync(),
PacketIdentifier = packetIdentifier
};
return(packet);
}
private static MqttBasePacket DeserializePubAck(MqttPacketReader reader)
{
return(new MqttPubAckPacket
{
PacketIdentifier = reader.ReadUInt16()
});
}
private static MqttBasePacket DeserializePublish(MqttPacketReader reader, MqttPacketHeader mqttPacketHeader)
{
var fixedHeader = new ByteReader(mqttPacketHeader.FixedHeader);
var retain = fixedHeader.Read();
var qualityOfServiceLevel = (MqttQualityOfServiceLevel)fixedHeader.Read(2);
var dup = fixedHeader.Read();
var topic = reader.ReadStringWithLengthPrefix();
ushort packetIdentifier = 0;
if (qualityOfServiceLevel > MqttQualityOfServiceLevel.AtMostOnce)
{
packetIdentifier = reader.ReadUInt16();
}
var packet = new MqttPublishPacket
{
Retain = retain,
QualityOfServiceLevel = qualityOfServiceLevel,
Dup = dup,
Topic = topic,
Payload = reader.ReadRemainingData(),
PacketIdentifier = packetIdentifier
};
return(packet);
}
private static MqttBasePacket Deserialize(MqttPacketHeader header, MqttPacketReader reader)
{
switch (header.ControlPacketType)
{
case MqttControlPacketType.Connect: return(DeserializeConnect(reader));
case MqttControlPacketType.ConnAck: return(DeserializeConnAck(reader));
case MqttControlPacketType.Disconnect: return(new MqttDisconnectPacket());
case MqttControlPacketType.Publish: return(DeserializePublish(reader, header));
case MqttControlPacketType.PubAck: return(DeserializePubAck(reader));
case MqttControlPacketType.PubRec: return(DeserializePubRec(reader));
case MqttControlPacketType.PubRel: return(DeserializePubRel(reader));
case MqttControlPacketType.PubComp: return(DeserializePubComp(reader));
case MqttControlPacketType.PingReq: return(new MqttPingReqPacket());
case MqttControlPacketType.PingResp: return(new MqttPingRespPacket());
case MqttControlPacketType.Subscribe: return(DeserializeSubscribe(reader));
case MqttControlPacketType.SubAck: return(DeserializeSubAck(reader));
case MqttControlPacketType.Unsubscibe: return(DeserializeUnsubscribe(reader));
case MqttControlPacketType.UnsubAck: return(DeserializeUnsubAck(reader));
default: throw new MqttProtocolViolationException($"Packet type ({(int)header.ControlPacketType}) not supported.");
}
}
private static async Task <MqttBasePacket> DeserializeConnectAsync(MqttPacketReader reader)
{
await reader.ReadRemainingDataAsync(2); // Skip 2 bytes
var protocolName = await reader.ReadRemainingDataAsync(4);
if (Encoding.UTF8.GetString(protocolName, 0, protocolName.Length) != "MQTT")
{
throw new MqttProtocolViolationException("Protocol name is not 'MQTT'.");
}
var protocolLevel = await reader.ReadRemainingDataByteAsync();
var connectFlags = await reader.ReadRemainingDataByteAsync();
var connectFlagsReader = new ByteReader(connectFlags);
connectFlagsReader.Read(); // Reserved.
var packet = new MqttConnectPacket
{
CleanSession = connectFlagsReader.Read()
};
var willFlag = connectFlagsReader.Read();
var willQoS = connectFlagsReader.Read(2);
var willRetain = connectFlagsReader.Read();
var passwordFlag = connectFlagsReader.Read();
var usernameFlag = connectFlagsReader.Read();
packet.KeepAlivePeriod = await reader.ReadRemainingDataUShortAsync();
packet.ClientId = await reader.ReadRemainingDataStringWithLengthPrefixAsync();
if (willFlag)
{
packet.WillMessage = new MqttApplicationMessage(
await reader.ReadRemainingDataStringWithLengthPrefixAsync(),
await reader.ReadRemainingDataWithLengthPrefixAsync(),
(MqttQualityOfServiceLevel)willQoS,
willRetain);
}
if (usernameFlag)
{
packet.Username = await reader.ReadRemainingDataStringWithLengthPrefixAsync();
}
if (passwordFlag)
{
packet.Password = await reader.ReadRemainingDataStringWithLengthPrefixAsync();
}
ValidateConnectPacket(packet);
return(packet);
}
public MqttBasePacket Deserialize(ReceivedMqttPacket receivedMqttPacket)
{
if (receivedMqttPacket == null)
{
throw new ArgumentNullException(nameof(receivedMqttPacket));
}
using (var reader = new MqttPacketReader(receivedMqttPacket))
{
return(Deserialize(receivedMqttPacket.Header, reader));
}
}
private static MqttBasePacket DeserializeConnAck(MqttPacketReader reader)
{
var variableHeader1 = reader.ReadByte();
var variableHeader2 = reader.ReadByte();
var packet = new MqttConnAckPacket
{
IsSessionPresent = new ByteReader(variableHeader1).Read(),
ConnectReturnCode = (MqttConnectReturnCode)variableHeader2
};
return(packet);
}
private static MqttBasePacket DeserializeUnsubscribe(MqttPacketReader reader)
{
var packet = new MqttUnsubscribePacket
{
PacketIdentifier = reader.ReadUInt16(),
};
while (!reader.EndOfRemainingData)
{
packet.TopicFilters.Add(reader.ReadStringWithLengthPrefix());
}
return(packet);
}
private static MqttBasePacket DeserializeSubAck(MqttPacketReader reader)
{
var packet = new MqttSubAckPacket
{
PacketIdentifier = reader.ReadUInt16()
};
while (!reader.EndOfRemainingData)
{
packet.SubscribeReturnCodes.Add((MqttSubscribeReturnCode)reader.ReadByte());
}
return(packet);
}
private async Task <MqttBasePacket> DeserializeUnsubscribeAsync(MqttPacketReader reader)
{
var packet = new MqttUnsubscribePacket
{
PacketIdentifier = await reader.ReadRemainingDataUShortAsync(),
};
while (!reader.EndOfRemainingData)
{
packet.TopicFilters.Add(await reader.ReadRemainingDataStringWithLengthPrefixAsync());
}
return(packet);
}
private async Task <MqttBasePacket> DeserializeSubAck(MqttPacketReader reader)
{
var packet = new MqttSubAckPacket
{
PacketIdentifier = await reader.ReadRemainingDataUShortAsync()
};
while (!reader.EndOfRemainingData)
{
packet.SubscribeReturnCodes.Add((MqttSubscribeReturnCode)await reader.ReadRemainingDataByteAsync());
}
return(packet);
}
private async Task <MqttBasePacket> DeserializeConnAck(MqttPacketReader reader)
{
var variableHeader1 = await reader.ReadRemainingDataByteAsync();
var variableHeader2 = await reader.ReadRemainingDataByteAsync();
var packet = new MqttConnAckPacket
{
IsSessionPresent = new ByteReader(variableHeader1).Read(),
ConnectReturnCode = (MqttConnectReturnCode)variableHeader2
};
return(packet);
}
private static async Task <MqttBasePacket> DeserializeSubscribeAsync(MqttPacketReader reader)
{
var packet = new MqttSubscribePacket
{
PacketIdentifier = await reader.ReadRemainingDataUShortAsync(),
};
while (!reader.EndOfRemainingData)
{
packet.TopicFilters.Add(new TopicFilter(
await reader.ReadRemainingDataStringWithLengthPrefixAsync(),
(MqttQualityOfServiceLevel)await reader.ReadRemainingDataByteAsync()));
}
return(packet);
}
private static MqttBasePacket DeserializeSubscribe(MqttPacketReader reader)
{
var packet = new MqttSubscribePacket
{
PacketIdentifier = reader.ReadUInt16()
};
while (!reader.EndOfRemainingData)
{
packet.TopicFilters.Add(new TopicFilter(
reader.ReadStringWithLengthPrefix(),
(MqttQualityOfServiceLevel)reader.ReadByte()));
}
return(packet);
}
private static MqttBasePacket DeserializeConnect(MqttPacketReader reader)
{
reader.ReadBytes(2); // Skip 2 bytes
MqttProtocolVersion protocolVersion;
var protocolName = reader.ReadBytes(4);
if (protocolName.SequenceEqual(ProtocolVersionV310Name))
{
reader.ReadBytes(2);
protocolVersion = MqttProtocolVersion.V310;
}
else if (protocolName.SequenceEqual(ProtocolVersionV311Name))
{
protocolVersion = MqttProtocolVersion.V311;
}
else
{
throw new MqttProtocolViolationException("Protocol name is not supported.");
}
reader.ReadByte(); // Skip protocol level
var connectFlags = reader.ReadByte();
var connectFlagsReader = new ByteReader(connectFlags);
connectFlagsReader.Read(); // Reserved.
var packet = new MqttConnectPacket
{
ProtocolVersion = protocolVersion,
CleanSession = connectFlagsReader.Read()
};
var willFlag = connectFlagsReader.Read();
var willQoS = connectFlagsReader.Read(2);
var willRetain = connectFlagsReader.Read();
var passwordFlag = connectFlagsReader.Read();
var usernameFlag = connectFlagsReader.Read();
packet.KeepAlivePeriod = reader.ReadUInt16();
packet.ClientId = reader.ReadStringWithLengthPrefix();
if (willFlag)
{
packet.WillMessage = new MqttApplicationMessage
{
Topic = reader.ReadStringWithLengthPrefix(),
Payload = reader.ReadWithLengthPrefix(),
QualityOfServiceLevel = (MqttQualityOfServiceLevel)willQoS,
Retain = willRetain
};
}
if (usernameFlag)
{
packet.Username = reader.ReadStringWithLengthPrefix();
}
if (passwordFlag)
{
packet.Password = reader.ReadStringWithLengthPrefix();
}
ValidateConnectPacket(packet);
return(packet);
}
public async Task <MqttBasePacket> DeserializeAsync(IMqttCommunicationChannel source)
{
if (source == null)
{
throw new ArgumentNullException(nameof(source));
}
using (var mqttPacketReader = new MqttPacketReader(source))
{
await mqttPacketReader.ReadToEndAsync();
switch (mqttPacketReader.ControlPacketType)
{
case MqttControlPacketType.Connect:
{
return(await DeserializeConnectAsync(mqttPacketReader));
}
case MqttControlPacketType.ConnAck:
{
return(await DeserializeConnAck(mqttPacketReader));
}
case MqttControlPacketType.Disconnect:
{
return(new MqttDisconnectPacket());
}
case MqttControlPacketType.Publish:
{
return(await DeserializePublishAsync(mqttPacketReader));
}
case MqttControlPacketType.PubAck:
{
return(new MqttPubAckPacket
{
PacketIdentifier = await mqttPacketReader.ReadRemainingDataUShortAsync()
});
}
case MqttControlPacketType.PubRec:
{
return(new MqttPubRecPacket
{
PacketIdentifier = await mqttPacketReader.ReadRemainingDataUShortAsync()
});
}
case MqttControlPacketType.PubRel:
{
return(new MqttPubRelPacket
{
PacketIdentifier = await mqttPacketReader.ReadRemainingDataUShortAsync()
});
}
case MqttControlPacketType.PubComp:
{
return(new MqttPubCompPacket
{
PacketIdentifier = await mqttPacketReader.ReadRemainingDataUShortAsync()
});
}
case MqttControlPacketType.PingReq:
{
return(new MqttPingReqPacket());
}
case MqttControlPacketType.PingResp:
{
return(new MqttPingRespPacket());
}
case MqttControlPacketType.Subscribe:
{
return(await DeserializeSubscribeAsync(mqttPacketReader));
}
case MqttControlPacketType.SubAck:
{
return(await DeserializeSubAck(mqttPacketReader));
}
case MqttControlPacketType.Unsubscibe:
{
return(await DeserializeUnsubscribeAsync(mqttPacketReader));
}
case MqttControlPacketType.UnsubAck:
{
return(new MqttUnsubAckPacket
{
PacketIdentifier = await mqttPacketReader.ReadRemainingDataUShortAsync()
});
}
default:
{
throw new MqttProtocolViolationException($"Packet type ({(int)mqttPacketReader.ControlPacketType}) not supported.");
}
}
}
}
private static MqttBasePacket Deserialize(MqttPacketHeader header, MqttPacketReader reader)
{
switch (header.ControlPacketType)
{
case MqttControlPacketType.Connect:
{
return(DeserializeConnect(reader));
}
case MqttControlPacketType.ConnAck:
{
return(DeserializeConnAck(reader));
}
case MqttControlPacketType.Disconnect:
{
return(new MqttDisconnectPacket());
}
case MqttControlPacketType.Publish:
{
return(DeserializePublish(reader, header));
}
case MqttControlPacketType.PubAck:
{
return(new MqttPubAckPacket
{
PacketIdentifier = reader.ReadUInt16()
});
}
case MqttControlPacketType.PubRec:
{
return(new MqttPubRecPacket
{
PacketIdentifier = reader.ReadUInt16()
});
}
case MqttControlPacketType.PubRel:
{
return(new MqttPubRelPacket
{
PacketIdentifier = reader.ReadUInt16()
});
}
case MqttControlPacketType.PubComp:
{
return(new MqttPubCompPacket
{
PacketIdentifier = reader.ReadUInt16()
});
}
case MqttControlPacketType.PingReq:
{
return(new MqttPingReqPacket());
}
case MqttControlPacketType.PingResp:
{
return(new MqttPingRespPacket());
}
case MqttControlPacketType.Subscribe:
{
return(DeserializeSubscribe(reader));
}
case MqttControlPacketType.SubAck:
{
return(DeserializeSubAck(reader));
}
case MqttControlPacketType.Unsubscibe:
{
return(DeserializeUnsubscribe(reader));
}
case MqttControlPacketType.UnsubAck:
{
return(new MqttUnsubAckPacket
{
PacketIdentifier = reader.ReadUInt16()
});
}
default:
{
throw new MqttProtocolViolationException($"Packet type ({(int)header.ControlPacketType}) not supported.");
}
}
}
