tailtalk-packets 0.1.2

Parsers and encoders for AppleTalk packets
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
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

/// Packets encapsulated in LocalTalk Link Access Protocol format. Typically only seen on actual LocalTalk
/// networks but interestingly AsanteTalk (and maybe others) default to this format if they do not see
/// other Ethernet traffic on the port during boot up.
use thiserror::Error;

#[derive(Debug, PartialEq, Eq, Clone, Copy)]
#[repr(u8)]
pub enum LlapType {
    DdpShort = 1,
    DdpLong = 2,
    Enquiry = 0x81,
    Acknowledge = 0x82,
    Other(u8),
}

impl From<u8> for LlapType {
    fn from(orig: u8) -> Self {
        match orig {
            1 => LlapType::DdpShort,
            2 => LlapType::DdpLong,
            0x81 => LlapType::Enquiry,
            0x82 => LlapType::Acknowledge,
            n => LlapType::Other(n),
        }
    }
}

#[derive(Debug)]
pub struct LlapPacket {
    pub dst_node: u8,
    pub src_node: u8,
    pub type_: LlapType,
}

#[derive(Error, Debug)]
pub enum LlapError {
    #[error("packet too short")]
    TooShort,
}

impl LlapPacket {
    pub const LEN: usize = 3;

    pub fn parse(buf: &[u8]) -> Result<Self, LlapError> {
        if buf.len() < Self::LEN {
            return Err(LlapError::TooShort);
        }
        Ok(Self {
            dst_node: buf[0],
            src_node: buf[1],
            type_: buf[2].into(),
        })
    }

    pub fn to_bytes(&self, buf: &mut [u8]) -> Result<usize, LlapError> {
        if buf.len() < Self::LEN {
            return Err(LlapError::TooShort);
        }
        buf[0] = self.dst_node;
        buf[1] = self.src_node;
        buf[2] = match self.type_ {
            LlapType::DdpShort => 1,
            LlapType::DdpLong => 2,
            LlapType::Enquiry => 0x81,
            LlapType::Acknowledge => 0x82,
            LlapType::Other(n) => n,
        };
        Ok(Self::LEN)
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_ethernet() {
        let packet = LlapPacket {
            dst_node: 0x42,
            src_node: 0x24,
            type_: LlapType::DdpShort,
        };
        let mut buf = [0u8; 3];
        let len = packet.to_bytes(&mut buf).unwrap();
        assert_eq!(len, 3);
        assert_eq!(buf, [0x42, 0x24, 1]);

        let parsed = LlapPacket::parse(&buf).unwrap();
        assert_eq!(parsed.dst_node, 0x42);
        assert_eq!(parsed.src_node, 0x24);
        assert_eq!(parsed.type_, LlapType::DdpShort);
    }

    #[test]
    fn test_localtalk_data() {
        let packet = LlapPacket {
            dst_node: 0x42,
            src_node: 0x24,
            type_: LlapType::DdpLong,
        };
        let mut buf = [0u8; 3];
        let len = packet.to_bytes(&mut buf).unwrap();
        assert_eq!(len, 3);
        assert_eq!(buf[0], 0x42);
        assert_eq!(buf[1], 0x24);
        assert_eq!(buf[2], 2);

        let parsed = LlapPacket::parse(&buf).unwrap();
        assert_eq!(parsed.dst_node, 0x42);
        assert_eq!(parsed.src_node, 0x24);
        assert_eq!(parsed.type_, LlapType::DdpLong);
    }

    #[test]
    fn test_localtalk_control() {
        let packet = LlapPacket {
            dst_node: 0xFF,
            src_node: 0x11,
            type_: LlapType::Enquiry, // ENQ
        };
        let mut buf = [0u8; 3];
        let len = packet.to_bytes(&mut buf).unwrap();
        assert_eq!(len, 3);
        assert_eq!(buf, [0xFF, 0x11, 0x81]);

        let parsed = LlapPacket::parse(&buf).unwrap();
        assert_eq!(parsed.dst_node, 0xFF);
        assert_eq!(parsed.src_node, 0x11);
        assert_eq!(parsed.type_, LlapType::Enquiry);
    }
}