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
mod asyncdeserialize;
mod asyncserialize;
mod deserialize;
mod packets;
mod serialize;
mod topic;
pub mod codec;
pub use asyncdeserialize::AsyncMqttRead;
pub use asyncserialize::AsyncMqttWrite;
pub use deserialize::MqttRead;
pub use packets::*;
pub use serialize::MqttWrite;
pub use topic::*;
use crate::Error;
#[repr(u8)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd)]
pub enum QoS {
AtMostOnce = 0,
AtLeastOnce = 1,
ExactlyOnce = 2,
}
#[repr(u8)]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum PacketType {
Connect = 1,
Connack,
Publish,
Puback,
Pubrec,
Pubrel,
Pubcomp,
Subscribe,
Suback,
Unsubscribe,
Unsuback,
Pingreq,
Pingresp,
Disconnect,
}
#[derive(Debug, Clone, PartialEq)]
pub enum Packet {
Connect(Connect),
Connack(Connack),
Publish(Publish),
Puback(PacketIdentifier),
Pubrec(PacketIdentifier),
Pubrel(PacketIdentifier),
Pubcomp(PacketIdentifier),
Subscribe(Subscribe),
Suback(Suback),
Unsubscribe(Unsubscribe),
Unsuback(PacketIdentifier),
Pingreq,
Pingresp,
Disconnect,
}
pub fn qos(num: u8) -> Result<QoS, Error> {
match num {
0 => Ok(QoS::AtMostOnce),
1 => Ok(QoS::AtLeastOnce),
2 => Ok(QoS::ExactlyOnce),
_ => Err(Error::UnsupportedQoS),
}
}
pub fn packet_type(num: u8) -> Result<PacketType, Error> {
match num {
1 => Ok(PacketType::Connect),
2 => Ok(PacketType::Connack),
3 => Ok(PacketType::Publish),
4 => Ok(PacketType::Puback),
5 => Ok(PacketType::Pubrec),
6 => Ok(PacketType::Pubrel),
7 => Ok(PacketType::Pubcomp),
8 => Ok(PacketType::Subscribe),
9 => Ok(PacketType::Suback),
10 => Ok(PacketType::Unsubscribe),
11 => Ok(PacketType::Unsuback),
12 => Ok(PacketType::Pingreq),
13 => Ok(PacketType::Pingresp),
14 => Ok(PacketType::Disconnect),
_ => Err(Error::UnsupportedPacketType(num)),
}
}
pub fn connect_return(num: u8) -> Result<ConnectReturnCode, Error> {
match num {
0 => Ok(ConnectReturnCode::Accepted),
1 => Ok(ConnectReturnCode::BadUsernamePassword),
2 => Ok(ConnectReturnCode::NotAuthorized),
3 => Ok(ConnectReturnCode::RefusedIdentifierRejected),
4 => Ok(ConnectReturnCode::RefusedProtocolVersion),
5 => Ok(ConnectReturnCode::ServerUnavailable),
_ => Err(Error::InvalidConnectReturnCode(num)),
}
}