rumqttc/mqttbytes/v5/

connect.rs

use super::{
    BufMut, BytesMut, Error, FixedHeader, PropertyType, QoS, len_len, length, property, qos,
    read_mqtt_bytes, read_mqtt_string, read_u8, read_u16, read_u32, write_mqtt_bytes,
    write_mqtt_string, write_remaining_length,
};
use bytes::{Buf, Bytes};

type ConnectReadParts = (Connect, Option<LastWill>, ConnectAuth);

/// Connection packet initiated by the client
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Connect {
    /// Mqtt keep alive time
    pub keep_alive: u16,
    /// Client Id
    pub client_id: String,
    /// Clean session. Asks the broker to clear previous state
    pub clean_start: bool,
    pub properties: Option<ConnectProperties>,
}

impl Connect {
    pub fn read(fixed_header: FixedHeader, mut bytes: Bytes) -> Result<ConnectReadParts, Error> {
        let variable_header_index = fixed_header.header_len;
        bytes.advance(variable_header_index);

        // Variable header
        let protocol_name = read_mqtt_string(&mut bytes)?;
        let protocol_level = read_u8(&mut bytes)?;
        if protocol_name != "MQTT" {
            return Err(Error::InvalidProtocol);
        }

        if protocol_level != 5 {
            return Err(Error::InvalidProtocolLevel(protocol_level));
        }

        let connect_flags = read_u8(&mut bytes)?;
        validate_connect_flags(connect_flags)?;
        let clean_start = (connect_flags & 0b10) != 0;
        let keep_alive = read_u16(&mut bytes)?;

        let properties = ConnectProperties::read(&mut bytes)?;

        let client_id = read_mqtt_string(&mut bytes)?;
        let will = LastWill::read(connect_flags, &mut bytes)?;
        let auth = ConnectAuth::read(connect_flags, &mut bytes)?;

        let connect = Self {
            keep_alive,
            client_id,
            clean_start,
            properties,
        };

        Ok((connect, will, auth))
    }

    fn len(&self, will: Option<&LastWill>, auth: &ConnectAuth) -> usize {
        let mut len = 2 + "MQTT".len() // protocol name
                        + 1            // protocol version
                        + 1            // connect flags
                        + 2; // keep alive

        if let Some(p) = &self.properties {
            let properties_len = p.len();
            let properties_len_len = len_len(properties_len);
            len += properties_len_len + properties_len;
        } else {
            // just 1 byte representing 0 len
            len += 1;
        }

        len += 2 + self.client_id.len();

        // last will len
        if let Some(w) = will {
            len += w.len();
        }

        // username and password len
        len += auth.len();

        len
    }

    pub fn write(
        &self,
        will: &Option<LastWill>,
        auth: &ConnectAuth,
        buffer: &mut BytesMut,
    ) -> Result<usize, Error> {
        let len = self.len(will.as_ref(), auth);

        buffer.put_u8(0b0001_0000);
        let count = write_remaining_length(buffer, len)?;
        write_mqtt_string(buffer, "MQTT");

        buffer.put_u8(0x05);
        let flags_index = 1 + count + 2 + 4 + 1;

        let mut connect_flags = 0;
        if self.clean_start {
            connect_flags |= 0x02;
        }

        buffer.put_u8(connect_flags);
        buffer.put_u16(self.keep_alive);

        match &self.properties {
            Some(p) => p.write(buffer)?,
            None => {
                write_remaining_length(buffer, 0)?;
            }
        }

        write_mqtt_string(buffer, &self.client_id);

        if let Some(w) = will {
            connect_flags |= w.write(buffer)?;
        }

        connect_flags |= auth.write(buffer);

        // update connect flags
        buffer[flags_index] = connect_flags;
        Ok(1 + count + len)
    }

    pub fn size(&self, will: &Option<LastWill>, auth: &ConnectAuth) -> usize {
        let len = self.len(will.as_ref(), auth);
        let remaining_len_size = len_len(len);

        1 + remaining_len_size + len
    }
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ConnectProperties {
    /// Expiry interval property after loosing connection
    pub session_expiry_interval: Option<u32>,
    /// Maximum simultaneous packets
    pub receive_maximum: Option<u16>,
    /// Maximum packet size
    pub max_packet_size: Option<u32>,
    /// Maximum mapping integer for a topic
    pub topic_alias_max: Option<u16>,
    pub request_response_info: Option<u8>,
    pub request_problem_info: Option<u8>,
    /// List of user properties
    pub user_properties: Vec<(String, String)>,
    /// Method of authentication
    pub authentication_method: Option<String>,
    /// Authentication data
    pub authentication_data: Option<Bytes>,
}

impl ConnectProperties {
    #[must_use]
    pub const fn new() -> Self {
        Self {
            session_expiry_interval: None,
            receive_maximum: None,
            max_packet_size: None,
            topic_alias_max: None,
            request_response_info: None,
            request_problem_info: None,
            user_properties: Vec::new(),
            authentication_method: None,
            authentication_data: None,
        }
    }

