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); }