use bytes::{Buf, BufMut, Bytes, BytesMut};
use crate::{DecodeError, EncodeError};
pub const LEN_PREFIX: usize = 2;
pub const PACKET_ID_LEN: usize = 2;
pub const MAX_PREFIXED_LEN: usize = u16::MAX as usize;
pub fn read_u8(buf: &mut Bytes) -> Result<u8, DecodeError> {
if buf.remaining() < 1 {
return Err(DecodeError::InsufficientBytes { needed: 1 });
}
Ok(buf.get_u8())
}
pub fn write_u8(value: u8, buf: &mut BytesMut) {
buf.put_u8(value);
}
pub fn read_u16(buf: &mut Bytes) -> Result<u16, DecodeError> {
if buf.remaining() < 2 {
return Err(DecodeError::InsufficientBytes { needed: 2 });
}
Ok(buf.get_u16())
}
pub fn write_u16(value: u16, buf: &mut BytesMut) {
buf.put_u16(value);
}
pub fn read_u32(buf: &mut Bytes) -> Result<u32, DecodeError> {
if buf.remaining() < 4 {
return Err(DecodeError::InsufficientBytes { needed: 4 });
}
Ok(buf.get_u32())
}
pub fn write_u32(value: u32, buf: &mut BytesMut) {
buf.put_u32(value);
}
pub fn read_string(buf: &mut Bytes) -> Result<String, DecodeError> {
let data = read_binary(buf)?;
let s = std::str::from_utf8(&data).map_err(|_| DecodeError::InvalidUtf8 {
reason: "invalid utf-8 sequence",
})?;
if s.contains('\0') {
return Err(DecodeError::InvalidUtf8 {
reason: "contains null character U+0000",
});
}
Ok(s.to_owned())
}
pub fn write_string(s: &str, buf: &mut BytesMut) -> Result<(), EncodeError> {
if s.contains('\0') {
return Err(EncodeError::StringContainsNull);
}
write_binary(s.as_bytes(), buf)
}
pub fn read_binary(buf: &mut Bytes) -> Result<Bytes, DecodeError> {
let len = read_u16(buf)? as usize;
if buf.remaining() < len {
return Err(DecodeError::InsufficientBytes {
needed: len - buf.remaining(),
});
}
Ok(buf.split_to(len))
}
pub fn write_binary(data: &[u8], buf: &mut BytesMut) -> Result<(), EncodeError> {
let len = data.len();
if len > MAX_PREFIXED_LEN {
return Err(EncodeError::StringTooLong { len });
}
buf.reserve(LEN_PREFIX + len);
buf.put_u16(len as u16);
buf.extend_from_slice(data);
Ok(())
}
pub fn read_string_pair(buf: &mut Bytes) -> Result<(String, String), DecodeError> {
let name = read_string(buf)?;
let value = read_string(buf)?;
Ok((name, value))
}
pub fn write_string_pair(name: &str, value: &str, buf: &mut BytesMut) -> Result<(), EncodeError> {
write_string(name, buf)?;
write_string(value, buf)?;
Ok(())
}
#[inline]
pub const fn string_encoded_len(s_len: usize) -> usize {
LEN_PREFIX + s_len
}
#[inline]
pub const fn binary_encoded_len(data_len: usize) -> usize {
LEN_PREFIX + data_len
}
#[inline]
pub const fn string_pair_encoded_len(name_len: usize, value_len: usize) -> usize {
LEN_PREFIX + name_len + LEN_PREFIX + value_len
}
#[cfg(test)]
mod tests {
use bytes::{Bytes, BytesMut};
use super::*;
use crate::{DecodeError, EncodeError};
#[test]
fn read_u8_normal() {
let mut buf = Bytes::from_static(&[0x42]);
assert_eq!(read_u8(&mut buf).unwrap(), 0x42);
assert_eq!(buf.remaining(), 0);
}
#[test]
fn read_u8_zero() {
let mut buf = Bytes::from_static(&[0x00]);
assert_eq!(read_u8(&mut buf).unwrap(), 0x00);
}
#[test]
fn read_u8_max() {
let mut buf = Bytes::from_static(&[0xFF]);
assert_eq!(read_u8(&mut buf).unwrap(), 0xFF);
}
#[test]
fn read_u8_empty_buffer() {
let mut buf = Bytes::new();
assert_eq!(read_u8(&mut buf), Err(DecodeError::InsufficientBytes { needed: 1 }));
}
#[test]
fn write_u8_roundtrip() {
let mut wbuf = BytesMut::new();
write_u8(0xAB, &mut wbuf);
let mut rbuf = wbuf.freeze();
assert_eq!(read_u8(&mut rbuf).unwrap(), 0xAB);
}
#[test]
fn read_u16_big_endian() {
let mut buf = Bytes::from_static(&[0x01, 0x00]);
assert_eq!(read_u16(&mut buf).unwrap(), 256);
}
#[test]
fn read_u16_zero() {
let mut buf = Bytes::from_static(&[0x00, 0x00]);
assert_eq!(read_u16(&mut buf).unwrap(), 0);
}
#[test]
fn read_u16_max() {
let mut buf = Bytes::from_static(&[0xFF, 0xFF]);
assert_eq!(read_u16(&mut buf).unwrap(), 65535);
}
#[test]
fn read_u16_one_byte() {
let mut buf = Bytes::from_static(&[0x01]);
assert_eq!(read_u16(&mut buf), Err(DecodeError::InsufficientBytes { needed: 2 }));
}
#[test]
fn read_u16_empty() {
let mut buf = Bytes::new();
assert_eq!(read_u16(&mut buf), Err(DecodeError::InsufficientBytes { needed: 2 }));
}
#[test]
fn write_u16_roundtrip() {
let mut wbuf = BytesMut::new();
write_u16(12345, &mut wbuf);
let mut rbuf = wbuf.freeze();
assert_eq!(read_u16(&mut rbuf).unwrap(), 12345);
}
#[test]
fn read_u32_normal() {
let mut buf = Bytes::from_static(&[0x00, 0x01, 0x00, 0x00]);
assert_eq!(read_u32(&mut buf).unwrap(), 65536);
}
#[test]
fn read_u32_zero() {
let mut buf = Bytes::from_static(&[0x00, 0x00, 0x00, 0x00]);
assert_eq!(read_u32(&mut buf).unwrap(), 0);
}
#[test]
fn read_u32_max() {
let mut buf = Bytes::from_static(&[0xFF, 0xFF, 0xFF, 0xFF]);
assert_eq!(read_u32(&mut buf).unwrap(), u32::MAX);
}
#[test]
fn read_u32_three_bytes() {
let mut buf = Bytes::from_static(&[0x01, 0x02, 0x03]);
assert_eq!(read_u32(&mut buf), Err(DecodeError::InsufficientBytes { needed: 4 }));
}
#[test]
fn read_u32_empty() {
let mut buf = Bytes::new();
assert_eq!(read_u32(&mut buf), Err(DecodeError::InsufficientBytes { needed: 4 }));
}
#[test]
fn write_u32_roundtrip() {
let mut wbuf = BytesMut::new();
write_u32(0xDEAD_BEEF, &mut wbuf);
let mut rbuf = wbuf.freeze();
assert_eq!(read_u32(&mut rbuf).unwrap(), 0xDEAD_BEEF);
}
#[test]
fn read_string_ascii() {
let mut wbuf = BytesMut::new();
write_string("hello", &mut wbuf).unwrap();
let mut rbuf = wbuf.freeze();
assert_eq!(read_string(&mut rbuf).unwrap(), "hello");
}
#[test]
fn read_string_empty() {
let mut buf = Bytes::from_static(&[0x00, 0x00]);
assert_eq!(read_string(&mut buf).unwrap(), "");
}
#[test]
fn read_string_utf8_multibyte() {
let mut wbuf = BytesMut::new();
write_string("你好", &mut wbuf).unwrap();
let mut rbuf = wbuf.freeze();
assert_eq!(read_string(&mut rbuf).unwrap(), "你好");
}
#[test]
fn read_string_contains_null() {
let mut buf = Bytes::from_static(&[0x00, 0x03, b'a', 0x00, b'b']);
assert_eq!(
read_string(&mut buf),
Err(DecodeError::InvalidUtf8 {
reason: "contains null character U+0000"
})
);
}
#[test]
fn read_string_invalid_utf8() {
let mut buf = Bytes::from_static(&[0x00, 0x02, 0xFF, 0xFE]);
assert_eq!(
read_string(&mut buf),
Err(DecodeError::InvalidUtf8 {
reason: "invalid utf-8 sequence"
})
);
}
#[test]
fn read_string_incomplete_prefix() {
let mut buf = Bytes::from_static(&[0x00]);
assert!(read_string(&mut buf).is_err());
}
#[test]
fn read_string_length_exceeds_data() {
let mut buf = Bytes::from_static(&[0x00, 0x0A, b'h', b'e', b'l', b'l', b'o']);
assert!(matches!(
read_string(&mut buf),
Err(DecodeError::InsufficientBytes { .. })
));
}
#[test]
fn write_string_too_long() {
let long = "a".repeat(65536);
let mut buf = BytesMut::new();
assert_eq!(
write_string(&long, &mut buf),
Err(EncodeError::StringTooLong { len: 65536 })
);
}
#[test]
fn write_string_contains_null() {
let mut buf = BytesMut::new();
assert_eq!(write_string("ab\0cd", &mut buf), Err(EncodeError::StringContainsNull));
}
#[test]
fn write_string_max_length() {
let max_str = "a".repeat(65535);
let mut buf = BytesMut::new();
assert!(write_string(&max_str, &mut buf).is_ok());
}
#[test]
fn read_binary_normal() {
let mut buf = Bytes::from_static(&[0x00, 0x03, 0x01, 0x02, 0x03]);
let data = read_binary(&mut buf).unwrap();
assert_eq!(&data[..], &[0x01, 0x02, 0x03]);
}
#[test]
fn read_binary_empty() {
let mut buf = Bytes::from_static(&[0x00, 0x00]);
let data = read_binary(&mut buf).unwrap();
assert!(data.is_empty());
}
#[test]
fn write_binary_too_long() {
let data = vec![0u8; 65536];
let mut buf = BytesMut::new();
assert_eq!(
write_binary(&data, &mut buf),
Err(EncodeError::StringTooLong { len: 65536 })
);
}
#[test]
fn read_binary_length_exceeds_data() {
let mut buf = Bytes::from_static(&[0x00, 0x05, 0x01, 0x02, 0x03]);
assert!(matches!(
read_binary(&mut buf),
Err(DecodeError::InsufficientBytes { .. })
));
}
#[test]
fn write_binary_roundtrip() {
let data = b"mqtt payload";
let mut wbuf = BytesMut::new();
write_binary(data, &mut wbuf).unwrap();
let mut rbuf = wbuf.freeze();
assert_eq!(&read_binary(&mut rbuf).unwrap()[..], data);
}
#[test]
fn string_pair_roundtrip() {
let mut wbuf = BytesMut::new();
write_string_pair("key", "value", &mut wbuf).unwrap();
let mut rbuf = wbuf.freeze();
assert_eq!(
read_string_pair(&mut rbuf).unwrap(),
("key".to_owned(), "value".to_owned())
);
}
#[test]
fn string_pair_empty() {
let mut wbuf = BytesMut::new();
write_string_pair("", "", &mut wbuf).unwrap();
let mut rbuf = wbuf.freeze();
assert_eq!(read_string_pair(&mut rbuf).unwrap(), (String::new(), String::new()));
}
#[test]
fn string_pair_first_has_null() {
let mut buf = BytesMut::new();
assert_eq!(
write_string_pair("k\0", "v", &mut buf),
Err(EncodeError::StringContainsNull)
);
}
#[test]
fn string_pair_second_has_null() {
let mut buf = BytesMut::new();
assert_eq!(
write_string_pair("k", "v\0", &mut buf),
Err(EncodeError::StringContainsNull)
);
}
#[test]
fn string_pair_incomplete_second() {
let mut wbuf = BytesMut::new();
write_string("key", &mut wbuf).unwrap();
let mut rbuf = wbuf.freeze();
assert!(read_string_pair(&mut rbuf).is_err());
}
#[test]
fn string_encoded_len_normal() {
assert_eq!(string_encoded_len(5), 7);
}
#[test]
fn string_encoded_len_zero() {
assert_eq!(string_encoded_len(0), 2);
}
#[test]
fn binary_encoded_len_normal() {
assert_eq!(binary_encoded_len(100), 102);
}
#[test]
fn string_pair_encoded_len_normal() {
assert_eq!(string_pair_encoded_len(3, 5), 12);
}
}