    pub fn read(bytes: &mut Bytes) -> Result<Option<Self>, Error> {
        let mut session_expiry_interval = None;
        let mut receive_maximum = None;
        let mut max_packet_size = None;
        let mut topic_alias_max = None;
        let mut request_response_info = None;
        let mut request_problem_info = None;
        let mut user_properties = Vec::new();
        let mut authentication_method = None;
        let mut authentication_data = None;

        let (properties_len_len, properties_len) = length(bytes.iter())?;
        bytes.advance(properties_len_len);
        if properties_len == 0 {
            return Ok(None);
        }

        let mut cursor = 0;
        // read until cursor reaches property length. properties_len = 0 will skip this loop
        while cursor < properties_len {
            let prop = read_u8(bytes)?;
            cursor += 1;
            match property(prop)? {
                PropertyType::SessionExpiryInterval => {
                    session_expiry_interval = Some(read_u32(bytes)?);
                    cursor += 4;
                }
                PropertyType::ReceiveMaximum => {
                    let receive_max = read_u16(bytes)?;
                    if receive_max == 0 {
                        return Err(Error::ProtocolError);
                    }
                    receive_maximum = Some(receive_max);
                    cursor += 2;
                }
                PropertyType::MaximumPacketSize => {
                    max_packet_size = Some(read_u32(bytes)?);
                    cursor += 4;
                }
                PropertyType::TopicAliasMaximum => {
                    topic_alias_max = Some(read_u16(bytes)?);
                    cursor += 2;
                }
                PropertyType::RequestResponseInformation => {
                    request_response_info = Some(read_u8(bytes)?);
                    cursor += 1;
                }
                PropertyType::RequestProblemInformation => {
                    request_problem_info = Some(read_u8(bytes)?);
                    cursor += 1;
                }
                PropertyType::UserProperty => {
                    let key = read_mqtt_string(bytes)?;
                    let value = read_mqtt_string(bytes)?;
                    cursor += 2 + key.len() + 2 + value.len();
                    user_properties.push((key, value));
                }
                PropertyType::AuthenticationMethod => {
                    let method = read_mqtt_string(bytes)?;
                    cursor += 2 + method.len();
                    authentication_method = Some(method);
                }
                PropertyType::AuthenticationData => {
                    let data = read_mqtt_bytes(bytes)?;
                    cursor += 2 + data.len();
                    authentication_data = Some(data);
                }
                _ => return Err(Error::InvalidPropertyType(prop)),
            }
        }

        Ok(Some(Self {
            session_expiry_interval,
            receive_maximum,
            max_packet_size,
            topic_alias_max,
            request_response_info,
            request_problem_info,
            user_properties,
            authentication_method,
            authentication_data,
        }))
    }

    fn len(&self) -> usize {
        let mut len = 0;

        if self.session_expiry_interval.is_some() {
            len += 1 + 4;
        }

        if self.receive_maximum.is_some() {
            len += 1 + 2;
        }

        if self.max_packet_size.is_some() {
            len += 1 + 4;
        }

        if self.topic_alias_max.is_some() {
            len += 1 + 2;
        }

        if self.request_response_info.is_some() {
            len += 1 + 1;
        }

        if self.request_problem_info.is_some() {
            len += 1 + 1;
        }

        for (key, value) in &self.user_properties {
            len += 1 + 2 + key.len() + 2 + value.len();
        }

        if let Some(authentication_method) = &self.authentication_method {
            len += 1 + 2 + authentication_method.len();
        }

        if let Some(authentication_data) = &self.authentication_data {
            len += 1 + 2 + authentication_data.len();
        }

        len
    }

