use bytes::{Buf, Bytes, BytesMut};
use super::property::{self, PROP_ID_LEN, PropertyId, properties_encoded_len, write_properties_len};
use super::reason_code::ReasonCode;
use crate::{DecodeError, EncodeError, PacketType, QoS, primitives, varint};
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[repr(u8)]
pub enum RetainHandling {
SendAtSubscribe = 0,
SendAtSubscribeIfNew = 1,
DoNotSend = 2,
}
impl TryFrom<u8> for RetainHandling {
type Error = DecodeError;
fn try_from(value: u8) -> Result<Self, Self::Error> {
match value {
0 => Ok(Self::SendAtSubscribe),
1 => Ok(Self::SendAtSubscribeIfNew),
2 => Ok(Self::DoNotSend),
_ => Err(DecodeError::ProtocolError {
reason: "invalid retain handling",
}),
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct SubscribeFilter {
pub topic: String,
pub qos: QoS,
pub no_local: bool,
pub retain_as_published: bool,
pub retain_handling: RetainHandling,
}
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct SubscribeProperties {
pub subscription_identifier: Option<u32>,
pub user_properties: Vec<(String, String)>,
}
impl SubscribeProperties {
fn encoded_len(&self) -> usize {
let mut len = 0;
if let Some(v) = self.subscription_identifier {
len += PROP_ID_LEN + varint::len(v);
}
for (k, v) in &self.user_properties {
len += PROP_ID_LEN + primitives::string_pair_encoded_len(k.len(), v.len());
}
len
}
fn encode(&self, buf: &mut BytesMut) -> Result<(), EncodeError> {
write_properties_len(self.encoded_len(), buf);
if let Some(v) = self.subscription_identifier {
primitives::write_u8(PropertyId::SubscriptionIdentifier as u8, buf);
let mut tmp = [0u8; 4];
let n = varint::encode_to(v, &mut tmp);
buf.extend_from_slice(&tmp[..n]);
}
for (k, v) in &self.user_properties {
primitives::write_u8(PropertyId::UserProperty as u8, buf);
primitives::write_string_pair(k, v, buf)?;
}
Ok(())
}
fn decode(mut buf: Bytes) -> Result<Self, DecodeError> {
let mut props = Self::default();
while buf.has_remaining() {
let id_byte = primitives::read_u8(&mut buf)?;
let id = PropertyId::try_from(id_byte).map_err(|_| DecodeError::InvalidProperty {
packet_type: PacketType::Subscribe,
id: id_byte,
})?;
match id {
PropertyId::SubscriptionIdentifier => {
if props.subscription_identifier.is_some() {
return Err(DecodeError::DuplicateProperty { id: id_byte });
}
props.subscription_identifier = Some(varint::decode(&mut buf)?);
}
PropertyId::UserProperty => {
props.user_properties.push(primitives::read_string_pair(&mut buf)?);
}
_ => {
return Err(DecodeError::InvalidProperty {
packet_type: PacketType::Subscribe,
id: id_byte,
});
}
}
}
Ok(props)
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Subscribe {
pub pkid: u16,
pub properties: SubscribeProperties,
pub filters: Vec<SubscribeFilter>,
}
impl Subscribe {
const FLAGS: u8 = 0b0010;
pub(super) fn flags(&self) -> u8 {
Self::FLAGS
}
pub(super) fn encoded_body_len(&self) -> usize {
let mut len = 2;
len += properties_encoded_len(self.properties.encoded_len());
for f in &self.filters {
len += 2 + f.topic.len() + 1;
}
len
}
pub(super) fn encode_body(&self, buf: &mut BytesMut) -> Result<(), EncodeError> {
if self.filters.is_empty() {
return Err(EncodeError::InvalidState {
reason: "SUBSCRIBE needs at least one filter",
});
}
primitives::write_u16(self.pkid, buf);
self.properties.encode(buf)?;
for f in &self.filters {
primitives::write_string(&f.topic, buf)?;
let opts = (f.qos as u8)
| if f.no_local { 0x04 } else { 0 }
| if f.retain_as_published { 0x08 } else { 0 }
| ((f.retain_handling as u8) << 4);
primitives::write_u8(opts, buf);
}
Ok(())
}
pub(super) fn decode_body(header_flags: u8, mut buf: Bytes) -> Result<Self, DecodeError> {
if header_flags != Self::FLAGS {
return Err(DecodeError::InvalidFlags {
packet_type: PacketType::Subscribe,
flags: header_flags,
});
}
let pkid = primitives::read_u16(&mut buf)?;
let props_buf = property::read_properties_bytes(&mut buf)?;
let properties = SubscribeProperties::decode(props_buf)?;
let mut filters = Vec::new();
while buf.has_remaining() {
let topic = primitives::read_string(&mut buf)?;
let opts = primitives::read_u8(&mut buf)?;
let qos = QoS::try_from(opts & 0x03)?;
let no_local = opts & 0x04 != 0;
let retain_as_published = opts & 0x08 != 0;
let retain_handling = RetainHandling::try_from((opts >> 4) & 0x03)?;
if opts & 0xC0 != 0 {
return Err(DecodeError::ProtocolError {
reason: "reserved bits in subscription options",
});
}
filters.push(SubscribeFilter {
topic,
qos,
no_local,
retain_as_published,
retain_handling,
});
}
if filters.is_empty() {
return Err(DecodeError::ProtocolError {
reason: "SUBSCRIBE must have at least one filter",
});
}
Ok(Self {
pkid,
properties,
filters,
})
}
}
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct SubAckProperties {
pub reason_string: Option<String>,
pub user_properties: Vec<(String, String)>,
}
impl SubAckProperties {
fn encoded_len(&self) -> usize {
let mut len = 0;
if let Some(ref s) = self.reason_string {
len += PROP_ID_LEN + primitives::string_encoded_len(s.len());
}
for (k, v) in &self.user_properties {
len += PROP_ID_LEN + primitives::string_pair_encoded_len(k.len(), v.len());
}
len
}
fn encode(&self, buf: &mut BytesMut) -> Result<(), EncodeError> {
write_properties_len(self.encoded_len(), buf);
if let Some(ref s) = self.reason_string {
primitives::write_u8(PropertyId::ReasonString as u8, buf);
primitives::write_string(s, buf)?;
}
for (k, v) in &self.user_properties {
primitives::write_u8(PropertyId::UserProperty as u8, buf);
primitives::write_string_pair(k, v, buf)?;
}
Ok(())
}
fn decode(mut buf: Bytes) -> Result<Self, DecodeError> {
let mut props = Self::default();
while buf.has_remaining() {
let id_byte = primitives::read_u8(&mut buf)?;
let id = PropertyId::try_from(id_byte).map_err(|_| DecodeError::InvalidProperty {
packet_type: PacketType::SubAck,
id: id_byte,
})?;
match id {
PropertyId::ReasonString => {
if props.reason_string.is_some() {
return Err(DecodeError::DuplicateProperty { id: id_byte });
}
props.reason_string = Some(primitives::read_string(&mut buf)?);
}
PropertyId::UserProperty => {
props.user_properties.push(primitives::read_string_pair(&mut buf)?);
}
_ => {
return Err(DecodeError::InvalidProperty {
packet_type: PacketType::SubAck,
id: id_byte,
});
}
}
}
Ok(props)
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct SubAck {
pub pkid: u16,
pub properties: SubAckProperties,
pub reason_codes: Vec<ReasonCode>,
}
impl SubAck {
const FLAGS: u8 = 0b0000;
pub(super) fn flags(&self) -> u8 {
Self::FLAGS
}
pub(super) fn encoded_body_len(&self) -> usize {
2 + properties_encoded_len(self.properties.encoded_len()) + self.reason_codes.len()
}
pub(super) fn encode_body(&self, buf: &mut BytesMut) -> Result<(), EncodeError> {
primitives::write_u16(self.pkid, buf);
self.properties.encode(buf)?;
for &rc in &self.reason_codes {
primitives::write_u8(rc as u8, buf);
}
Ok(())
}
pub(super) fn decode_body(header_flags: u8, mut buf: Bytes) -> Result<Self, DecodeError> {
if header_flags != Self::FLAGS {
return Err(DecodeError::InvalidFlags {
packet_type: PacketType::SubAck,
flags: header_flags,
});
}
let pkid = primitives::read_u16(&mut buf)?;
let props_buf = property::read_properties_bytes(&mut buf)?;
let properties = SubAckProperties::decode(props_buf)?;
let mut reason_codes = Vec::new();
while buf.has_remaining() {
reason_codes.push(ReasonCode::try_from(primitives::read_u8(&mut buf)?)?);
}
Ok(Self {
pkid,
properties,
reason_codes,
})
}
}
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct UnsubscribeProperties {
pub user_properties: Vec<(String, String)>,
}
impl UnsubscribeProperties {
fn encoded_len(&self) -> usize {
let mut len = 0;
for (k, v) in &self.user_properties {
len += PROP_ID_LEN + primitives::string_pair_encoded_len(k.len(), v.len());
}
len
}
fn encode(&self, buf: &mut BytesMut) -> Result<(), EncodeError> {
write_properties_len(self.encoded_len(), buf);
for (k, v) in &self.user_properties {
primitives::write_u8(PropertyId::UserProperty as u8, buf);
primitives::write_string_pair(k, v, buf)?;
}
Ok(())
}
fn decode(mut buf: Bytes) -> Result<Self, DecodeError> {
let mut props = Self::default();
while buf.has_remaining() {
let id_byte = primitives::read_u8(&mut buf)?;
let id = PropertyId::try_from(id_byte).map_err(|_| DecodeError::InvalidProperty {
packet_type: PacketType::Unsubscribe,
id: id_byte,
})?;
match id {
PropertyId::UserProperty => {
props.user_properties.push(primitives::read_string_pair(&mut buf)?);
}
_ => {
return Err(DecodeError::InvalidProperty {
packet_type: PacketType::Unsubscribe,
id: id_byte,
});
}
}
}
Ok(props)
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Unsubscribe {
pub pkid: u16,
pub properties: UnsubscribeProperties,
pub topics: Vec<String>,
}
impl Unsubscribe {
const FLAGS: u8 = 0b0010;
pub(super) fn flags(&self) -> u8 {
Self::FLAGS
}
pub(super) fn encoded_body_len(&self) -> usize {
let mut len = 2;
len += properties_encoded_len(self.properties.encoded_len());
for t in &self.topics {
len += 2 + t.len();
}
len
}
pub(super) fn encode_body(&self, buf: &mut BytesMut) -> Result<(), EncodeError> {
if self.topics.is_empty() {
return Err(EncodeError::InvalidState {
reason: "UNSUBSCRIBE needs at least one topic",
});
}
primitives::write_u16(self.pkid, buf);
self.properties.encode(buf)?;
for t in &self.topics {
primitives::write_string(t, buf)?;
}
Ok(())
}
pub(super) fn decode_body(header_flags: u8, mut buf: Bytes) -> Result<Self, DecodeError> {
if header_flags != Self::FLAGS {
return Err(DecodeError::InvalidFlags {
packet_type: PacketType::Unsubscribe,
flags: header_flags,
});
}
let pkid = primitives::read_u16(&mut buf)?;
let props_buf = property::read_properties_bytes(&mut buf)?;
let properties = UnsubscribeProperties::decode(props_buf)?;
let mut topics = Vec::new();
while buf.has_remaining() {
topics.push(primitives::read_string(&mut buf)?);
}
if topics.is_empty() {
return Err(DecodeError::ProtocolError {
reason: "UNSUBSCRIBE must have at least one topic",
});
}
Ok(Self {
pkid,
properties,
topics,
})
}
}
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct UnsubAckProperties {
pub reason_string: Option<String>,
pub user_properties: Vec<(String, String)>,
}
impl UnsubAckProperties {
fn encoded_len(&self) -> usize {
let mut len = 0;
if let Some(ref s) = self.reason_string {
len += PROP_ID_LEN + primitives::string_encoded_len(s.len());
}
for (k, v) in &self.user_properties {
len += PROP_ID_LEN + primitives::string_pair_encoded_len(k.len(), v.len());
}
len
}
fn encode(&self, buf: &mut BytesMut) -> Result<(), EncodeError> {
write_properties_len(self.encoded_len(), buf);
if let Some(ref s) = self.reason_string {
primitives::write_u8(PropertyId::ReasonString as u8, buf);
primitives::write_string(s, buf)?;
}
for (k, v) in &self.user_properties {
primitives::write_u8(PropertyId::UserProperty as u8, buf);
primitives::write_string_pair(k, v, buf)?;
}
Ok(())
}
fn decode(mut buf: Bytes) -> Result<Self, DecodeError> {
let mut props = Self::default();
while buf.has_remaining() {
let id_byte = primitives::read_u8(&mut buf)?;
let id = PropertyId::try_from(id_byte).map_err(|_| DecodeError::InvalidProperty {
packet_type: PacketType::UnsubAck,
id: id_byte,
})?;
match id {
PropertyId::ReasonString => {
if props.reason_string.is_some() {
return Err(DecodeError::DuplicateProperty { id: id_byte });
}
props.reason_string = Some(primitives::read_string(&mut buf)?);
}
PropertyId::UserProperty => {
props.user_properties.push(primitives::read_string_pair(&mut buf)?);
}
_ => {
return Err(DecodeError::InvalidProperty {
packet_type: PacketType::UnsubAck,
id: id_byte,
});
}
}
}
Ok(props)
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct UnsubAck {
pub pkid: u16,
pub properties: UnsubAckProperties,
pub reason_codes: Vec<ReasonCode>,
}
impl UnsubAck {
const FLAGS: u8 = 0b0000;
pub(super) fn flags(&self) -> u8 {
Self::FLAGS
}
pub(super) fn encoded_body_len(&self) -> usize {
2 + properties_encoded_len(self.properties.encoded_len()) + self.reason_codes.len()
}
pub(super) fn encode_body(&self, buf: &mut BytesMut) -> Result<(), EncodeError> {
primitives::write_u16(self.pkid, buf);
self.properties.encode(buf)?;
for &rc in &self.reason_codes {
primitives::write_u8(rc as u8, buf);
}
Ok(())
}
pub(super) fn decode_body(header_flags: u8, mut buf: Bytes) -> Result<Self, DecodeError> {
if header_flags != Self::FLAGS {
return Err(DecodeError::InvalidFlags {
packet_type: PacketType::UnsubAck,
flags: header_flags,
});
}
let pkid = primitives::read_u16(&mut buf)?;
let props_buf = property::read_properties_bytes(&mut buf)?;
let properties = UnsubAckProperties::decode(props_buf)?;
let mut reason_codes = Vec::new();
while buf.has_remaining() {
reason_codes.push(ReasonCode::try_from(primitives::read_u8(&mut buf)?)?);
}
Ok(Self {
pkid,
properties,
reason_codes,
})
}
}
#[cfg(test)]
mod tests {
use bytes::{Bytes, BytesMut};
use super::*;
use crate::v5::Packet;
use crate::{DecodeError, PacketType, QoS};
fn roundtrip(packet: Packet) -> Packet {
let mut buf = BytesMut::new();
packet.encode(&mut buf).unwrap();
Packet::decode(&mut buf).unwrap().unwrap()
}
#[test]
fn subscribe_single_default_options() {
let pkt = Packet::Subscribe(Subscribe {
pkid: 1,
properties: SubscribeProperties::default(),
filters: vec![SubscribeFilter {
topic: "a/b".to_owned(),
qos: QoS::AtMostOnce,
no_local: false,
retain_as_published: false,
retain_handling: RetainHandling::SendAtSubscribe,
}],
});
assert_eq!(roundtrip(pkt.clone()), pkt);
}
#[test]
fn subscribe_full_options() {
let pkt = Packet::Subscribe(Subscribe {
pkid: 99,
properties: SubscribeProperties {
subscription_identifier: Some(12345),
user_properties: vec![("sub-key".to_owned(), "sub-val".to_owned())],
},
filters: vec![
SubscribeFilter {
topic: "a/+".to_owned(),
qos: QoS::ExactlyOnce,
no_local: true,
retain_as_published: true,
retain_handling: RetainHandling::DoNotSend,
},
SubscribeFilter {
topic: "b/#".to_owned(),
qos: QoS::AtLeastOnce,
no_local: false,
retain_as_published: false,
retain_handling: RetainHandling::SendAtSubscribeIfNew,
},
],
});
assert_eq!(roundtrip(pkt.clone()), pkt);
}
#[test]
fn subscribe_invalid_flags() {
let buf = Bytes::from_static(&[0x00, 0x01, 0x00, 0x00, 0x01, b'a', 0x00]);
assert_eq!(
Subscribe::decode_body(0x00, buf),
Err(DecodeError::InvalidFlags {
packet_type: PacketType::Subscribe,
flags: 0x00,
})
);
}
#[test]
fn suback_all_success() {
let pkt = Packet::SubAck(SubAck {
pkid: 1,
properties: SubAckProperties::default(),
reason_codes: vec![ReasonCode::Success, ReasonCode::GrantedQoS1, ReasonCode::GrantedQoS2],
});
assert_eq!(roundtrip(pkt.clone()), pkt);
}
#[test]
fn suback_with_failure() {
let pkt = Packet::SubAck(SubAck {
pkid: 5,
properties: SubAckProperties {
reason_string: Some("partial failure".to_owned()),
user_properties: vec![],
},
reason_codes: vec![ReasonCode::Success, ReasonCode::UnspecifiedError],
});
assert_eq!(roundtrip(pkt.clone()), pkt);
}
#[test]
fn unsubscribe_with_properties() {
let pkt = Packet::Unsubscribe(Unsubscribe {
pkid: 10,
properties: UnsubscribeProperties {
user_properties: vec![("reason".to_owned(), "test".to_owned())],
},
topics: vec!["a/b".to_owned(), "c/d".to_owned()],
});
assert_eq!(roundtrip(pkt.clone()), pkt);
}
#[test]
fn unsubscribe_invalid_flags() {
let buf = Bytes::from_static(&[0x00, 0x01, 0x00, 0x00, 0x01, b'a']);
assert_eq!(
Unsubscribe::decode_body(0x00, buf),
Err(DecodeError::InvalidFlags {
packet_type: PacketType::Unsubscribe,
flags: 0x00,
})
);
}
#[test]
fn unsuback_roundtrip() {
let pkt = Packet::UnsubAck(UnsubAck {
pkid: 7,
properties: UnsubAckProperties::default(),
reason_codes: vec![ReasonCode::Success, ReasonCode::NoSubscriptionExisted],
});
assert_eq!(roundtrip(pkt.clone()), pkt);
}
#[test]
fn unsuback_with_properties() {
let pkt = Packet::UnsubAck(UnsubAck {
pkid: 20,
properties: UnsubAckProperties {
reason_string: Some("done".to_owned()),
user_properties: vec![("k".to_owned(), "v".to_owned())],
},
reason_codes: vec![ReasonCode::Success],
});
assert_eq!(roundtrip(pkt.clone()), pkt);
}
}