use bytes::{Buf, Bytes, BytesMut};
use crate::primitives::PACKET_ID_LEN;
use crate::{DecodeError, EncodeError, PacketType, QoS, primitives};
const SUBACK_FAILURE: u8 = 0x80;
const TYPICAL_FILTER_COUNT: usize = 4;
const TYPICAL_RETURN_CODE_COUNT: usize = 8;
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct SubscribeFilter {
pub topic: String,
pub qos: QoS,
}
impl SubscribeFilter {
pub fn new(topic: String, qos: QoS) -> Self {
Self { topic, qos }
}
}
impl From<(&str, QoS)> for SubscribeFilter {
fn from((topic, qos): (&str, QoS)) -> Self {
Self {
qos,
topic: topic.to_string(),
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Subscribe {
pub pkid: u16,
pub filters: Vec<SubscribeFilter>,
}
impl Subscribe {
const FLAGS: u8 = 0b0010;
const QOS_FIELD_LEN: usize = 1;
pub(super) fn flags(&self) -> u8 {
Self::FLAGS
}
pub(super) fn encoded_body_len(&self) -> usize {
PACKET_ID_LEN
+ self
.filters
.iter()
.map(|f| primitives::string_encoded_len(f.topic.len()) + Self::QOS_FIELD_LEN)
.sum::<usize>()
}
pub(super) fn encode_body(&self, buf: &mut BytesMut) -> Result<(), EncodeError> {
if self.filters.is_empty() {
return Err(EncodeError::InvalidState {
reason: "SUBSCRIBE must have at least one filter",
});
}
primitives::write_u16(self.pkid, buf);
for filter in &self.filters {
primitives::write_string(&filter.topic, buf)?;
primitives::write_u8(filter.qos 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::Subscribe,
flags: header_flags,
});
}
let pkid = primitives::read_u16(&mut buf)?;
let mut filters = Vec::with_capacity(TYPICAL_FILTER_COUNT);
while buf.has_remaining() {
let topic = primitives::read_string(&mut buf)?;
let qos_byte = primitives::read_u8(&mut buf)?;
if qos_byte & 0xFC != 0 {
return Err(DecodeError::ProtocolError {
reason: "SUBSCRIBE QoS field upper 6 bits must be 0",
});
}
filters.push(SubscribeFilter {
topic,
qos: QoS::try_from(qos_byte & 0x03)?,
});
}
if filters.is_empty() {
return Err(DecodeError::ProtocolError {
reason: "SUBSCRIBE payload must contain at least one filter",
});
}
Ok(Subscribe { pkid, filters })
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum SubscribeReturnCode {
Success(QoS),
Failure,
}
impl SubscribeReturnCode {
fn to_byte(self) -> u8 {
match self {
Self::Success(qos) => qos as u8,
Self::Failure => SUBACK_FAILURE,
}
}
}
impl TryFrom<u8> for SubscribeReturnCode {
type Error = DecodeError;
fn try_from(value: u8) -> Result<Self, Self::Error> {
match value {
SUBACK_FAILURE => Ok(Self::Failure),
0x00..=0x02 => Ok(Self::Success(QoS::try_from(value)?)),
_ => Err(DecodeError::ProtocolError {
reason: "SUBACK return code must be 0x00, 0x01, 0x02, or 0x80",
}),
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct SubAck {
pub pkid: u16,
pub return_codes: Vec<SubscribeReturnCode>,
}
impl SubAck {
const FLAGS: u8 = 0b0000;
pub(super) fn flags(&self) -> u8 {
Self::FLAGS
}
pub(super) fn encoded_body_len(&self) -> usize {
PACKET_ID_LEN + self.return_codes.len()
}
pub(super) fn encode_body(&self, buf: &mut BytesMut) -> Result<(), EncodeError> {
if self.return_codes.is_empty() {
return Err(EncodeError::InvalidState {
reason: "SUBACK must have at least one return code",
});
}
primitives::write_u16(self.pkid, buf);
for rc in &self.return_codes {
primitives::write_u8(rc.to_byte(), 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 mut return_codes = Vec::with_capacity(TYPICAL_RETURN_CODE_COUNT);
while buf.has_remaining() {
return_codes.push(SubscribeReturnCode::try_from(primitives::read_u8(&mut buf)?)?);
}
if return_codes.is_empty() {
return Err(DecodeError::ProtocolError {
reason: "SUBACK payload must contain at least one return code",
});
}
Ok(SubAck { pkid, return_codes })
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Unsubscribe {
pub pkid: u16,
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 {
PACKET_ID_LEN
+ self
.topics
.iter()
.map(|t| primitives::string_encoded_len(t.len()))
.sum::<usize>()
}
pub(super) fn encode_body(&self, buf: &mut BytesMut) -> Result<(), EncodeError> {
if self.topics.is_empty() {
return Err(EncodeError::InvalidState {
reason: "UNSUBSCRIBE must have at least one topic",
});
}
primitives::write_u16(self.pkid, buf);
for topic in &self.topics {
primitives::write_string(topic, 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 mut topics = Vec::with_capacity(TYPICAL_FILTER_COUNT);
while buf.has_remaining() {
topics.push(primitives::read_string(&mut buf)?);
}
if topics.is_empty() {
return Err(DecodeError::ProtocolError {
reason: "UNSUBSCRIBE payload must contain at least one topic",
});
}
Ok(Unsubscribe { pkid, topics })
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct UnsubAck {
pub pkid: u16,
}
impl UnsubAck {
const FLAGS: u8 = 0b0000;
pub(super) fn flags(&self) -> u8 {
Self::FLAGS
}
pub(super) fn encoded_body_len(&self) -> usize {
PACKET_ID_LEN
}
pub(super) fn encode_body(&self, buf: &mut BytesMut) -> Result<(), EncodeError> {
primitives::write_u16(self.pkid, 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)?;
if !buf.is_empty() {
return Err(DecodeError::TrailingBytes { count: buf.len() });
}
Ok(UnsubAck { pkid })
}
}
#[cfg(test)]
mod tests {
use bytes::{Bytes, BytesMut};
use super::*;
use crate::v3::Packet;
use crate::{DecodeError, EncodeError, 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_filter() {
let pkt = Packet::Subscribe(Subscribe {
pkid: 1,
filters: vec![SubscribeFilter::new("a/b".to_owned(), QoS::AtMostOnce)],
});
assert_eq!(roundtrip(pkt.clone()), pkt);
}
#[test]
fn subscribe_multiple_filters() {
let pkt = Packet::Subscribe(Subscribe {
pkid: 100,
filters: vec![
SubscribeFilter::new("a/+".to_owned(), QoS::AtMostOnce),
SubscribeFilter::new("b/#".to_owned(), QoS::AtLeastOnce),
SubscribeFilter::new("c/d".to_owned(), QoS::ExactlyOnce),
],
});
assert_eq!(roundtrip(pkt.clone()), pkt);
}
#[test]
fn subscribe_invalid_flags() {
let buf = Bytes::from_static(&[0x00, 0x01, 0x00, 0x01, b'a', 0x00]);
assert_eq!(
Subscribe::decode_body(0x00, buf),
Err(DecodeError::InvalidFlags {
packet_type: PacketType::Subscribe,
flags: 0x00,
})
);
}
#[test]
fn subscribe_empty_filters() {
let pkt = Packet::Subscribe(Subscribe {
pkid: 1,
filters: vec![],
});
let mut buf = BytesMut::new();
assert_eq!(
pkt.encode(&mut buf),
Err(EncodeError::InvalidState {
reason: "SUBSCRIBE must have at least one filter"
})
);
}
#[test]
fn subscribe_decode_empty_payload() {
let buf = Bytes::from_static(&[0x00, 0x01]);
assert_eq!(
Subscribe::decode_body(0x02, buf),
Err(DecodeError::ProtocolError {
reason: "SUBSCRIBE payload must contain at least one filter"
})
);
}
#[test]
fn subscribe_decode_qos_upper_bits_set() {
let mut raw = BytesMut::new();
primitives::write_u16(1, &mut raw);
primitives::write_string("a", &mut raw).unwrap();
primitives::write_u8(0x04, &mut raw); let buf = raw.freeze();
assert_eq!(
Subscribe::decode_body(0x02, buf),
Err(DecodeError::ProtocolError {
reason: "SUBSCRIBE QoS field upper 6 bits must be 0"
})
);
}
#[test]
fn suback_all_success() {
let pkt = Packet::SubAck(SubAck {
pkid: 1,
return_codes: vec![
SubscribeReturnCode::Success(QoS::AtMostOnce),
SubscribeReturnCode::Success(QoS::AtLeastOnce),
SubscribeReturnCode::Success(QoS::ExactlyOnce),
],
});
assert_eq!(roundtrip(pkt.clone()), pkt);
}
#[test]
fn suback_with_failure() {
let pkt = Packet::SubAck(SubAck {
pkid: 10,
return_codes: vec![
SubscribeReturnCode::Success(QoS::AtLeastOnce),
SubscribeReturnCode::Failure,
],
});
assert_eq!(roundtrip(pkt.clone()), pkt);
}
#[test]
fn suback_invalid_return_code() {
let buf = Bytes::from_static(&[0x00, 0x01, 0x03]);
assert_eq!(
SubAck::decode_body(0x00, buf),
Err(DecodeError::ProtocolError {
reason: "SUBACK return code must be 0x00, 0x01, 0x02, or 0x80"
})
);
}
#[test]
fn suback_empty_return_codes() {
let buf = Bytes::from_static(&[0x00, 0x01]);
assert_eq!(
SubAck::decode_body(0x00, buf),
Err(DecodeError::ProtocolError {
reason: "SUBACK payload must contain at least one return code"
})
);
}
#[test]
fn suback_encode_empty_return_codes() {
let pkt = Packet::SubAck(SubAck {
pkid: 1,
return_codes: vec![],
});
let mut buf = BytesMut::new();
assert_eq!(
pkt.encode(&mut buf),
Err(EncodeError::InvalidState {
reason: "SUBACK must have at least one return code"
})
);
}
#[test]
fn unsubscribe_single_topic() {
let pkt = Packet::Unsubscribe(Unsubscribe {
pkid: 5,
topics: vec!["a/b".to_owned()],
});
assert_eq!(roundtrip(pkt.clone()), pkt);
}
#[test]
fn unsubscribe_multiple_topics() {
let pkt = Packet::Unsubscribe(Unsubscribe {
pkid: 99,
topics: vec!["x".to_owned(), "y/z".to_owned(), "#".to_owned()],
});
assert_eq!(roundtrip(pkt.clone()), pkt);
}
#[test]
fn unsubscribe_invalid_flags() {
let buf = Bytes::from_static(&[0x00, 0x01, 0x00, 0x01, b'a']);
assert_eq!(
Unsubscribe::decode_body(0x00, buf),
Err(DecodeError::InvalidFlags {
packet_type: PacketType::Unsubscribe,
flags: 0x00,
})
);
}
#[test]
fn unsubscribe_empty_topics() {
let pkt = Packet::Unsubscribe(Unsubscribe {
pkid: 1,
topics: vec![],
});
let mut buf = BytesMut::new();
assert_eq!(
pkt.encode(&mut buf),
Err(EncodeError::InvalidState {
reason: "UNSUBSCRIBE must have at least one topic"
})
);
}
#[test]
fn unsubscribe_decode_empty_payload() {
let buf = Bytes::from_static(&[0x00, 0x01]);
assert_eq!(
Unsubscribe::decode_body(0x02, buf),
Err(DecodeError::ProtocolError {
reason: "UNSUBSCRIBE payload must contain at least one topic"
})
);
}
#[test]
fn unsuback_roundtrip() {
let pkt = Packet::UnsubAck(UnsubAck { pkid: 7 });
assert_eq!(roundtrip(pkt.clone()), pkt);
}
#[test]
fn unsuback_invalid_flags() {
let buf = Bytes::from_static(&[0x00, 0x01]);
assert_eq!(
UnsubAck::decode_body(0x01, buf),
Err(DecodeError::InvalidFlags {
packet_type: PacketType::UnsubAck,
flags: 0x01,
})
);
}
#[test]
fn unsuback_trailing_bytes() {
let buf = Bytes::from_static(&[0x00, 0x01, 0xFF]);
assert_eq!(
UnsubAck::decode_body(0x00, buf),
Err(DecodeError::TrailingBytes { count: 1 })
);
}
}