use crate::{DecodeError, varint};
#[allow(missing_docs)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[repr(u8)]
pub enum PacketType {
Connect = 1,
ConnAck = 2,
Publish = 3,
PubAck = 4,
PubRec = 5,
PubRel = 6,
PubComp = 7,
Subscribe = 8,
SubAck = 9,
Unsubscribe = 10,
UnsubAck = 11,
PingReq = 12,
PingResp = 13,
Disconnect = 14,
Auth = 15,
}
impl TryFrom<u8> for PacketType {
type Error = DecodeError;
fn try_from(value: u8) -> Result<Self, Self::Error> {
match value {
1 => Ok(Self::Connect),
2 => Ok(Self::ConnAck),
3 => Ok(Self::Publish),
4 => Ok(Self::PubAck),
5 => Ok(Self::PubRec),
6 => Ok(Self::PubRel),
7 => Ok(Self::PubComp),
8 => Ok(Self::Subscribe),
9 => Ok(Self::SubAck),
10 => Ok(Self::Unsubscribe),
11 => Ok(Self::UnsubAck),
12 => Ok(Self::PingReq),
13 => Ok(Self::PingResp),
14 => Ok(Self::Disconnect),
15 => Ok(Self::Auth),
_ => Err(DecodeError::InvalidPacketType { value }),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct FixedHeader {
pub packet_type: PacketType,
pub flags: u8,
pub remaining_len: u32,
}
pub fn peek(buf: &[u8]) -> Result<Option<(FixedHeader, usize)>, DecodeError> {
let Some((&byte1, varint_buf)) = buf.split_first() else {
return Ok(None);
};
let packet_type = PacketType::try_from(byte1 >> 4)?;
let flags = byte1 & 0x0F;
let Some((remaining_len, varint_len)) = varint::peek(varint_buf)? else {
return Ok(None);
};
Ok(Some((
FixedHeader {
packet_type,
flags,
remaining_len,
},
1 + varint_len,
)))
}
#[cfg(test)]
mod tests {
use super::*;
use crate::DecodeError;
#[test]
fn packet_type_all_valid() {
let expected = [
(1, PacketType::Connect),
(2, PacketType::ConnAck),
(3, PacketType::Publish),
(4, PacketType::PubAck),
(5, PacketType::PubRec),
(6, PacketType::PubRel),
(7, PacketType::PubComp),
(8, PacketType::Subscribe),
(9, PacketType::SubAck),
(10, PacketType::Unsubscribe),
(11, PacketType::UnsubAck),
(12, PacketType::PingReq),
(13, PacketType::PingResp),
(14, PacketType::Disconnect),
(15, PacketType::Auth),
];
for (val, pt) in expected {
assert_eq!(PacketType::try_from(val), Ok(pt));
}
}
#[test]
fn packet_type_zero_reserved() {
assert_eq!(
PacketType::try_from(0u8),
Err(DecodeError::InvalidPacketType { value: 0 })
);
}
#[test]
fn packet_type_16_invalid() {
assert_eq!(
PacketType::try_from(16u8),
Err(DecodeError::InvalidPacketType { value: 16 })
);
}
#[test]
fn packet_type_255_invalid() {
assert_eq!(
PacketType::try_from(255u8),
Err(DecodeError::InvalidPacketType { value: 255 })
);
}
#[test]
fn peek_empty_buffer() {
assert_eq!(peek(&[]), Ok(None));
}
#[test]
fn peek_only_type_byte_no_varint() {
assert_eq!(peek(&[0x10]), Ok(None));
}
#[test]
fn peek_connect_zero_body() {
let result = peek(&[0x10, 0x00]).unwrap().unwrap();
assert_eq!(result.0.packet_type, PacketType::Connect);
assert_eq!(result.0.flags, 0x00);
assert_eq!(result.0.remaining_len, 0);
assert_eq!(result.1, 2); }
#[test]
fn peek_publish_with_flags() {
let result = peek(&[0x33, 0x05]).unwrap().unwrap();
assert_eq!(result.0.packet_type, PacketType::Publish);
assert_eq!(result.0.flags, 0x03);
assert_eq!(result.0.remaining_len, 5);
assert_eq!(result.1, 2);
}
#[test]
fn peek_large_remaining_len() {
let result = peek(&[0x30, 0xFF, 0xFF, 0xFF, 0x7F]).unwrap().unwrap();
assert_eq!(result.0.remaining_len, 268_435_455);
assert_eq!(result.1, 5); }
#[test]
fn peek_type_zero_invalid() {
assert_eq!(peek(&[0x00, 0x00]), Err(DecodeError::InvalidPacketType { value: 0 }));
}
#[test]
fn peek_varint_incomplete() {
assert_eq!(peek(&[0x10, 0x80]), Ok(None));
}
#[test]
fn peek_varint_malformed() {
assert_eq!(
peek(&[0x10, 0x80, 0x80, 0x80, 0x80]),
Err(DecodeError::MalformedRemainingLength)
);
}
#[test]
fn peek_subscribe_flags() {
let result = peek(&[0x82, 0x0A]).unwrap().unwrap();
assert_eq!(result.0.packet_type, PacketType::Subscribe);
assert_eq!(result.0.flags, 0x02);
assert_eq!(result.0.remaining_len, 10);
}
#[test]
fn peek_two_byte_varint_header_len() {
let result = peek(&[0x30, 0x80, 0x01]).unwrap().unwrap();
assert_eq!(result.0.remaining_len, 128);
assert_eq!(result.1, 3);
}
}