edge-dhcp 0.7.0

Async + `no_std` + no-alloc implementation of the DHCP protocol
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

use rand_core::RngCore;

use super::*;

/// A simple DHCP client.
/// The client is unaware of the IP/UDP transport layer and operates purely in terms of packets
/// represented as Rust slices.
///
/// As such, the client can generate all BOOTP requests and parse BOOTP replies.
pub struct Client<T> {
    pub rng: T,
    pub mac: [u8; 6],
}

impl<T> Client<T>
where
    T: RngCore,
{
    pub const fn new(rng: T, mac: [u8; 6]) -> Self {
        Self { rng, mac }
    }

    pub fn discover<'o>(
        &mut self,
        opt_buf: &'o mut [DhcpOption<'o>],
        secs: u16,
        ip: Option<Ipv4Addr>,
    ) -> (Packet<'o>, u32) {
        self.bootp_request(secs, None, true, Options::discover(ip, opt_buf))
    }

    pub fn request<'o>(
        &mut self,
        opt_buf: &'o mut [DhcpOption<'o>],
        secs: u16,
        ip: Ipv4Addr,
        broadcast: bool,
    ) -> (Packet<'o>, u32) {
        self.bootp_request(secs, None, broadcast, Options::request(ip, opt_buf))
    }

    pub fn release<'o>(
        &mut self,
        opt_buf: &'o mut [DhcpOption<'o>],
        secs: u16,
        ip: Ipv4Addr,
    ) -> Packet<'o> {
        self.bootp_request(secs, Some(ip), false, Options::release(opt_buf))
            .0
    }

    pub fn decline<'o>(
        &mut self,
        opt_buf: &'o mut [DhcpOption<'o>],
        secs: u16,
        ip: Ipv4Addr,
    ) -> Packet<'o> {
        self.bootp_request(secs, Some(ip), false, Options::decline(opt_buf))
            .0
    }

    pub fn is_offer(&self, reply: &Packet<'_>, xid: u32) -> bool {
        self.is_bootp_reply_for_us(reply, xid, Some(&[MessageType::Offer]))
    }

    pub fn is_ack(&self, reply: &Packet<'_>, xid: u32) -> bool {
        self.is_bootp_reply_for_us(reply, xid, Some(&[MessageType::Ack]))
    }

    pub fn is_nak(&self, reply: &Packet<'_>, xid: u32) -> bool {
        self.is_bootp_reply_for_us(reply, xid, Some(&[MessageType::Nak]))
    }

    #[allow(clippy::too_many_arguments)]
    pub fn bootp_request<'o>(
        &mut self,
        secs: u16,
        ip: Option<Ipv4Addr>,
        broadcast: bool,
        options: Options<'o>,
    ) -> (Packet<'o>, u32) {
        let xid = self.rng.next_u32();

        (
            Packet::new_request(self.mac, xid, secs, ip, broadcast, options),
            xid,
        )
    }

    pub fn is_bootp_reply_for_us(
        &self,
        reply: &Packet<'_>,
        xid: u32,
        expected_message_types: Option<&[MessageType]>,
    ) -> bool {
        if reply.reply && reply.is_for_us(&self.mac, xid) {
            if let Some(expected_message_types) = expected_message_types {
                let mt = reply.options.iter().find_map(|option| {
                    if let DhcpOption::MessageType(mt) = option {
                        Some(mt)
                    } else {
                        None
                    }
                });

                expected_message_types.iter().any(|emt| mt == Some(*emt))
            } else {
                true
            }
        } else {
            false
        }
    }
}