Struct Connack 

pub struct Connack {
    pub props: Properties,
    /* private fields */
}

MQTT 5.0 CONNACK packet representation

The CONNACK packet is sent by the MQTT server (broker) in response to a CONNECT packet from a client. It indicates whether the connection attempt was successful and provides various connection-related parameters and capabilities.

According to MQTT 5.0 specification, the CONNACK packet contains:

• Fixed header with packet type and remaining length
• Variable header with acknowledgment flags, reason code, and properties
• No payload

Acknowledgment Flags

The acknowledgment flags byte contains:

• Session Present flag (bit 0): Indicates whether the server has stored session state from a previous connection. Set to 1 if the server has session state, 0 if starting a clean session.
• Bits 1-7: Reserved and must be set to 0

Reason Codes

The reason code indicates the result of the connection attempt:

• 0x00 Success - Connection accepted
• 0x80 Unspecified error
• 0x81 Malformed packet
• 0x82 Protocol error
• 0x83 Implementation specific error
• 0x84 Unsupported protocol version
• 0x85 Client identifier not valid
• 0x86 Bad username or password
• 0x87 Not authorized
• 0x88 Server unavailable
• 0x89 Server busy
• 0x8A Banned
• 0x8C Bad authentication method
• 0x90 Topic name invalid
• 0x95 Packet too large
• 0x97 Quota exceeded
• 0x99 Payload format invalid
• 0x9A Retain not supported
• 0x9B QoS not supported
• 0x9C Use another server
• 0x9D Server moved
• 0x9F Connection rate exceeded

Properties

MQTT 5.0 CONNACK packets can include various properties:

• Session Expiry Interval
• Receive Maximum
• Maximum QoS
• Retain Available
• Maximum Packet Size
• Assigned Client Identifier
• Topic Alias Maximum
• Reason String
• User Properties
• Wildcard Subscription Available
• Subscription Identifiers Available
• Shared Subscription Available
• Server Keep Alive
• Response Information
• Server Reference
• Authentication Method
• Authentication Data

Examples

use mqtt_protocol_core::mqtt;
use mqtt_protocol_core::mqtt::result_code::ConnectReasonCode;

// Create a successful CONNACK with clean session
let connack = mqtt::packet::v5_0::Connack::builder()
    .session_present(false)
    .reason_code(ConnectReasonCode::Success)
    .build()
    .unwrap();

assert_eq!(connack.reason_code(), ConnectReasonCode::Success);
assert!(!connack.session_present());

// Create CONNACK with session present and properties
let props = mqtt::packet::Properties::new();
let connack = mqtt::packet::v5_0::Connack::builder()
    .session_present(true)
    .reason_code(ConnectReasonCode::Success)
    .props(props)
    .build()
    .unwrap();

// Serialize to bytes for network transmission
let buffers = connack.to_buffers();

Fields

props: Properties

Implementations

impl Connack

pub fn props(&self) -> &Properties

impl Connack

pub fn builder() -> ConnackBuilder

Create a new ConnackBuilder for constructing CONNACK packets

Returns a builder instance that allows setting the various fields of a CONNACK packet in a fluent interface style. The builder ensures all required fields are set before creating the final packet.

Returns

A new ConnackBuilder instance

Examples

use mqtt_protocol_core::mqtt;
use mqtt_protocol_core::mqtt::result_code::ConnectReasonCode;

let connack = mqtt::packet::v5_0::Connack::builder()
    .session_present(false)
    .reason_code(ConnectReasonCode::Success)
    .build()
    .unwrap();

pub fn packet_type() -> PacketType

Get the packet type for CONNACK packets

Returns the constant packet type identifier for CONNACK packets. This is always PacketType::Connack for CONNACK packets.

Returns

The packet type PacketType::Connack

Examples

use mqtt_protocol_core::mqtt;
use mqtt_protocol_core::mqtt::packet::packet_type::PacketType;

assert_eq!(mqtt::packet::v5_0::Connack::packet_type(), PacketType::Connack);

pub fn session_present(&self) -> bool

Get the session present flag

Returns true if the server has stored session state for this client from a previous connection, false if this is a clean session or no session state exists. This corresponds to bit 0 of the acknowledgment flags byte.

Returns

true if session state is present, false for a clean session

Examples

use mqtt_protocol_core::mqtt;
use mqtt_protocol_core::mqtt::result_code::ConnectReasonCode;

let connack = mqtt::packet::v5_0::Connack::builder()
    .session_present(true)
    .reason_code(ConnectReasonCode::Success)
    .build()
    .unwrap();

assert!(connack.session_present());

pub fn reason_code(&self) -> ConnectReasonCode

Get the reason code from the CONNACK packet

Returns the reason code that indicates the result of the connection attempt. The reason code provides detailed information about whether the connection was successful or failed, and if failed, the specific reason for failure.

Returns

The ConnectReasonCode indicating the connection result

Examples

use mqtt_protocol_core::mqtt;
use mqtt_protocol_core::mqtt::result_code::ConnectReasonCode;

