Struct Message

pub struct Message {

    pub op: Ops,
    pub htype: HTypes,
    pub hlen: u8,
    pub hops: u8,
    pub xid: u32,
    pub secs: u16,
    pub flags: Flags,
    pub ciaddr: Ipv4Addr,
    pub yiaddr: Ipv4Addr,
    pub siaddr: Ipv4Addr,
    pub giaddr: Ipv4Addr,
    pub chaddr: [u8; 16],
    pub sname: SName,
    pub file: File,
    pub magic: [u8; 4],
    pub options: Vec<MessageOptions>,
}

Wraps all the data sent between DHCP clients and servers.

Formally defined in RFC-2131 as:

                    1                   2                   3
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
|     op (1)    |   htype (1)   |   hlen (1)    |   hops (1)    |
+---------------+---------------+---------------+---------------+
|                            xid (4)                            |
+-------------------------------+-------------------------------+
|           secs (2)            |           flags (2)           |
+-------------------------------+-------------------------------+
|                          ciaddr  (4)                          |
+---------------------------------------------------------------+
|                          yiaddr  (4)                          |
+---------------------------------------------------------------+
|                          siaddr  (4)                          |
+---------------------------------------------------------------+
|                          giaddr  (4)                          |
+---------------------------------------------------------------+
|                          chaddr  (16)                         |
+---------------------------------------------------------------+
|                          sname   (64)                         |
+---------------------------------------------------------------+
|                          file    (128)                        |
+---------------------------------------------------------------+
|                          options (variable)                   |
+---------------------------------------------------------------+

Fields

op: Ops

Message type (not to be confused with a MessageOptions’s MessageTypes)

htype: HTypes

Hardware address type

hlen: u8

Hardware address length

hops: u8

Optionally used by relay agents when booting via a relay agent. Client sets to zero.

xid: u32

The transaction id. A random number chosen by the client. Used by the client and server to associate messages and responses between a client and a server.

secs: u16

Seconds elapsed since client started address acquisition/renewal process. Filled in by client.

flags: Flags

The leftmost bit is defined as the Broadcast flag. The remaining bits are reserved for future use, and must be set to zero by clients and ignored by servers and relay agents.

ciaddr: Ipv4Addr

Client IP address. Only filled in if the client is in BOUND, RENEW, or REBINDING state and can respond to ARP requests.

yiaddr: Ipv4Addr

Your IP address

siaddr: Ipv4Addr

IP address of the next server to use in bootstrap. Returned in DHCPOFFER, DHCPACK by server.

giaddr: Ipv4Addr

Relay agent IP address. Used in booting via a relay agent.

chaddr: [u8; 16]

Client hardware address

If using an ethernet hardware type you can get the value for this field with the mac_address crate. A Client will automatically use mac_address.

sname: SName

Server host name (optional). Null terminated string. 64 bytes in length.

file: File

Boot file name. Null terminated string. Generic name or null in DHCPDISCOVER. Fully qualified directory path name in DHCPOFFER. 128 bytes in length.

magic: [u8; 4]

The first four octets of options field with values 99, 130, 83, 99

options: Vec<MessageOptions>

A variable length field with a minimum of 312 octets. Options use Tag-Length-Value (TLV) encoding, where multi-byte quantities are in network byte order. The last option must be MessageOptions::End

Trait Implementations

impl Debug for Message

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

Formats the value using the given formatter.

impl DecodeMessage for Message

type Op = Ops

The type your custom Message uses to represent the op field.

type Htype = HTypes

The type your custom Message uses to represent the htype field.

type Hlen = u8

The type your custom Message uses to represent the hlen field.

type Hops = u8

The type your custom Message uses to represent the hops field.

type Xid = u32

The type your custom Message uses to represent the xid field.

type Secs = u16

The type your custom Message uses to represent the secs field.

type Flags = Flags

The type your custom Message uses to represent the flags field.

type Ciaddr = Ipv4Addr

The type your custom Message uses to represent the ciaddr field.

type Yiaddr = Ipv4Addr

The type your custom Message uses to represent the yiaddr field.

type Siaddr = Ipv4Addr

The type your custom Message uses to represent the siaddr field.

type Giaddr = Ipv4Addr

The type your custom Message uses to represent the giaddr field.

type Chaddr = [u8; 16]

The type your custom Message uses to represent the chaddr field.

type Sname = SName

The type your custom Message uses to represent the sname field.

type File = File

The type your custom Message uses to represent the file field.

type Magic = [u8; 4]

The type your custom Message uses to represent the magic field.

type Options = Vec<MessageOptions>