    pub fn write(&self, buffer: &mut BytesMut) -> Result<(), Error> {
        let len = self.len();
        write_remaining_length(buffer, len)?;

        if let Some(session_expiry_interval) = self.session_expiry_interval {
            buffer.put_u8(PropertyType::SessionExpiryInterval as u8);
            buffer.put_u32(session_expiry_interval);
        }

        if let Some(receive_maximum) = self.receive_maximum {
            buffer.put_u8(PropertyType::ReceiveMaximum as u8);
            buffer.put_u16(receive_maximum);
        }

        if let Some(max_packet_size) = self.max_packet_size {
            buffer.put_u8(PropertyType::MaximumPacketSize as u8);
            buffer.put_u32(max_packet_size);
        }

        if let Some(topic_alias_max) = self.topic_alias_max {
            buffer.put_u8(PropertyType::TopicAliasMaximum as u8);
            buffer.put_u16(topic_alias_max);
        }

        if let Some(request_response_info) = self.request_response_info {
            buffer.put_u8(PropertyType::RequestResponseInformation as u8);
            buffer.put_u8(request_response_info);
        }

        if let Some(request_problem_info) = self.request_problem_info {
            buffer.put_u8(PropertyType::RequestProblemInformation as u8);
            buffer.put_u8(request_problem_info);
        }

        for (key, value) in &self.user_properties {
            buffer.put_u8(PropertyType::UserProperty as u8);
            write_mqtt_string(buffer, key);
            write_mqtt_string(buffer, value);
        }

        if let Some(authentication_method) = &self.authentication_method {
            buffer.put_u8(PropertyType::AuthenticationMethod as u8);
            write_mqtt_string(buffer, authentication_method);
        }

        if let Some(authentication_data) = &self.authentication_data {
            buffer.put_u8(PropertyType::AuthenticationData as u8);
            write_mqtt_bytes(buffer, authentication_data);
        }

        Ok(())
    }
}

impl Default for ConnectProperties {
    fn default() -> Self {
        Self::new()
    }
}

/// `LastWill` that broker forwards on behalf of the client
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct LastWill {
    pub topic: Bytes,
    pub message: Bytes,
    pub qos: QoS,
    pub retain: bool,
    pub properties: Option<LastWillProperties>,
}

impl LastWill {
    pub fn new(
        topic: impl Into<String>,
        payload: impl Into<Vec<u8>>,
        qos: QoS,
        retain: bool,
        properties: Option<LastWillProperties>,
    ) -> Self {
        let topic = Bytes::from(topic.into().into_bytes());
        Self {
            topic,
            message: Bytes::from(payload.into()),
            qos,
            retain,
            properties,
        }
    }

    fn len(&self) -> usize {
        let mut len = 0;

        if let Some(p) = &self.properties {
            let properties_len = p.len();
            let properties_len_len = len_len(properties_len);
            len += properties_len_len + properties_len;
        } else {
            // just 1 byte representing 0 len
            len += 1;
        }

        len += 2 + self.topic.len() + 2 + self.message.len();
        len
    }

    pub fn read(connect_flags: u8, bytes: &mut Bytes) -> Result<Option<Self>, Error> {
        let o = match connect_flags & 0b100 {
            0 if (connect_flags & 0b0011_1000) != 0 => {
                return Err(Error::IncorrectPacketFormat);
            }
            0 => None,
            _ => {
                // Properties in variable header
                let properties = LastWillProperties::read(bytes)?;

                let will_topic = read_mqtt_bytes(bytes)?;
                let will_message = read_mqtt_bytes(bytes)?;
                let qos_num = (connect_flags & 0b11000) >> 3;
                let will_qos = qos(qos_num).ok_or(Error::InvalidQoS(qos_num))?;
                Some(Self {
                    topic: will_topic,
                    message: will_message,
                    qos: will_qos,
                    retain: (connect_flags & 0b0010_0000) != 0,
                    properties,
                })
            }
        };

        Ok(o)
    }

    pub fn write(&self, buffer: &mut BytesMut) -> Result<u8, Error> {
        let mut connect_flags = 0;

        connect_flags |= 0x04 | ((self.qos as u8) << 3);
        if self.retain {
            connect_flags |= 0x20;
        }

        if let Some(p) = &self.properties {
            p.write(buffer)?;
        } else {
            write_remaining_length(buffer, 0)?;
        }

        write_mqtt_bytes(buffer, &self.topic);
        write_mqtt_bytes(buffer, &self.message);
        Ok(connect_flags)
    }
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct LastWillProperties {
    pub delay_interval: Option<u32>,
    pub payload_format_indicator: Option<u8>,
    pub message_expiry_interval: Option<u32>,
    pub content_type: Option<String>,
    pub response_topic: Option<String>,
    pub correlation_data: Option<Bytes>,
    pub user_properties: Vec<(String, String)>,
}

impl LastWillProperties {
    fn len(&self) -> usize {
        let mut len = 0;

        if self.delay_interval.is_some() {
            len += 1 + 4;
        }

        if self.payload_format_indicator.is_some() {
            len += 1 + 1;
        }

        if self.message_expiry_interval.is_some() {
            len += 1 + 4;
        }

        if let Some(typ) = &self.content_type {
            len += 1 + 2 + typ.len();
        }

        if let Some(topic) = &self.response_topic {
            len += 1 + 2 + topic.len();
        }

        if let Some(data) = &self.correlation_data {
            len += 1 + 2 + data.len();
        }

        for (key, value) in &self.user_properties {
            len += 1 + 2 + key.len() + 2 + value.len();
        }

        len
    }

