mqtt_5 0.1.1

A library for reading and writing MQTT 5.0 packets
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

use super::data_representation::{
    properties::Properties, 
    qos::QoS,
    reserved_flags::ReservedFlags, 
    UTF8EncodedString, 
    RemainingLength,
    BinaryData
};

use super::error::MQTTParserError;
use packattack::*;
 
#[derive(Clone, Debug, PartialEq, FromBitReader)]
pub struct Connect
(
    ReservedFlags, 
    RemainingLength, 
    Protocol, 
    ProtocolLevel,
    #[expose = "c_flags"]
    ConnectFlags, 
    KeepAlive,
    Properties,
    ClientID,
    #[flag = "c_flags.WillFlag"]
    Option<WillProperties>,
    #[flag = "c_flags.WillFlag"]
    Option<WillTopic>,
    #[flag = "c_flags.WillFlag"]
    Option<WillPayload>,
    #[flag = "c_flags.UserNameFlag"]
    Option<Username>,
    #[flag = "c_flags.PasswordFlag"]
    Option<Password>
);

#[derive(Clone, Debug, PartialEq)]
pub enum Protocol
{
    MQTT,
    MQIsdp //Older name for MQTT
}

#[async_trait]
impl<R> FromBitReader<MQTTParserError, R> for Protocol where Self : Sized, R : Read + std::marker::Unpin + std::marker::Send
{
    async fn from_bitreader(reader : &mut bitreader_async::BitReader<R>) -> Result<Protocol, MQTTParserError>
    {
        let protocol = UTF8EncodedString::from_bitreader(reader).await?;

        match protocol.as_str()
        {
            "MQTT" => Ok(Protocol::MQTT),
            "MQIsdp" => Ok(Protocol::MQIsdp),
            _ => panic!("Couldn't parse control packet because the client tried to use a protocol other than MQTT!")
        }
    }
}

pub type ProtocolLevel = u8;
pub type KeepAlive = u16;

#[allow(non_snake_case)]
#[derive(Clone, Copy, Debug, PartialEq, FromBitReader)]
pub struct ConnectFlags
{
    pub UserNameFlag : bool,
    pub PasswordFlag : bool,
    pub WillRetain : bool,
    pub WillQoS : QoS,
    pub WillFlag : bool,
    pub CleanStart: bool,
    Reserve : bool
}

pub type ClientID = UTF8EncodedString;
pub type WillProperties = Properties;
pub type WillTopic = UTF8EncodedString;
pub type WillPayload = BinaryData;
pub type Username = UTF8EncodedString;
pub type Password = UTF8EncodedString;

/*
#[cfg(test)]
mod test
{
    use bitreader_async::BitReader;
    use crate::Packet;
    use crate::data_representation::FromBitReader;
    use async_std::io::BufReader;
    use async_std::task;

    #[test]
    fn read_connect()
    {

        task::block_on(async {
            let bytes = [
            0b00010000,//Packet type and ReservedFlags
            0b00010000,
            0b00000000,0b00000100, //Protocol Length
            0b01001101,//M
            0b01010001,//Q
            0b01010100,//T
            0b01010100,//T
            0b00000101,//Protocol Version 5
            0b11001110,//Connect Flags
            0b00000000,0b00001010,//Keep Alive
            0b00000101,//Properties Length
            0b00010001,//Session Expiry Interval identifier
            0b00000000, //Session Expiry Interval
            0b00000000,
            0b00000000,
            0b00001010];

            let underlying_reader : BufReader<&[u8]> = BufReader::new(&bytes);

            let mut reader = BitReader::<BufReader<&[u8]>>::new(underlying_reader);

            let packet = Packet::from_bitreader(&mut reader).await.unwrap();

            print!("Packect : {:#?}", packet);
        });

    }
}*/