The type your custom Message uses to represent the options field.

type Output = Message

Your custom Message.

fn decode_op(op: &[u8]) -> Self::Op

Convert an op field’s byte into your custom Message’s type.

fn decode_htype(htype: &[u8]) -> Self::Htype

Convert an htype field’s byte into your custom Message’s type.

fn decode_hlen(hlen: &[u8]) -> Self::Hlen

Convert an hlen field’s byte into your custom Message’s type.

fn decode_hops(hops: &[u8]) -> Self::Hops

Convert an hops field’s byte into your custom Message’s type.

fn decode_xid(xid: &[u8]) -> Self::Xid

Convert an xid field’s bytes into your custom Message’s type.

fn decode_secs(secs: &[u8]) -> Self::Secs

Convert an secs field’s bytes into your custom Message’s type.

fn decode_flags(flags: &[u8]) -> Self::Flags

Convert an flags field’s bytes into your custom Message’s type.

fn decode_ciaddr(ciaddr: &[u8]) -> Self::Ciaddr

Convert an ciaddr field’s bytes into your custom Message’s type.

fn decode_yiaddr(yiaddr: &[u8]) -> Self::Yiaddr

Convert an yiaddr field’s bytes into your custom Message’s type.

fn decode_siaddr(siaddr: &[u8]) -> Self::Siaddr

Convert an siaddr field’s bytes into your custom Message’s type.

fn decode_giaddr(giaddr: &[u8]) -> Self::Giaddr

Convert an giaddr field’s bytes into your custom Message’s type.

fn decode_chaddr(chaddr: &[u8]) -> Self::Chaddr

Convert an chaddr field’s bytes into your custom Message’s type.

fn decode_sname(sname: &[u8]) -> Self::Sname

Convert an sname field’s bytes into your custom Message’s type.

fn decode_file(file: &[u8]) -> Self::File

Convert an file field’s bytes into your custom Message’s type.

fn decode_magic(_magic: &[u8]) -> Self::Magic

Convert an magic field’s bytes into your custom Message’s type.

fn decode_options(options: &[u8]) -> Self::Options

Convert an options field’s bytes into your custom Message’s type.

fn from_bytes(input: &[u8]) -> Result<Self::Output>

decodes a byte array slice into a Message or other type that implements decodeMessage.

impl EncodeMessage for Message

fn encode_op(&self) -> u8

Represent any data type as the correct amount of op field bytes.

fn encode_htype(&self) -> u8

Represent any data type as the correct amount of htype field bytes.

fn encode_hlen(&self) -> u8

Represent any data type as the correct amount of hlen field bytes.

fn encode_hops(&self) -> u8

Represent any data type as the correct amount of hops field bytes.

fn encode_xid(&self) -> [u8; 4]

Represent any data type as the correct amount of xid field bytes.

fn encode_secs(&self) -> [u8; 2]

Represent any data type as the correct amount of secs field bytes.

fn encode_flags(&self) -> [u8; 2]

Represent any data type as the correct amount of flags field bytes.

fn encode_ciaddr(&self) -> [u8; 4]

Represent any data type as the correct amount of ciaddr field bytes.

fn encode_yiaddr(&self) -> [u8; 4]

Represent any data type as the correct amount of yiaddr field bytes.

fn encode_siaddr(&self) -> [u8; 4]

Represent any data type as the correct amount of siaddr field bytes.

fn encode_giaddr(&self) -> [u8; 4]

Represent any data type as the correct amount of giaddr field bytes.

fn encode_chaddr(&self) -> [u8; 16]

Represent any data type as the correct amount of chaddr field bytes.

fn encode_sname(&self) -> [u8; 64]

Represent any data type as the correct amount of sname field bytes.

fn encode_file(&self) -> [u8; 128]

Represent any data type as the correct amount of file field bytes.

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

Represent any data type as a variable amount of options field bytes.

fn encode_magic(&self) -> [u8; 4]

Automagically defined because its a constant

fn to_bytes(&self) -> Result<Vec<u8>>

Encodes a Message into a Vec of bytes by calling the encode_* methods defined in EncodeMessage, and uses a Encoder to store the output.

impl MessageHelpers for Message

fn find_option(&self, tag: u8) -> Option<&MessageOptions>

Search this Message’s list of options for a specific option.

fn add_option(&mut self, option: MessageOptions)

Add an option to the list of options, and ensure that it is added before MessageOptions::End.

fn get_mac_address(&self) -> MacAddress

Parses the chaddr field as a mac address.

impl PartialEq for Message

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

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

const 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 Deliverable for Message

impl StructuralPartialEq for Message