    pub fn read(bytes: &mut Bytes) -> Result<Option<Self>, Error> {
        let mut delay_interval = None;
        let mut payload_format_indicator = None;
        let mut message_expiry_interval = None;
        let mut content_type = None;
        let mut response_topic = None;
        let mut correlation_data = None;
        let mut user_properties = Vec::new();

        let (properties_len_len, properties_len) = length(bytes.iter())?;
        bytes.advance(properties_len_len);
        if properties_len == 0 {
            return Ok(None);
        }

        let mut cursor = 0;
        // read until cursor reaches property length. properties_len = 0 will skip this loop
        while cursor < properties_len {
            let prop = read_u8(bytes)?;
            cursor += 1;

            match property(prop)? {
                PropertyType::WillDelayInterval => {
                    delay_interval = Some(read_u32(bytes)?);
                    cursor += 4;
                }
                PropertyType::PayloadFormatIndicator => {
                    payload_format_indicator = Some(read_u8(bytes)?);
                    cursor += 1;
                }
                PropertyType::MessageExpiryInterval => {
                    message_expiry_interval = Some(read_u32(bytes)?);
                    cursor += 4;
                }
                PropertyType::ContentType => {
                    let typ = read_mqtt_string(bytes)?;
                    cursor += 2 + typ.len();
                    content_type = Some(typ);
                }
                PropertyType::ResponseTopic => {
                    let topic = read_mqtt_string(bytes)?;
                    cursor += 2 + topic.len();
                    response_topic = Some(topic);
                }
                PropertyType::CorrelationData => {
                    let data = read_mqtt_bytes(bytes)?;
                    cursor += 2 + data.len();
                    correlation_data = Some(data);
                }
                PropertyType::UserProperty => {
                    let key = read_mqtt_string(bytes)?;
                    let value = read_mqtt_string(bytes)?;
                    cursor += 2 + key.len() + 2 + value.len();
                    user_properties.push((key, value));
                }
                _ => return Err(Error::InvalidPropertyType(prop)),
            }
        }

        Ok(Some(Self {
            delay_interval,
            payload_format_indicator,
            message_expiry_interval,
            content_type,
            response_topic,
            correlation_data,
            user_properties,
        }))
    }

    pub fn write(&self, buffer: &mut BytesMut) -> Result<(), Error> {
        let len = self.len();
        write_remaining_length(buffer, len)?;

        if let Some(delay_interval) = self.delay_interval {
            buffer.put_u8(PropertyType::WillDelayInterval as u8);
            buffer.put_u32(delay_interval);
        }

        if let Some(payload_format_indicator) = self.payload_format_indicator {
            buffer.put_u8(PropertyType::PayloadFormatIndicator as u8);
            buffer.put_u8(payload_format_indicator);
        }

        if let Some(message_expiry_interval) = self.message_expiry_interval {
            buffer.put_u8(PropertyType::MessageExpiryInterval as u8);
            buffer.put_u32(message_expiry_interval);
        }

        if let Some(typ) = &self.content_type {
            buffer.put_u8(PropertyType::ContentType as u8);
            write_mqtt_string(buffer, typ);
        }

        if let Some(topic) = &self.response_topic {
            buffer.put_u8(PropertyType::ResponseTopic as u8);
            write_mqtt_string(buffer, topic);
        }

        if let Some(data) = &self.correlation_data {
            buffer.put_u8(PropertyType::CorrelationData as u8);
            write_mqtt_bytes(buffer, data);
        }

        for (key, value) in &self.user_properties {
            buffer.put_u8(PropertyType::UserProperty as u8);
            write_mqtt_string(buffer, key);
            write_mqtt_string(buffer, value);
        }

        Ok(())
    }
}
#[derive(Debug, Clone, PartialEq, Eq, Default)]
pub enum ConnectAuth {
    #[default]
    None,
    Username {
        username: String,
    },
    Password {
        password: Bytes,
    },
    UsernamePassword {
        username: String,
        password: Bytes,
    },
}

impl ConnectAuth {
    pub fn read(connect_flags: u8, bytes: &mut Bytes) -> Result<Self, Error> {
        let username_flag = (connect_flags & 0b1000_0000) != 0;
        let password_flag = (connect_flags & 0b0100_0000) != 0;

        match (username_flag, password_flag) {
            (false, false) => Ok(Self::None),
            (true, false) => Ok(Self::Username {
                username: read_mqtt_string(bytes)?,
            }),
            (false, true) => Ok(Self::Password {
                password: read_mqtt_bytes(bytes)?,
            }),
            (true, true) => Ok(Self::UsernamePassword {
                username: read_mqtt_string(bytes)?,
                password: read_mqtt_bytes(bytes)?,
            }),
        }
    }

