void DeserializeAndCompare(MqttPacket packet, string expectedBase64Value, MqttProtocolVersion protocolVersion = MqttProtocolVersion.V311)
{
var writer = WriterFactory();
var serializer = MqttPacketFormatterAdapter.GetMqttPacketFormatter(protocolVersion, writer);
var buffer1 = serializer.Encode(packet);
using (var headerStream = new MemoryStream(buffer1.Join().ToArray()))
{
using (var channel = new TestMqttChannel(headerStream))
{
using (var adapter = new MqttChannelAdapter(
channel,
new MqttPacketFormatterAdapter(protocolVersion, new MqttBufferWriter(4096, 65535)),
null,
new MqttNetEventLogger()))
{
var receivedPacket = adapter.ReceivePacketAsync(CancellationToken.None).GetAwaiter().GetResult();
var buffer2 = serializer.Encode(receivedPacket);
Assert.AreEqual(expectedBase64Value, Convert.ToBase64String(buffer2.Join().ToArray()));
}
}
}
}
public static byte[] EncodePacket(MqttPacket packet)
{
using (var helper = new MqttPacketSerializationHelper())
{
return helper.Encode(packet).ToArray();
}
}
static void ThrowIfPacketIdentifierIsInvalid(ushort packetIdentifier, MqttPacket packet)
{
// SUBSCRIBE, UNSUBSCRIBE, and PUBLISH(in cases where QoS > 0) Control Packets MUST contain a non-zero 16 - bit Packet Identifier[MQTT - 2.3.1 - 1].
if (packetIdentifier == 0)
{
throw new MqttProtocolViolationException($"Packet identifier is not set for {packet.GetType().Name}.");
}
}
public void Complete(MqttPacket packet)
{
if (packet == null)
{
throw new ArgumentNullException(nameof(packet));
}
_promise.TrySetResult(packet);
}
public void GlobalSetup()
{
_packet = new MqttPublishPacket
{
Topic = "A"
};
_bufferWriter = new MqttBufferWriter(4096, 65535);
_serializer = new MqttV3PacketFormatter(_bufferWriter, MqttProtocolVersion.V311);
_serializedPacket = _serializer.Encode(_packet).Join();
}
byte EncodePacket(MqttPacket packet)
{
switch (packet)
{
case MqttConnectPacket connectPacket:
return(EncodeConnectPacket(connectPacket));
case MqttConnAckPacket connAckPacket:
return(EncodeConnAckPacket(connAckPacket));
case MqttDisconnectPacket disconnectPacket:
return(EncodeDisconnectPacket(disconnectPacket));
case MqttPingReqPacket _:
return(EncodePingReqPacket());
case MqttPingRespPacket _:
return(EncodePingRespPacket());
case MqttPublishPacket publishPacket:
return(EncodePublishPacket(publishPacket));
case MqttPubAckPacket pubAckPacket:
return(EncodePubAckPacket(pubAckPacket));
case MqttPubRecPacket pubRecPacket:
return(EncodePubRecPacket(pubRecPacket));
case MqttPubRelPacket pubRelPacket:
return(EncodePubRelPacket(pubRelPacket));
case MqttPubCompPacket pubCompPacket:
return(EncodePubCompPacket(pubCompPacket));
case MqttSubscribePacket subscribePacket:
return(EncodeSubscribePacket(subscribePacket));
case MqttSubAckPacket subAckPacket:
return(EncodeSubAckPacket(subAckPacket));
case MqttUnsubscribePacket unsubscribePacket:
return(EncodeUnsubscribePacket(unsubscribePacket));
case MqttUnsubAckPacket unsubAckPacket:
return(EncodeUnsubAckPacket(unsubAckPacket));
case MqttAuthPacket authPacket:
return(EncodeAuthPacket(authPacket));
default:
throw new MqttProtocolViolationException("Packet type invalid.");
}
}
public async Task SendPacketAsync(MqttPacket packet, CancellationToken cancellationToken)
{
packet = await InterceptPacketAsync(packet, cancellationToken).ConfigureAwait(false);
if (packet == null)
{
// The interceptor has decided that this packet will not used at all.
// This might break the protocol but the user wants that.
return;
}
await ChannelAdapter.SendPacketAsync(packet, cancellationToken).ConfigureAwait(false);
Statistics.HandleSentPacket(packet);
}
public void HandleSentPacket(MqttPacket packet)
{
if (packet == null)
{
throw new ArgumentNullException(nameof(packet));
}
// This class is tracking all values from Clients perspective!
LastPacketReceivedTimestamp = DateTime.UtcNow;
Interlocked.Increment(ref _receivedPacketsCount);
if (packet is MqttPublishPacket)
{
Interlocked.Increment(ref _receivedApplicationMessagesCount);
}
}
public bool TryDispatch(MqttPacket packet)
{
if (packet == null)
{
throw new ArgumentNullException(nameof(packet));
}
ushort identifier = 0;
if (packet is MqttPacketWithIdentifier packetWithIdentifier)
{
identifier = packetWithIdentifier.PacketIdentifier;
}
var packetType = packet.GetType();
var awaitables = new List <IMqttPacketAwaitable>();
lock (_awaitables)
{
for (var i = _awaitables.Count - 1; i >= 0; i--)
{
var entry = _awaitables[i];
// Note: The PingRespPacket will also arrive here and has NO identifier but there
// is code which waits for it. So the code must be able to deal with filters which
// are referring to the type only (identifier is 0)!
if (entry.Filter.Type != packetType || entry.Filter.Identifier != identifier)
{
continue;
}
awaitables.Add(entry);
_awaitables.RemoveAt(i);
}
}
foreach (var matchingEntry in awaitables)
{
matchingEntry.Complete(packet);
}
return(awaitables.Count > 0);
}
public MqttPacketBuffer Encode(MqttPacket packet)
{
if (packet == null)
{
throw new ArgumentNullException(nameof(packet));
}
// Leave enough head space for max header size (fixed + 4 variable remaining length = 5 bytes)
_bufferWriter.Reset(5);
_bufferWriter.Seek(5);
var fixedHeader = EncodePacket(packet, _bufferWriter);
var remainingLength = (uint)(_bufferWriter.Length - 5);
var publishPacket = packet as MqttPublishPacket;
if (publishPacket?.Payload != null)
{
remainingLength += (uint)publishPacket.Payload.Length;
}
var remainingLengthSize = MqttBufferWriter.GetLengthOfVariableInteger(remainingLength);
var headerSize = FixedHeaderSize + remainingLengthSize;
var headerOffset = 5 - headerSize;
// Position cursor on correct offset on beginning of array (has leading 0x0)
_bufferWriter.Seek(headerOffset);
_bufferWriter.WriteByte(fixedHeader);
_bufferWriter.WriteVariableByteInteger(remainingLength);
var buffer = _bufferWriter.GetBuffer();
var firstSegment = new ArraySegment <byte>(buffer, headerOffset, _bufferWriter.Length - headerOffset);
if (publishPacket?.Payload != null)
{
var payloadSegment = new ArraySegment <byte>(publishPacket.Payload, 0, publishPacket.Payload.Length);
return(new MqttPacketBuffer(firstSegment, payloadSegment));
}
return(new MqttPacketBuffer(firstSegment));
}
public async Task SendPacketAsync(MqttPacket packet, CancellationToken cancellationToken)
{
ThrowIfDisposed();
// This lock makes sure that multiple threads can send packets at the same time.
// This is required when a disconnect is sent from another thread while the
// worker thread is still sending publish packets etc.
using (await _syncRoot.WaitAsync(cancellationToken).ConfigureAwait(false))
{
// Check for cancellation here again because "WaitAsync" might take some time.
cancellationToken.ThrowIfCancellationRequested();
try
{
var packetBuffer = PacketFormatterAdapter.Encode(packet);
_packetInspector?.BeginSendPacket(packetBuffer);
_logger.Verbose("TX ({0} bytes) >>> {1}", packetBuffer.Length, packet);
await _channel.WriteAsync(packetBuffer.Packet.Array, packetBuffer.Packet.Offset, packetBuffer.Packet.Count, cancellationToken).ConfigureAwait(false);
if (packetBuffer.Payload.Count > 0)
{
await _channel.WriteAsync(packetBuffer.Payload.Array, packetBuffer.Payload.Offset, packetBuffer.Payload.Count, cancellationToken).ConfigureAwait(false);
}
Interlocked.Add(ref _bytesReceived, packetBuffer.Length);
}
catch (Exception exception)
{
if (!WrapAndThrowException(exception))
{
throw;
}
}
finally
{
PacketFormatterAdapter.Cleanup();
}
}
}
//should this work under subscribe changed .....
private static void Client_PublishReceivedChanged(object sender, MqttPacket packet)
{
string rez = UTF8Encoding.UTF8.GetString(packet.Data);
// Debug.WriteLine("Sender : " + sender.ToString());
// Debug.WriteLine("Message : " + packet.ToString());
switch (rez)
{
case "0": Debug.WriteLine("Light / Off");
break;
case "1": Debug.WriteLine("Light / On");
break;
case "10": Debug.WriteLine("Switch / Off");
break;
case "11": Debug.WriteLine("Switch / On");
break;
}
}
async Task <MqttPacket> InterceptPacketAsync(MqttPacket packet, CancellationToken cancellationToken)
{
if (!_eventContainer.InterceptingOutboundPacketEvent.HasHandlers)
{
return(packet);
}
var interceptingPacketEventArgs = new InterceptingPacketEventArgs
{
ClientId = Id,
Endpoint = Endpoint,
Packet = packet,
CancellationToken = cancellationToken
};
await _eventContainer.InterceptingOutboundPacketEvent.InvokeAsync(interceptingPacketEventArgs).ConfigureAwait(false);
if (!interceptingPacketEventArgs.ProcessPacket || packet == null)
{
return(null);
}
return(interceptingPacketEventArgs.Packet);
}
public MqttPacketBuffer Encode(MqttPacket mqttPacket)
{
return(_encoder.Encode(mqttPacket));
}
byte EncodePacket(MqttPacket packet, MqttBufferWriter bufferWriter)
{
switch (packet)
{
case MqttConnectPacket connectPacket:
if (_mqttProtocolVersion == MqttProtocolVersion.V311)
{
return(EncodeConnectPacketV311(connectPacket, bufferWriter));
}
else
{
return(EncodeConnectPacket(connectPacket, bufferWriter));
}
case MqttConnAckPacket connAckPacket:
if (_mqttProtocolVersion == MqttProtocolVersion.V311)
{
return(EncodeConnAckPacketV311(connAckPacket, bufferWriter));
}
else
{
return(EncodeConnAckPacket(connAckPacket, bufferWriter));
}
case MqttDisconnectPacket _:
return(EncodeEmptyPacket(MqttControlPacketType.Disconnect));
case MqttPingReqPacket _:
return(EncodeEmptyPacket(MqttControlPacketType.PingReq));
case MqttPingRespPacket _:
return(EncodeEmptyPacket(MqttControlPacketType.PingResp));
case MqttPublishPacket publishPacket:
return(EncodePublishPacket(publishPacket, bufferWriter));
case MqttPubAckPacket pubAckPacket:
return(EncodePubAckPacket(pubAckPacket, bufferWriter));
case MqttPubRecPacket pubRecPacket:
return(EncodePubRecPacket(pubRecPacket, bufferWriter));
case MqttPubRelPacket pubRelPacket:
return(EncodePubRelPacket(pubRelPacket, bufferWriter));
case MqttPubCompPacket pubCompPacket:
return(EncodePubCompPacket(pubCompPacket, bufferWriter));
case MqttSubscribePacket subscribePacket:
return(EncodeSubscribePacket(subscribePacket, bufferWriter));
case MqttSubAckPacket subAckPacket:
return(EncodeSubAckPacket(subAckPacket, bufferWriter));
case MqttUnsubscribePacket unsubscribePacket:
return(EncodeUnsubscribePacket(unsubscribePacket, bufferWriter));
case MqttUnsubAckPacket unsubAckPacket:
return(EncodeUnsubAckPacket(unsubAckPacket, bufferWriter));
default:
throw new MqttProtocolViolationException("Packet type invalid.");
}
}
public MqttPacketBusItem(MqttPacket packet)
{
Packet = packet ?? throw new ArgumentNullException(nameof(packet));
}
public MqttPacketBuffer Encode(MqttPacket packet)
{
ThrowIfFormatterNotSet();
return(_formatter.Encode(packet));
}
public void AssertIsConnAckPacket(MqttPacket packet)
{
Assert.AreEqual(packet.GetType(), typeof(MqttConnAckPacket));
}
void SerializeAndCompare(MqttPacket packet, string expectedBase64Value, MqttProtocolVersion protocolVersion = MqttProtocolVersion.V311)
{
Assert.AreEqual(expectedBase64Value, Convert.ToBase64String(Serialize(packet, protocolVersion)));
}
byte[] Serialize(MqttPacket packet, MqttProtocolVersion protocolVersion)
{
return(MqttPacketFormatterAdapter.GetMqttPacketFormatter(protocolVersion, WriterFactory()).Encode(packet).Join().ToArray());
}
private static void Client_SubscribedChanged(object sender, MqttPacket packet)
{
Debug.WriteLine("subscribe " + DateTime.UtcNow.ToString("yyyy.MM.dd HH:mm:ss.fff"));
}
public void ParseMqttMessage(string filename)
{
var path = PacketProvider.GetFullPath(filename);
var bytes = File.ReadAllBytes(path);
var tlsPacket = new MqttPacket(new KaitaiStream(bytes));
}
public MqttPacketBuffer Encode(MqttPacket packet)
{
return _packetFormatter.Encode(packet);
}
