use bytes::{Bytes, BytesMut};
use crate::primitives::PACKET_ID_LEN;
use crate::{DecodeError, EncodeError, PacketType, QoS, primitives};
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Publish {
pub dup: bool,
pub qos: QoS,
pub retain: bool,
pub topic: String,
pub pkid: Option<u16>,
pub payload: Bytes,
}
impl Publish {
pub(super) fn flags(&self) -> u8 {
let mut flags = (self.qos as u8) << 1;
if self.dup {
flags |= 0x08;
}
if self.retain {
flags |= 0x01;
}
flags
}
pub(super) fn encode_body(&self, buf: &mut BytesMut) -> Result<(), EncodeError> {
self.validate()?;
primitives::write_string(&self.topic, buf)?;
if let Some(pkid) = self.pkid {
primitives::write_u16(pkid, buf);
}
buf.extend_from_slice(&self.payload);
Ok(())
}
pub(super) fn encoded_body_len(&self) -> usize {
let mut len = primitives::string_encoded_len(self.topic.len());
if self.pkid.is_some() {
len += PACKET_ID_LEN;
}
len += self.payload.len();
len
}
pub(super) fn decode_body(header_flags: u8, mut buf: Bytes) -> Result<Self, DecodeError> {
let qos = QoS::try_from((header_flags >> 1) & 0x03)?;
let dup = header_flags & 0x08 != 0;
let retain = header_flags & 0x01 != 0;
let topic = primitives::read_string(&mut buf)?;
let pkid = match qos {
QoS::AtMostOnce => None,
QoS::AtLeastOnce | QoS::ExactlyOnce => Some(primitives::read_u16(&mut buf)?),
};
Ok(Publish {
dup,
qos,
retain,
topic,
pkid,
payload: buf,
})
}
fn validate(&self) -> Result<(), EncodeError> {
match self.qos {
QoS::AtMostOnce => {
if self.pkid.is_some() {
return Err(EncodeError::InvalidState {
reason: "QoS 0 PUBLISH must not have packet identifier",
});
}
}
QoS::AtLeastOnce | QoS::ExactlyOnce => match self.pkid {
None => {
return Err(EncodeError::InvalidState {
reason: "QoS 1/2 PUBLISH must have packet identifier",
});
}
Some(0) => {
return Err(EncodeError::InvalidState {
reason: "packet identifier must be non-zero",
});
}
_ => {}
},
}
Ok(())
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct PubAck {
pub pkid: u16,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct PubRec {
pub pkid: u16,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct PubRel {
pub pkid: u16,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct PubComp {
pub pkid: u16,
}
macro_rules! impl_pkid_ack {
($($name:ident => ($packet_type:ident, $flags:expr, $flags_doc:literal)),* $(,)?) => {
$(
impl $name {
#[doc = $flags_doc]
const FLAGS: u8 = $flags;
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::$packet_type,
flags: header_flags,
});
}
let pkid = primitives::read_u16(&mut buf)?;
if !buf.is_empty() {
return Err(DecodeError::TrailingBytes { count: buf.len() });
}
Ok(Self { pkid })
}
}
)*
};
}
impl_pkid_ack! {
PubAck => (PubAck, 0b0000, "Fixed header flags are always 0b0000 [MQTT-2.2.2, Table 2.2]"),
PubRec => (PubRec, 0b0000, "Fixed header flags are always 0b0000 [MQTT-2.2.2, Table 2.2]"),
PubRel => (PubRel, 0b0010, "Fixed header flags are always 0b0010 [MQTT-3.6.1-1]"),
PubComp => (PubComp, 0b0000, "Fixed header flags are always 0b0000 [MQTT-2.2.2, Table 2.2]"),
}
#[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 publish_qos0_no_pkid() {
let pkt = Packet::Publish(Publish {
dup: false,
qos: QoS::AtMostOnce,
retain: false,
topic: "a/b".to_owned(),
pkid: None,
payload: Bytes::from_static(b"hi"),
});
assert_eq!(roundtrip(pkt.clone()), pkt);
}
#[test]
fn publish_qos1() {
let pkt = Packet::Publish(Publish {
dup: false,
qos: QoS::AtLeastOnce,
retain: false,
topic: "topic".to_owned(),
pkid: Some(1),
payload: Bytes::from_static(b"data"),
});
assert_eq!(roundtrip(pkt.clone()), pkt);
}
#[test]
fn publish_qos2_max_pkid() {
let pkt = Packet::Publish(Publish {
dup: false,
qos: QoS::ExactlyOnce,
retain: false,
topic: "t".to_owned(),
pkid: Some(65535),
payload: Bytes::from_static(b"x"),
});
assert_eq!(roundtrip(pkt.clone()), pkt);
}
#[test]
fn publish_retain_flag() {
let pkt = Packet::Publish(Publish {
dup: false,
qos: QoS::AtMostOnce,
retain: true,
topic: "t".to_owned(),
pkid: None,
payload: Bytes::new(),
});
let mut buf = BytesMut::new();
pkt.encode(&mut buf).unwrap();
assert_eq!(buf[0] & 0x0F, 0x01);
assert_eq!(roundtrip(pkt.clone()), pkt);
}
#[test]
fn publish_dup_flag_qos1() {
let pkt = Packet::Publish(Publish {
dup: true,
qos: QoS::AtLeastOnce,
retain: false,
topic: "t".to_owned(),
pkid: Some(10),
payload: Bytes::new(),
});
let mut buf = BytesMut::new();
pkt.encode(&mut buf).unwrap();
assert_eq!(buf[0] & 0x0F, 0x0A);
assert_eq!(roundtrip(pkt.clone()), pkt);
}
#[test]
fn publish_empty_payload() {
let pkt = Packet::Publish(Publish {
dup: false,
qos: QoS::AtMostOnce,
retain: false,
topic: "t".to_owned(),
pkid: None,
payload: Bytes::new(),
});
assert_eq!(roundtrip(pkt.clone()), pkt);
}
#[test]
fn publish_all_flags() {
let pkt = Packet::Publish(Publish {
dup: true,
qos: QoS::AtLeastOnce,
retain: true,
topic: "t".to_owned(),
pkid: Some(42),
payload: Bytes::from_static(b"payload"),
});
let mut buf = BytesMut::new();
pkt.encode(&mut buf).unwrap();
assert_eq!(buf[0] & 0x0F, 0x0B);
assert_eq!(roundtrip(pkt.clone()), pkt);
}
#[test]
fn publish_encode_qos0_with_pkid_error() {
let pkt = Packet::Publish(Publish {
dup: false,
qos: QoS::AtMostOnce,
retain: false,
topic: "t".to_owned(),
pkid: Some(1),
payload: Bytes::new(),
});
let mut buf = BytesMut::new();
assert_eq!(
pkt.encode(&mut buf),
Err(EncodeError::InvalidState {
reason: "QoS 0 PUBLISH must not have packet identifier"
})
);
}
#[test]
fn publish_encode_qos1_no_pkid_error() {
let pkt = Packet::Publish(Publish {
dup: false,
qos: QoS::AtLeastOnce,
retain: false,
topic: "t".to_owned(),
pkid: None,
payload: Bytes::new(),
});
let mut buf = BytesMut::new();
assert_eq!(
pkt.encode(&mut buf),
Err(EncodeError::InvalidState {
reason: "QoS 1/2 PUBLISH must have packet identifier"
})
);
}
#[test]
fn publish_encode_qos1_pkid_zero_error() {
let pkt = Packet::Publish(Publish {
dup: false,
qos: QoS::AtLeastOnce,
retain: false,
topic: "t".to_owned(),
pkid: Some(0),
payload: Bytes::new(),
});
let mut buf = BytesMut::new();
assert_eq!(
pkt.encode(&mut buf),
Err(EncodeError::InvalidState {
reason: "packet identifier must be non-zero"
})
);
}
#[test]
fn publish_decode_invalid_qos3() {
let buf = Bytes::from_static(&[0x00, 0x01, b't']); assert_eq!(
Publish::decode_body(0x06, buf),
Err(DecodeError::ProtocolError {
reason: "invalid QoS value"
})
);
}
#[test]
fn publish_encode_error_rollback() {
let pkt = Packet::Publish(Publish {
dup: false,
qos: QoS::AtMostOnce,
retain: false,
topic: "t".to_owned(),
pkid: Some(1), payload: Bytes::new(),
});
let mut buf = BytesMut::new();
buf.extend_from_slice(b"pre");
let _ = pkt.encode(&mut buf);
assert_eq!(&buf[..], b"pre");
}
#[test]
fn puback_roundtrip() {
let pkt = Packet::PubAck(PubAck { pkid: 1 });
assert_eq!(roundtrip(pkt.clone()), pkt);
}
#[test]
fn puback_max_pkid() {
let pkt = Packet::PubAck(PubAck { pkid: 65535 });
assert_eq!(roundtrip(pkt.clone()), pkt);
}
#[test]
fn puback_invalid_flags() {
let buf = Bytes::from_static(&[0x00, 0x01]);
assert_eq!(
PubAck::decode_body(0x01, buf),
Err(DecodeError::InvalidFlags {
packet_type: PacketType::PubAck,
flags: 0x01,
})
);
}
#[test]
fn puback_trailing_bytes() {
let buf = Bytes::from_static(&[0x00, 0x01, 0xFF]);
assert_eq!(
PubAck::decode_body(0x00, buf),
Err(DecodeError::TrailingBytes { count: 1 })
);
}
#[test]
fn pubrec_roundtrip() {
let pkt = Packet::PubRec(PubRec { pkid: 100 });
assert_eq!(roundtrip(pkt.clone()), pkt);
}
#[test]
fn pubrec_invalid_flags() {
let buf = Bytes::from_static(&[0x00, 0x01]);
assert_eq!(
PubRec::decode_body(0x01, buf),
Err(DecodeError::InvalidFlags {
packet_type: PacketType::PubRec,
flags: 0x01,
})
);
}
#[test]
fn pubrel_roundtrip() {
let pkt = Packet::PubRel(PubRel { pkid: 200 });
assert_eq!(roundtrip(pkt.clone()), pkt);
}
#[test]
fn pubrel_flags_are_0010() {
let mut buf = BytesMut::new();
Packet::PubRel(PubRel { pkid: 1 }).encode(&mut buf).unwrap();
assert_eq!(buf[0], 0x62);
}
#[test]
fn pubrel_wrong_flags() {
let buf = Bytes::from_static(&[0x00, 0x01]);
assert_eq!(
PubRel::decode_body(0x00, buf),
Err(DecodeError::InvalidFlags {
packet_type: PacketType::PubRel,
flags: 0x00,
})
);
}
#[test]
fn pubcomp_roundtrip() {
let pkt = Packet::PubComp(PubComp { pkid: 42 });
assert_eq!(roundtrip(pkt.clone()), pkt);
}
#[test]
fn pubcomp_invalid_flags() {
let buf = Bytes::from_static(&[0x00, 0x01]);
assert_eq!(
PubComp::decode_body(0x01, buf),
Err(DecodeError::InvalidFlags {
packet_type: PacketType::PubComp,
flags: 0x01,
})
);
}
#[test]
fn pubcomp_trailing_bytes() {
let buf = Bytes::from_static(&[0x00, 0x2A, 0x00]);
assert_eq!(
PubComp::decode_body(0x00, buf),
Err(DecodeError::TrailingBytes { count: 1 })
);
}
#[test]
fn puback_empty_body_error() {
let buf = Bytes::new();
assert!(matches!(
PubAck::decode_body(0x00, buf),
Err(DecodeError::InsufficientBytes { .. })
));
}
}