    const fn len(&self) -> usize {
        match self {
            Self::None => 0,
            Self::Username { username } => 2 + username.len(),
            Self::Password { password } => 2 + password.len(),
            Self::UsernamePassword { username, password } => {
                2 + username.len() + 2 + password.len()
            }
        }
    }

    pub fn write(&self, buffer: &mut BytesMut) -> u8 {
        match self {
            Self::None => 0,
            Self::Username { username } => {
                write_mqtt_string(buffer, username);
                0x80
            }
            Self::Password { password } => {
                write_mqtt_bytes(buffer, password.as_ref());
                0x40
            }
            Self::UsernamePassword { username, password } => {
                write_mqtt_string(buffer, username);
                write_mqtt_bytes(buffer, password.as_ref());
                0xC0
            }
        }
    }
}

const fn validate_connect_flags(connect_flags: u8) -> Result<(), Error> {
    if (connect_flags & 0x01) != 0 {
        return Err(Error::IncorrectPacketFormat);
    }

    Ok(())
}

#[cfg(test)]
mod test {
    use super::super::test::{USER_PROP_KEY, USER_PROP_VAL};
    use super::*;
    use crate::mqttbytes::v5::parse_fixed_header;
    use bytes::Bytes;
    use bytes::BytesMut;
    use pretty_assertions::assert_eq;

    #[test]
    fn length_calculation() {
        let mut dummy_bytes = BytesMut::new();
        let mut connect_props = ConnectProperties::new();
        // Use user_properties to pad the size to exceed ~128 bytes to make the
        // remaining_length field in the packet be 2 bytes long.
        connect_props.user_properties = vec![(USER_PROP_KEY.into(), USER_PROP_VAL.into())];
        let connect_pkt = Connect {
            keep_alive: 5,
            client_id: "client".into(),
            clean_start: true,
            properties: Some(connect_props),
        };

        let reported_size = connect_pkt
            .write(&None, &ConnectAuth::None, &mut dummy_bytes)
            .unwrap();
        let size_from_bytes = dummy_bytes.len();

        assert_eq!(reported_size, size_from_bytes);
    }

    #[test]
    fn read_rejects_receive_maximum_zero() {
        let mut bytes = Bytes::from_static(&[
            0x03, // properties length
            0x21, // ReceiveMaximum property
            0x00, 0x00, // value = 0
        ]);
        let result = ConnectProperties::read(&mut bytes);

        assert!(matches!(result, Err(Error::ProtocolError)));
    }

    #[test]
    fn connect_roundtrips_binary_password() {
        let connect_pkt = Connect {
            keep_alive: 5,
            client_id: "client".into(),
            clean_start: true,
            properties: None,
        };
        let login = ConnectAuth::UsernamePassword {
            username: "binary".to_owned(),
            password: Bytes::from_static(b"\x00\xffproto\0buf"),
        };

        let mut buf = BytesMut::new();
        connect_pkt.write(&None, &login, &mut buf).unwrap();

        let fixed_header = parse_fixed_header(buf.iter()).unwrap();
        let connect_bytes = buf.split_to(fixed_header.frame_length()).freeze();
        let (_, _, decoded_login) = Connect::read(fixed_header, connect_bytes).unwrap();

        assert_eq!(
            decoded_login,
            ConnectAuth::UsernamePassword {
                username: "binary".to_owned(),
                password: Bytes::from_static(b"\x00\xffproto\0buf"),
            }
        );
    }

