ppproto 0.2.1

Point-to-Point Protocol (PPP) for embedded systems. `no-std` compatible, no alloc (heap) required.
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

use num_enum::{FromPrimitive, IntoPrimitive};

use super::option_fsm::{Protocol, Verdict};
use crate::wire::ProtocolType;

#[derive(FromPrimitive, IntoPrimitive, Copy, Clone, Eq, PartialEq, Debug)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[repr(u8)]
enum Option {
    #[num_enum(default)]
    Unknown = 0,
    Asyncmap = 2,
    Auth = 3,
}

#[derive(Copy, Clone, Eq, PartialEq, Debug)]
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
pub enum AuthType {
    None = 0,
    PAP = 0xc023,
}

pub(crate) struct LCP {
    pub auth: AuthType,

    pub asyncmap_remote: u32,
    pub asyncmap: u32,
    pub asyncmap_rej: bool,
}

impl LCP {
    pub fn new() -> Self {
        Self {
            auth: AuthType::None,
            asyncmap_remote: 0xFFFFFFFF,
            asyncmap: 0x00000000,
            asyncmap_rej: false,
        }
    }
}

impl Protocol for LCP {
    fn protocol(&self) -> ProtocolType {
        ProtocolType::LCP
    }

    fn peer_options_start(&mut self) {
        self.auth = AuthType::None;
    }

    fn peer_option_received(&mut self, code: u8, data: &[u8]) -> Verdict {
        let opt = Option::from(code);
        trace!("LCP: rx option {:?} {:?} {:?}", code, opt, data);
        match opt {
            Option::Unknown => Verdict::Rej,
            Option::Asyncmap => {
                if data.len() == 4 {
                    self.asyncmap_remote = u32::from_be_bytes(data.try_into().unwrap());
                    Verdict::Ack
                } else {
                    Verdict::Rej
                }
            }
            Option::Auth => {
                if data == &[0xc0, 0x23] {
                    self.auth = AuthType::PAP;
                    Verdict::Ack
                } else {
                    Verdict::Nack(&[0xc0, 0x23])
                }
            }
        }
    }

    fn own_options(&mut self, mut f: impl FnMut(u8, &[u8])) {
        if !self.asyncmap_rej {
            f(Option::Asyncmap.into(), &self.asyncmap.to_be_bytes());
        }
    }

    fn own_option_nacked(&mut self, code: u8, data: &[u8], is_rej: bool) {
        let opt = Option::from(code);
        trace!("LCP nak {:?} {:?} {:?} {:?}", code, opt, data, is_rej);
        match opt {
            Option::Asyncmap => {
                if !is_rej && data.len() == 4 {
                    self.asyncmap = u32::from_be_bytes(data.try_into().unwrap())
                } else {
                    self.asyncmap_rej = true
                }
            }
            _ => {}
        }
    }
}