示例#1
0
        private static MqttBasePacket DeserializePublish(MqttReceivedPacket receivedMqttPacket)
        {
            ThrowIfBodyIsEmpty(receivedMqttPacket.Body);

            var retain = (receivedMqttPacket.FixedHeader & 0x1) > 0;
            var qualityOfServiceLevel = (MqttQualityOfServiceLevel)(receivedMqttPacket.FixedHeader >> 1 & 0x3);
            var dup = (receivedMqttPacket.FixedHeader & 0x8) > 0;

            var topic = receivedMqttPacket.Body.ReadStringWithLengthPrefix();

            ushort?packetIdentifier = null;

            if (qualityOfServiceLevel > MqttQualityOfServiceLevel.AtMostOnce)
            {
                packetIdentifier = receivedMqttPacket.Body.ReadUInt16();
            }

            var packet = new MqttPublishPacket
            {
                PacketIdentifier      = packetIdentifier,
                Retain                = retain,
                Topic                 = topic,
                Payload               = receivedMqttPacket.Body.ReadRemainingData().ToArray(),
                QualityOfServiceLevel = qualityOfServiceLevel,
                Dup = dup
            };

            return(packet);
        }
示例#2
0
        public MqttBasePacket Deserialize(MqttReceivedPacket receivedMqttPacket)
        {
            if (receivedMqttPacket == null)
            {
                throw new ArgumentNullException(nameof(receivedMqttPacket));
            }

            var controlPacketType = receivedMqttPacket.FixedHeader >> 4;

            if (controlPacketType < 1 || controlPacketType > 14)
            {
                throw new MqttProtocolViolationException($"The packet type is invalid ({controlPacketType}).");
            }

            switch ((MqttControlPacketType)controlPacketType)
            {
            case MqttControlPacketType.Connect: return(DeserializeConnect(receivedMqttPacket.Body));

            case MqttControlPacketType.ConnAck: return(DeserializeConnAck(receivedMqttPacket.Body));

            case MqttControlPacketType.Disconnect: return(new MqttDisconnectPacket());

            case MqttControlPacketType.Publish: return(DeserializePublish(receivedMqttPacket));

            case MqttControlPacketType.PubAck: return(DeserializePubAck(receivedMqttPacket.Body));

            case MqttControlPacketType.PubRec: return(DeserializePubRec(receivedMqttPacket.Body));

            case MqttControlPacketType.PubRel: return(DeserializePubRel(receivedMqttPacket.Body));

            case MqttControlPacketType.PubComp: return(DeserializePubComp(receivedMqttPacket.Body));

            case MqttControlPacketType.PingReq: return(new MqttPingReqPacket());

            case MqttControlPacketType.PingResp: return(new MqttPingRespPacket());

            case MqttControlPacketType.Subscribe: return(DeserializeSubscribe(receivedMqttPacket.Body));

            case MqttControlPacketType.SubAck: return(DeserializeSubAck(receivedMqttPacket.Body));

            case MqttControlPacketType.Unsubscibe: return(DeserializeUnsubscribe(receivedMqttPacket.Body));

            case MqttControlPacketType.UnsubAck: return(DeserializeUnsubAck(receivedMqttPacket.Body));

            default: throw new MqttProtocolViolationException($"Packet type ({controlPacketType}) not supported.");
            }
        }