let connack = mqtt::packet::v5_0::Connack::builder()
    .session_present(false)
    .reason_code(ConnectReasonCode::Success)
    .build()
    .unwrap();

assert_eq!(connack.reason_code(), ConnectReasonCode::Success);

pub fn size(&self) -> usize

Get the total size of the CONNACK packet in bytes

Returns the complete size of the CONNACK packet including the fixed header, variable header, and all properties. This is useful for memory allocation and buffer management.

Returns

The total packet size in bytes

Examples

use mqtt_protocol_core::mqtt;
use mqtt_protocol_core::mqtt::result_code::ConnectReasonCode;

let connack = mqtt::packet::v5_0::Connack::builder()
    .session_present(false)
    .reason_code(ConnectReasonCode::Success)
    .build()
    .unwrap();

let size = connack.size();
// Size includes fixed header + variable header + properties

pub fn to_buffers(&self) -> Vec<IoSlice<'_>>

Create IoSlice buffers for efficient network I/O

Returns a vector of IoSlice objects that can be used for vectored I/O operations, allowing zero-copy writes to network sockets. The buffers represent the complete CONNACK packet in wire format.

Returns

A vector of IoSlice objects for vectored I/O operations

Examples

use mqtt_protocol_core::mqtt;
use mqtt_protocol_core::mqtt::result_code::ConnectReasonCode;

let connack = mqtt::packet::v5_0::Connack::builder()
    .session_present(false)
    .reason_code(ConnectReasonCode::Success)
    .build()
    .unwrap();

let buffers = connack.to_buffers();
// Use with vectored write: socket.write_vectored(&buffers)?;

pub fn to_continuous_buffer(&self) -> Vec<u8>

Create a continuous buffer containing the complete packet data

Returns a vector containing all packet bytes in a single continuous buffer. This method provides an alternative to to_buffers() for no-std environments where vectored I/O is not available.

The returned buffer contains the complete CONNACK packet serialized according to the MQTT v5.0 protocol specification, including fixed header, remaining length, acknowledgment flags, reason code, property length, and properties.

Returns

A vector containing the complete packet data

Examples

use mqtt_protocol_core::mqtt;
use mqtt_protocol_core::mqtt::result_code::ConnectReasonCode;

let connack = mqtt::packet::v5_0::Connack::builder()
    .session_present(false)
    .reason_code(ConnectReasonCode::Success)
    .build()
    .unwrap();

let buffer = connack.to_continuous_buffer();
// buffer contains all packet bytes

pub fn parse(data: &[u8]) -> Result<(Self, usize), MqttError>

Parse a CONNACK packet from raw bytes

Decodes a CONNACK packet from a byte buffer according to the MQTT 5.0 protocol specification. The buffer should contain the variable header and any properties, but not the fixed header (which should have been processed separately).

The parsing process:

1. Reads acknowledgment flags (1 byte)
2. Reads reason code (1 byte)
3. Parses properties section
4. Validates the packet structure and properties

Parameters

• data - Byte buffer containing the CONNACK packet data (without fixed header)

Returns

• Ok((Connack, bytes_consumed)) - Successfully parsed packet and number of bytes consumed
• Err(MqttError::MalformedPacket) - If the buffer is malformed or too short
• Err(MqttError::ProtocolError) - If the packet contains invalid properties

Examples

use mqtt_protocol_core::mqtt;

// Buffer contains: [flags, reason_code, prop_length, ...properties]
let buffer = &[0x00, 0x00, 0x00]; // No session, success, no properties
let (connack, consumed) = mqtt::packet::v5_0::Connack::parse(buffer).unwrap();

assert!(!connack.session_present());
assert_eq!(consumed, 3);

Trait Implementations

impl Clone for Connack

fn clone(&self) -> Connack

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Connack

Implementation of Debug trait for debugging output

Uses the same JSON formatting as Display for consistent debugging output. This provides detailed, structured information about the CONNACK packet state.

Examples

use mqtt_protocol_core::mqtt;
use mqtt_protocol_core::mqtt::result_code::ConnectReasonCode;

let connack = mqtt::packet::v5_0::Connack::builder()
    .session_present(false)
    .reason_code(ConnectReasonCode::BadUserNameOrPassword)
    .build()
    .unwrap();

println!("{:?}", connack);
// Output: {"type":"CONNACK","session_present":false,"reason_code":"BadUserNameOrPassword","props":{}}

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for Connack

Implementation of Display trait for human-readable output

Formats the CONNACK packet as a JSON string for easy reading and debugging. If serialization fails, it returns an error message in JSON format.

Examples

use mqtt_protocol_core::mqtt;
use mqtt_protocol_core::mqtt::result_code::ConnectReasonCode;

let connack = mqtt::packet::v5_0::Connack::builder()
    .session_present(true)
    .reason_code(ConnectReasonCode::Success)
    .build()
    .unwrap();

