private bool TryDecodePacket(IChannelHandlerContext context, IByteBuffer buffer, out Packet packet)
{
if (!buffer.IsReadable(2))
{
packet = default;
return(false);
}
FixedHeader fixedHeader = default;
fixedHeader.Decode(buffer);
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);
return(true);
}
internal PingResponse(FixedHeader header, byte[] payload)
: base(header.MessageType)
{
// NOTE: PingResponse has no variable header and no payload
VariableHeader = null;
}
public void DeserializationTest_1()
{
var bytes = new byte[] { 0x20, 0x02 };
var header = FixedHeader.Deserialize(bytes);
Assert.AreEqual(MessageType.ConnectAck, header.MessageType);
Assert.AreEqual(2, header.RemainingLength);
}
public PingReq(FixedHeader header)
: base(header)
{
if (header.RemainingLength != 0)
{
throw new ProtocolException(CommandMessage, "PingReq does not have any payload data");
}
}
MqttCommand ICommandReader.Read(NetworkConnection connection)
{
var header = FixedHeader.Load(connection);
byte[] data = connection.ReadBytesOrFailAsync(header.RemainingLength).Await().Result;
return(MqttCommand.Create(header, data));
}
public void AuthenticationFailedTest()
{
VariableHeader vh = new ConnAckVariableHeader(true, ConnectReturnCode.AuthenticationFailed);
FixedHeader fh = FixedHeader.CreateStandardHeader(ControlPacketType.CONNACK, (UInt16)(vh.Encode().Count() + pn.Encode().Count()));
Assert.IsTrue(CheckExpectedByteEncoding(fh, AuthenticationFailed.FixedHeader));
Assert.IsTrue(CheckExpectedByteEncoding(vh, AuthenticationFailed.VariableHeader));
Assert.IsTrue(CheckExpectedByteEncoding(pn, AuthenticationFailed.Payload));
}
public void ServerUnavailableTest()
{
VariableHeader vh = new ConnAckVariableHeader(false, ConnectReturnCode.ServerUnavailable);
FixedHeader fh = FixedHeader.CreateStandardHeader(ControlPacketType.CONNACK, (UInt16)(vh.Encode().Count() + pn.Encode().Count()));
Assert.IsTrue(CheckExpectedByteEncoding(fh, ServerUnavailable.FixedHeader));
Assert.IsTrue(CheckExpectedByteEncoding(vh, ServerUnavailable.VariableHeader));
Assert.IsTrue(CheckExpectedByteEncoding(pn, ServerUnavailable.Payload));
}
public void Connection_accepted_response_encoded_correctly()
{
VariableHeader vh = new ConnAckVariableHeader(true, ConnectReturnCode.Accepted);
FixedHeader fh = FixedHeader.CreateStandardHeader(ControlPacketType.CONNACK, (UInt16)(vh.Encode().Count() + pn.Encode().Count()));
Assert.IsTrue(CheckExpectedByteEncoding(fh, Accepted.FixedHeader));
Assert.IsTrue(CheckExpectedByteEncoding(vh, Accepted.VariableHeader));
Assert.IsTrue(CheckExpectedByteEncoding(pn, Accepted.Payload));
}
public void Packet_encodes_correct_fixed_header_bytes()
{
FixedHeader fh = FixedHeader.CreateStandardHeader(ControlPacketType.CONNECT, (UInt16)(cp.VariableHeader.Encode().Count() + cp.Payload.Encode().Count()));
byte[] expectedBytes = fh.Encode().ToArray();
for (int i = 0; i < expectedBytes.Count(); i++)
{
Assert.AreEqual(expectedBytes[i], cp.FixedHeader.Encode().ToArray()[i]);
}
}
public static MqttCommand Create(FixedHeader header, byte[] data)
{
switch (header.Message)
{
case CommandMessage.CONNACK:
return(new ConnAck(header, data));
case CommandMessage.CONNECT:
return(new Connect(header, data));
case CommandMessage.DISCONNECT:
return(new Disconnect(header));
case CommandMessage.PINGREQ:
return(new PingReq(header));
case CommandMessage.PINGRESP:
return(new PingResp(header));
case CommandMessage.PUBACK:
return(new PubAck(header, data));
case CommandMessage.PUBCOMP:
return(new PubComp(header, data));
case CommandMessage.PUBLISH:
return(new Publish(header, data));
case CommandMessage.PUBREC:
return(new PubRec(header, data));
case CommandMessage.PUBREL:
return(new PubRel(header, data));
case CommandMessage.SUBACK:
return(new SubAck(header, data));
case CommandMessage.SUBSCRIBE:
return(new Subscribe(header, data));
case CommandMessage.UNSUBACK:
return(new UnSubAck(header, data));
case CommandMessage.UNSUBSCRIBE:
return(new Unsubscribe(header, data));
default:
throw new InvalidOperationException("Unknown command message");
}
}
public Connect(FixedHeader header, byte[] data)
: base(header)
{
if (data != null)
{
using (var stream = new MemoryStream(data))
{
Details = V3ConnectVariableHeader.FromStream(stream);
LoadPayload(stream);
}
}
else
{
Details = new V3ConnectVariableHeader(180, new ConnectFlags());
}
}
MqttCommand ICommandReader.Read(NetworkConnection connection)
{
byte[] data = null;
FixedHeader header = FixedHeader.Load(connection);
if (header.RemainingLength > 0)
{
data = connection.Stream.ReadBytesOrFailAsync(header.RemainingLength).Await().Result;
}
MqttCommand cmd = MqttCommand.Create(header, data);
System.Diagnostics.Debug.WriteLine("RECV {0}", cmd);
return(cmd);
}
public ConnAck(FixedHeader header, byte[] data)
: base(header)
{
if (data != null)
{
if (header.RemainingLength != data.Length)
{
throw new ProtocolException(CommandMessage, "The declared and actual data lengths did not match");
}
if (header.RemainingLength != 2)
{
throw new ProtocolException(CommandMessage, "The declared data length must be 2");
}
Result = (ConnectionAckResult)data[1];
}
}
public Unsubscribe(FixedHeader header, byte[] data)
: base(header)
{
if (header.RemainingLength > 0)
{
using (var stream = new MemoryStream(data))
{
if (Header.QualityOfService != QualityOfService.AtMostOnce)
{
MessageId = MessageId.FromStream(stream);
while (stream.Position < stream.Length)
{
_topics.Add(MqString.FromStream(stream));
}
}
}
}
}
public Publish(FixedHeader header, byte[] data)
: base(header)
{
if (header.RemainingLength > 0)
{
using (var stream = new MemoryStream(data))
{
Topic = MQString.FromStream(stream);
if (Header.QualityOfService == QualityOfService.AtLeastOnce ||
Header.QualityOfService == QualityOfService.ExactlyOnce)
{
MessageId = MessageId.FromStream(stream);
}
Message = stream.Position < stream.Length ? stream.ReadRest() : new byte[0];
}
}
}
Packet DecodePacketInternal(IByteBuffer buffer, byte packetSignature, ref int remainingLength)
{
Packet packet;
var fixedHeader = new FixedHeader(packetSignature, remainingLength);
switch (fixedHeader.PacketType)
{
case PacketType.CONNECT: packet = new ConnectPacket(); break;
case PacketType.CONNACK: packet = new ConnAckPacket(); break;
case PacketType.DISCONNECT: packet = new DisconnectPacket(); break;
case PacketType.PINGREQ: packet = new PingReqPacket(); break;
case PacketType.PINGRESP: packet = new PingRespPacket(); break;
case PacketType.PUBACK: packet = new PubAckPacket(); break;
case PacketType.PUBCOMP: packet = new PubCompPacket(); break;
case PacketType.PUBLISH: packet = new PublishPacket(); break;
case PacketType.PUBREC: packet = new PubRecPacket(); break;
case PacketType.PUBREL: packet = new PubRelPacket(); break;
case PacketType.SUBSCRIBE: packet = new SubscribePacket(); break;
case PacketType.SUBACK: packet = new SubAckPacket(); break;
case PacketType.UNSUBSCRIBE: packet = new UnsubscribePacket(); break;
case PacketType.UNSUBACK: packet = new UnsubscribePacket(); break;
default:
throw new DecoderException("Unsupported Message Type");
}
packet.FixedHeader = fixedHeader;
packet.Decode(buffer);
remainingLength = packet.RemaingLength;
return(packet);
}
public SubAck(FixedHeader header, byte[] data)
: base(header)
{
if (data == null)
{
throw new ArgumentNullException("data");
}
using (var stream = new MemoryStream(data))
{
_grants = new List <QualityOfService>();
MessageId = MessageId.FromStream(stream);
while (stream.Position < stream.Length)
{
byte qosByte = stream.ReadBytesOrFailAsync(1).Await().Result[0];
qosByte = (byte)(qosByte & 0x03); // 00000011
_grants.Add((QualityOfService)qosByte);
}
}
}
protected MqttCommand(FixedHeader header)
{
MessageId = MessageId.Any;
Header = header;
}
internal ConnectAck(FixedHeader header, byte[] payload)
: base(header)
{
m_payload = payload;
}
public string GetScriptToInitialFixedHeader()
{
return($"CreateFixedHeader($get('{Journal.ClientID}'), {FixedHeader.ToString().ToLower()}, {FixedRowsCount}, {FixedColumnsCount});");
}
