Struct Message 

pub struct Message { /* private fields */ }

Available on crate features dns and std only.

A parsed DNS message header, question section, and answer section.

Parsing deliberately stops after the answer section: the authority and additional sections are never walked, so their records are not validated and any EDNS(0) OPT record they carry is not read. Use MessageHeader::authority_count and MessageHeader::additional_count to see what was skipped.

The result stays close to the wire. Names keep their original case and trailing root label, records keep their declared class and TTL, and no section is capped or deduplicated. Normalisation and limits belong with the caller.

Message::parse is lenient, because a message that goes wrong halfway is still worth what precedes it. Only a message shorter than its fixed header fails outright; a question or answer that cannot be decoded ends the walk and everything before it is kept. Message::is_complete and Message::incomplete_reason report whether the walk ended early and why. A question that fails also ends it before the answer section, whose start is then unknown.

Message::parse_strict instead rejects such a message, and its error still hands back that same partial result through MessageParseError::partial.

Implementations

impl Message

pub fn parse(message: &[u8]) -> Result<Message, MessageParseError>

Parse one borrowed DNS message, keeping what decodes.

Only RDATA that outlives the call is copied. Use Message::parse_bytes when the caller already owns the message as Bytes and wants that RDATA to share its allocation.

pub fn parse_bytes(message: &Bytes) -> Result<Message, MessageParseError>

Parse one owned DNS message, keeping what decodes, without copying its RDATA.

Retained RDATA keeps the whole message allocation alive, which is what a proportionately sized datagram buffer wants. Use Message::parse to copy out of an oversized or reused buffer.

pub fn parse_strict(message: &[u8]) -> Result<Message, MessageParseError>

Parse one borrowed DNS message, rejecting an incomplete result.

A question or answer that Message::parse would stop on is an error here. The error carries everything parsed before it through MessageParseError::partial.

pub fn parse_bytes_strict(message: &Bytes) -> Result<Message, MessageParseError>

Parse one owned DNS message, rejecting an incomplete result, without copying its RDATA.

This is Message::parse_strict with the sharing behaviour of Message::parse_bytes.

pub const fn header(&self) -> &MessageHeader

Return the message’s header.

pub const fn questions(&self) -> &[Question]

Return the message’s questions, in wire order.

This holds fewer entries than MessageHeader::question_count when the walk ended early.

pub const fn answers(&self) -> &[ResourceRecord]

Return the message’s answer records, in wire order.

This holds fewer entries than MessageHeader::answer_count when the walk ended early.

pub const fn is_complete(&self) -> bool

Return whether every question and answer the header declared was parsed.

pub fn incomplete_reason(&self) -> Option<&MessageParseError>

Return what stopped the section walk, when it stopped early.

This is the error Message::parse_strict reports for the same message, without a partial message of its own.

Trait Implementations

impl Clone for Message

fn clone(&self) -> Message

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Message

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

Formats the value using the given formatter.

impl Eq for Message

impl PartialEq for Message

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Message