println!("{}", connack);
// Output: {"type":"CONNACK","session_present":true,"reason_code":"Success","props":{}}

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<PacketIdType> From<Connack> for GenericPacket<PacketIdType>

where PacketIdType: IsPacketId + Serialize,

fn from(v: Connack) -> GenericPacket<PacketIdType>

Converts to this type from the input type.

impl GenericPacketDisplay for Connack

Implementation of GenericPacketDisplay for generic formatting operations

Provides a common interface for formatting operations that can be used generically across different MQTT packet types. This enables uniform display handling in collections and generic contexts.

Methods

• fmt_debug(): Delegates to the Debug trait implementation
• fmt_display(): Delegates to the Display trait implementation

Examples

use mqtt_protocol_core::mqtt;
use mqtt_protocol_core::mqtt::packet::GenericPacketDisplay;
use mqtt_protocol_core::mqtt::result_code::ConnectReasonCode;

let connack = mqtt::packet::v5_0::Connack::builder()
    .session_present(false)
    .reason_code(ConnectReasonCode::Success)
    .build()
    .unwrap();

// Use generic display methods
println!("{}", format_args!("{}", connack)); // Uses fmt_display

fn fmt_debug(&self, f: &mut Formatter<'_>) -> Result

fn fmt_display(&self, f: &mut Formatter<'_>) -> Result

impl GenericPacketTrait for Connack

Implementation of GenericPacketTrait for generic packet operations

Provides a common interface for packet operations that can be used generically across different MQTT packet types. This allows for uniform handling of packets in collections and generic contexts.

Methods

• size(): Returns the total packet size in bytes
• to_buffers(): Returns IoSlice buffers for efficient network I/O

Examples

use mqtt_protocol_core::mqtt;
use mqtt_protocol_core::mqtt::packet::GenericPacketTrait;
use mqtt_protocol_core::mqtt::result_code::ConnectReasonCode;

let connack = mqtt::packet::v5_0::Connack::builder()
    .session_present(false)
    .reason_code(ConnectReasonCode::Success)
    .build()
    .unwrap();

// Use generic trait methods
let size = connack.size();
let buffers = connack.to_buffers();

fn size(&self) -> usize

fn to_buffers(&self) -> Vec<IoSlice<'_>>

fn to_continuous_buffer(&self) -> Vec<u8>

Create a continuous buffer containing the complete packet data

impl PacketKind for Connack

PacketKind implementation for v5.0 CONNACK packet

const IS_CONNACK: bool = true

true if this is a CONNACK packet

const IS_V5_0: bool = true

true if this is an MQTT v5.0 packet

const IS_CONNECT: bool = false

true if this is a CONNECT packet

const IS_PUBLISH: bool = false

true if this is a PUBLISH packet

const IS_PUBACK: bool = false

true if this is a PUBACK packet

const IS_PUBREC: bool = false

true if this is a PUBREC packet

const IS_PUBREL: bool = false

true if this is a PUBREL packet

const IS_PUBCOMP: bool = false

true if this is a PUBCOMP packet

const IS_SUBSCRIBE: bool = false

true if this is a SUBSCRIBE packet

const IS_SUBACK: bool = false

true if this is a SUBACK packet

const IS_UNSUBSCRIBE: bool = false

true if this is an UNSUBSCRIBE packet

const IS_UNSUBACK: bool = false

true if this is an UNSUBACK packet

const IS_PINGREQ: bool = false

true if this is a PINGREQ packet

const IS_PINGRESP: bool = false

true if this is a PINGRESP packet

const IS_DISCONNECT: bool = false

true if this is a DISCONNECT packet

const IS_AUTH: bool = false

true if this is an AUTH packet (v5.0 only)

const IS_V3_1_1: bool = false

true if this is an MQTT v3.1.1 packet

impl PartialEq for Connack

fn eq(&self, other: &Connack) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Connack

Implementation of Serialize trait for JSON serialization

Serializes the CONNACK packet to a structured format containing:

• type: The packet type as a string (“CONNACK”)
• session_present: Boolean indicating session state
• reason_code: The connection result reason code
• props: MQTT 5.0 properties (if any)

Examples

use mqtt_protocol_core::mqtt;
use mqtt_protocol_core::mqtt::result_code::ConnectReasonCode;

let connack = mqtt::packet::v5_0::Connack::builder()
    .session_present(false)
    .reason_code(ConnectReasonCode::Success)
    .build()
    .unwrap();

let json = serde_json::to_string(&connack).unwrap();
// Produces: {"type":"CONNACK","session_present":false,"reason_code":"Success","props":{}}

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<PacketIdType> TryInto<Connack> for GenericPacket<PacketIdType>

where PacketIdType: IsPacketId + Serialize,

type Error = &'static str

The type returned in the event of a conversion error.

fn try_into(self) -> Result<Connack, <Self as TryInto<Connack>>::Error>

Performs the conversion.

impl Eq for Connack

impl SendableRole<Any> for Connack

impl SendableRole<Server> for Connack

impl StructuralPartialEq for Connack