mozim 0.3.2

DHCP Client Library
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

// SPDX-License-Identifier: Apache-2.0

use std::{os::fd::OwnedFd, time::Duration};

use nix::sys::{
    time::TimeSpec,
    timerfd::{
        ClockId::CLOCK_BOOTTIME, Expiration, TimerFd, TimerFlags,
        TimerSetTimeFlags,
    },
};
use tokio::io::unix::AsyncFd;

use crate::{DhcpError, ErrorKind};

/// Timer depend on CLOCK_BOOTTIME so it continue ticks when system
/// sleeps/hibernates.
#[derive(Debug)]
pub(crate) struct DhcpTimer {
    pub(crate) end: TimeSpec,
}

impl DhcpTimer {
    pub(crate) fn new(time: Duration) -> Result<Self, DhcpError> {
        let end = boot_time_now()? + TimeSpec::from_duration(time);
        Ok(Self { end })
    }

    pub(crate) async fn wait(&self) -> Result<(), DhcpError> {
        let remains = self.remains()?;
        if !remains.is_zero() {
            let fd = TimerFd::new(CLOCK_BOOTTIME, TimerFlags::TFD_NONBLOCK)
                .map_err(|e| {
                    let e = DhcpError::new(
                        ErrorKind::Bug,
                        format!("Failed to create timerfd {e}"),
                    );
                    log::error!("{e}");
                    e
                })?;
            fd.set(
                Expiration::OneShot(TimeSpec::from_duration(remains)),
                TimerSetTimeFlags::empty(),
            )
            .map_err(|e| {
                let e = DhcpError::new(
                    ErrorKind::Bug,
                    format!("Failed to set timerfd {e}"),
                );
                log::error!("{e}");
                e
            })?;
            log::debug!(
                "DHCP timer created {:?} with {} seconds {} milliseconds",
                fd,
                remains.as_secs(),
                remains.subsec_millis(),
            );
            let _ = AsyncFd::new(OwnedFd::from(fd))?.readable().await?;
        }
        Ok(())
    }

    pub(crate) fn remains(&self) -> Result<Duration, DhcpError> {
        let now = boot_time_now()?;
        if self.end > now {
            Ok((self.end - now).into())
        } else {
            Ok(Duration::ZERO)
        }
    }
}

fn boot_time_now() -> Result<TimeSpec, DhcpError> {
    nix::time::clock_gettime(nix::time::ClockId::CLOCK_BOOTTIME).map_err(|e| {
        DhcpError::new(
            ErrorKind::Bug,
            format!("Failed to retrieve CLOCK_BOOTTIME: {e}"),
        )
    })
}