    #[test]
    fn connect_encoding_with_password_and_empty_username_writes_zero_len_username() {
        let connect_pkt = Connect {
            keep_alive: 5,
            client_id: "client".into(),
            clean_start: true,
            properties: None,
        };
        let login = ConnectAuth::UsernamePassword {
            username: String::new(),
            password: Bytes::from_static(b"pw"),
        };

        let mut buf = BytesMut::new();
        connect_pkt.write(&None, &login, &mut buf).unwrap();

        assert_eq!(buf[9], 0b1100_0010);

        let fixed_header = parse_fixed_header(buf.iter()).unwrap();
        let connect_bytes = buf.split_to(fixed_header.frame_length()).freeze();
        let (_, _, decoded_login) = Connect::read(fixed_header, connect_bytes).unwrap();
        assert_eq!(
            decoded_login,
            ConnectAuth::UsernamePassword {
                username: String::new(),
                password: Bytes::from_static(b"pw"),
            }
        );
    }

    #[test]
    fn connect_parsing_accepts_password_without_username_flag() {
        let mut stream = bytes::BytesMut::new();
        let packetstream = &[
            0x10, 0x15, 0x00, 0x04, b'M', b'Q', b'T', b'T', 0x05, 0x42, 0x00, 0x0a, 0x00, 0x00,
            0x04, b't', b'e', b's', b't', 0x00, 0x02, 0xff, 0x00,
        ];
        stream.extend_from_slice(packetstream);
        let fixed_header = parse_fixed_header(stream.iter()).unwrap();
        let connect_bytes = stream.split_to(fixed_header.frame_length()).freeze();
        let (_, will, auth) = Connect::read(fixed_header, connect_bytes).unwrap();

        assert_eq!(will, None);
        assert_eq!(
            auth,
            ConnectAuth::Password {
                password: Bytes::from_static(b"\xff\0"),
            }
        );
    }

    #[test]
    fn connect_parsing_rejects_reserved_connect_flag_bit() {
        let mut stream = bytes::BytesMut::new();
        let packetstream = &[
            0x10, 0x10, 0x00, 0x04, b'M', b'Q', b'T', b'T', 0x05, 0x03, 0x00, 0x0a, 0x00, 0x00,
            0x00, 0x04, b't', b'e', b's', b't',
        ];
        stream.extend_from_slice(packetstream);
        let fixed_header = parse_fixed_header(stream.iter()).unwrap();
        let connect_bytes = stream.split_to(fixed_header.frame_length()).freeze();
        let packet = Connect::read(fixed_header, connect_bytes);

        assert!(matches!(packet, Err(Error::IncorrectPacketFormat)));
    }

    #[test]
    fn connect_roundtrips_explicitly_empty_password() {
        let connect_pkt = Connect {
            keep_alive: 5,
            client_id: "client".into(),
            clean_start: true,
            properties: None,
        };
        let auth = ConnectAuth::UsernamePassword {
            username: "user".to_owned(),
            password: Bytes::new(),
        };

        let mut buf = BytesMut::new();
        connect_pkt.write(&None, &auth, &mut buf).unwrap();

        assert_eq!(buf[9], 0b1100_0010);

        let fixed_header = parse_fixed_header(buf.iter()).unwrap();
        let connect_bytes = buf.split_to(fixed_header.frame_length()).freeze();
        let (_, _, decoded_auth) = Connect::read(fixed_header, connect_bytes).unwrap();
        assert_eq!(
            decoded_auth,
            ConnectAuth::UsernamePassword {
                username: "user".to_owned(),
                password: Bytes::new(),
            }
        );
    }

    #[test]
    fn connect_roundtrips_password_only_auth() {
        let connect_pkt = Connect {
            keep_alive: 5,
            client_id: "client".into(),
            clean_start: true,
            properties: None,
        };
        let auth = ConnectAuth::Password {
            password: Bytes::from_static(b"\x00\xffproto\0buf"),
        };

        let mut buf = BytesMut::new();
        connect_pkt.write(&None, &auth, &mut buf).unwrap();

        assert_eq!(buf[9], 0b0100_0010);

        let fixed_header = parse_fixed_header(buf.iter()).unwrap();
        let connect_bytes = buf.split_to(fixed_header.frame_length()).freeze();
        let (_, _, decoded_auth) = Connect::read(fixed_header, connect_bytes).unwrap();
        assert_eq!(
            decoded_auth,
            ConnectAuth::Password {
                password: Bytes::from_static(b"\x00\xffproto\0buf"),
            }
        );
    }
}