示例#1
0
        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);
        }
示例#2
0
 private static MqttBasePacket DeserializePubAck(MqttPacketReader reader)
 {
     return(new MqttPubAckPacket
     {
         PacketIdentifier = reader.ReadUInt16()
     });
 }
示例#3
0
        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.");
            }
        }
示例#4
0
        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);
        }
示例#5
0
        private static MqttBasePacket DeserializeSubAck(MqttPacketReader reader)
        {
            var packet = new MqttSubAckPacket
            {
                PacketIdentifier = reader.ReadUInt16()
            };

            while (!reader.EndOfRemainingData)
            {
                packet.SubscribeReturnCodes.Add((MqttSubscribeReturnCode)reader.ReadByte());
            }

            return(packet);
        }
示例#6
0
        private static MqttBasePacket DeserializeUnsubscribe(MqttPacketReader reader)
        {
            var packet = new MqttUnsubscribePacket
            {
                PacketIdentifier = reader.ReadUInt16(),
            };

            while (!reader.EndOfRemainingData)
            {
                packet.TopicFilters.Add(reader.ReadStringWithLengthPrefix());
            }

            return(packet);
        }
示例#7
0
        private MqttBasePacket DeserializeConnAck(MqttPacketReader reader)
        {
            var packet = new MqttConnAckPacket();

            var firstByteReader = new ByteReader(reader.ReadByte());

            if (ProtocolVersion == MqttProtocolVersion.V311)
            {
                packet.IsSessionPresent = firstByteReader.Read();
            }

            packet.ConnectReturnCode = (MqttConnectReturnCode)reader.ReadByte();

            return(packet);
        }
示例#8
0
        public MqttBasePacket Deserialize(MqttPacketHeader header, MemoryStream body)
        {
            if (header == null)
            {
                throw new ArgumentNullException(nameof(header));
            }
            if (body == null)
            {
                throw new ArgumentNullException(nameof(body));
            }

            using (var reader = new MqttPacketReader(header, body))
            {
                return(Deserialize(header, reader));
            }
        }
示例#9
0
        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);
        }
示例#10
0
        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);
        }