ezsp 5.0.0

Ember ZNet Serial 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
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278

use le_stream::FromLeStream;

use crate::Callback;
use crate::error::Decode;
use crate::frame::Parameter;
use crate::parameters::{
    binding, bootloader, cbke, green_power, messaging, mfglib, networking, security, trust_center,
    utilities, zll,
};

/// A trait for parsing parameters from a little-endian stream given their frame ID.
pub trait Parsable: Sized {
    /// Parse a parameter from a little-endian stream given its frame ID.
    ///
    /// # Errors
    ///
    /// Returns an [`Error`](crate::error::Error) if the parsing of the parameter failed.
    fn parse_from_le_stream<T>(id: u16, stream: T) -> Result<Self, Decode>
    where
        T: Iterator<Item = u8>;
}

impl<T> Parsable for T
where
    T: Parameter + FromLeStream,
{
    fn parse_from_le_stream<S>(id: u16, stream: S) -> Result<Self, Decode>
    where
        S: Iterator<Item = u8>,
    {
        if Self::ID != id {
            return Err(Decode::FrameIdMismatch {
                expected: Self::ID,
                found: id,
            });
        }

        Ok(Self::from_le_stream_exact(stream)?)
    }
}

impl Parsable for Callback {
    /// Parse a handler from a little-endian stream.
    ///
    /// # Errors
    ///
    /// Returns an error if the frame ID is not recognized.
    #[expect(clippy::too_many_lines)]
    fn parse_from_le_stream<T>(id: u16, stream: T) -> Result<Self, Decode>
    where
        T: Iterator<Item = u8>,
    {
        match id {
            // Binding callbacks.
            binding::handler::RemoteDeleteBinding::ID => Ok(Self::Binding(
                binding::handler::Handler::RemoteDeleteBinding(
                    binding::handler::RemoteDeleteBinding::from_le_stream_exact(stream)?,
                ),
            )),
            binding::handler::RemoteSetBinding::ID => {
                Ok(Self::Binding(binding::handler::Handler::RemoteSetBinding(
                    binding::handler::RemoteSetBinding::from_le_stream_exact(stream)?.into(),
                )))
            }
            // Bootloader callbacks.
            bootloader::handler::BootloadTransmitComplete::ID => Ok(Self::Bootloader(
                bootloader::handler::Handler::BootloadTransmitComplete(
                    bootloader::handler::BootloadTransmitComplete::from_le_stream_exact(stream)?,
                ),
            )),
            bootloader::handler::IncomingBootloadMessage::ID => Ok(Self::Bootloader(
                bootloader::handler::Handler::IncomingBootloadMessage(
                    bootloader::handler::IncomingBootloadMessage::from_le_stream_exact(stream)?,
                ),
            )),
            // Certificate-based key exchange callbacks.
            cbke::handler::CalculateSmacs::ID => {
                Ok(Self::Cbke(cbke::handler::Handler::CalculateSmacs(
                    cbke::handler::CalculateSmacs::from_le_stream_exact(stream)?,
                )))
            }
            cbke::handler::CalculateSmacs283k1::ID => {
                Ok(Self::Cbke(cbke::handler::Handler::CalculateSmacs283k1(
                    cbke::handler::CalculateSmacs283k1::from_le_stream_exact(stream)?,
                )))
            }
            cbke::handler::DsaSign::ID => Ok(Self::Cbke(cbke::handler::Handler::DsaSign(
                cbke::handler::DsaSign::from_le_stream_exact(stream)?.into(),
            ))),
            cbke::handler::DsaVerify::ID => Ok(Self::Cbke(cbke::handler::Handler::DsaVerify(
                cbke::handler::DsaVerify::from_le_stream_exact(stream)?,
            ))),
            cbke::handler::GenerateCbkeKeys::ID => {
                Ok(Self::Cbke(cbke::handler::Handler::GenerateCbkeKeys(
                    cbke::handler::GenerateCbkeKeys::from_le_stream_exact(stream)?,
                )))
            }
            cbke::handler::GenerateCbkeKeys283k1::ID => {
                Ok(Self::Cbke(cbke::handler::Handler::GenerateCbkeKeys283k1(
                    cbke::handler::GenerateCbkeKeys283k1::from_le_stream_exact(stream)?,
                )))
            }
            // Green Power callbacks.
            green_power::handler::IncomingMessage::ID => Ok(Self::GreenPower(
                green_power::handler::Handler::IncomingMessage(
                    green_power::handler::IncomingMessage::from_le_stream_exact(stream)?,
                ),
            )),
            green_power::handler::Sent::ID => {
                Ok(Self::GreenPower(green_power::handler::Handler::Sent(
                    green_power::handler::Sent::from_le_stream_exact(stream)?,
                )))
            }
            // Messaging callbacks.
            messaging::handler::IdConflict::ID => {
                Ok(Self::Messaging(messaging::handler::Handler::IdConflict(
                    messaging::handler::IdConflict::from_le_stream_exact(stream)?,
                )))
            }
            messaging::handler::IncomingManyToOneRouteRequest::ID => Ok(Self::Messaging(
                messaging::handler::Handler::IncomingManyToOneRouteRequest(
                    messaging::handler::IncomingManyToOneRouteRequest::from_le_stream_exact(
                        stream,
                    )?,
                ),
            )),
            messaging::handler::IncomingMessage::ID => Ok(Self::Messaging(
                messaging::handler::Handler::IncomingMessage(
                    messaging::handler::IncomingMessage::from_le_stream_exact(stream)?,
                ),
            )),
            messaging::handler::IncomingNetworkStatus::ID => Ok(Self::Messaging(
                messaging::handler::Handler::IncomingNetworkStatus(
                    messaging::handler::IncomingNetworkStatus::from_le_stream_exact(stream)?,
                ),
            )),
            messaging::handler::IncomingRouteError::ID => Ok(Self::Messaging(
                messaging::handler::Handler::IncomingRouteError(
                    messaging::handler::IncomingRouteError::from_le_stream_exact(stream)?,
                ),
            )),
            messaging::handler::IncomingRouteRecord::ID => Ok(Self::Messaging(
                messaging::handler::Handler::IncomingRouteRecord(
                    messaging::handler::IncomingRouteRecord::from_le_stream_exact(stream)?,
                ),
            )),
            messaging::handler::IncomingSenderEui64::ID => Ok(Self::Messaging(
                messaging::handler::Handler::IncomingSenderEui64(
                    messaging::handler::IncomingSenderEui64::from_le_stream_exact(stream)?,
                ),
            )),
            messaging::handler::MacFilterMatchMessage::ID => Ok(Self::Messaging(
                messaging::handler::Handler::MacFilterMatchMessage(
                    messaging::handler::MacFilterMatchMessage::from_le_stream_exact(stream)?,
                ),
            )),
            messaging::handler::MacPassthroughMessage::ID => Ok(Self::Messaging(
                messaging::handler::Handler::MacPassthroughMessage(
                    messaging::handler::MacPassthroughMessage::from_le_stream_exact(stream)?,
                ),
            )),
            messaging::handler::MessageSent::ID => {
                Ok(Self::Messaging(messaging::handler::Handler::MessageSent(
                    messaging::handler::MessageSent::from_le_stream_exact(stream)?,
                )))
            }
            messaging::handler::Poll::ID => Ok(Self::Messaging(messaging::handler::Handler::Poll(
                messaging::handler::Poll::from_le_stream_exact(stream)?,
            ))),
            messaging::handler::PollComplete::ID => {
                Ok(Self::Messaging(messaging::handler::Handler::PollComplete(
                    messaging::handler::PollComplete::from_le_stream_exact(stream)?,
                )))
            }
            messaging::handler::RawTransmitComplete::ID => Ok(Self::Messaging(
                messaging::handler::Handler::RawTransmitComplete(
                    messaging::handler::RawTransmitComplete::from_le_stream_exact(stream)?,
                ),
            )),
            // MfgLib callbacks.
            mfglib::handler::Rx::ID => Ok(Self::MfgLib(mfglib::handler::Handler::Rx(
                mfglib::handler::Rx::from_le_stream_exact(stream)?,
            ))),
            // Networking callbacks.
            networking::handler::ChildJoin::ID => {
                Ok(Self::Networking(networking::handler::Handler::ChildJoin(
                    networking::handler::ChildJoin::from_le_stream_exact(stream)?,
                )))
            }
            networking::handler::DutyCycle::ID => {
                Ok(Self::Networking(networking::handler::Handler::DutyCycle(
                    networking::handler::DutyCycle::from_le_stream_exact(stream)?,
                )))
            }
            networking::handler::EnergyScanResult::ID => Ok(Self::Networking(
                networking::handler::Handler::EnergyScanResult(
                    networking::handler::EnergyScanResult::from_le_stream_exact(stream)?,
                ),
            )),
            networking::handler::NetworkFound::ID => Ok(Self::Networking(
                networking::handler::Handler::NetworkFound(
                    networking::handler::NetworkFound::from_le_stream_exact(stream)?,
                ),
            )),
            networking::handler::ScanComplete::ID => Ok(Self::Networking(
                networking::handler::Handler::ScanComplete(
                    networking::handler::ScanComplete::from_le_stream_exact(stream)?,
                ),
            )),
            networking::handler::StackStatus::ID => {
                Ok(Self::Networking(networking::handler::Handler::StackStatus(
                    networking::handler::StackStatus::from_le_stream_exact(stream)?,
                )))
            }
            networking::handler::UnusedPanIdFound::ID => Ok(Self::Networking(
                networking::handler::Handler::UnusedPanIdFound(
                    networking::handler::UnusedPanIdFound::from_le_stream_exact(stream)?,
                ),
            )),
            // Security callbacks.
            security::handler::SwitchNetworkKey::ID => Ok(Self::Security(
                security::handler::Handler::SwitchNetworkKey(
                    security::handler::SwitchNetworkKey::from_le_stream_exact(stream)?,
                ),
            )),
            security::handler::ZigbeeKeyEstablishment::ID => Ok(Self::Security(
                security::handler::Handler::ZigbeeKeyEstablishment(
                    security::handler::ZigbeeKeyEstablishment::from_le_stream_exact(stream)?.into(),
                ),
            )),
            // Trust Center callbacks.
            trust_center::handler::TrustCenterJoin::ID => Ok(Self::TrustCenter(
                trust_center::handler::Handler::TrustCenterJoin(
                    trust_center::handler::TrustCenterJoin::from_le_stream_exact(stream)?,
                ),
            )),
            // Utilities callbacks.
            utilities::handler::CounterRollover::ID => Ok(Self::Utilities(
                utilities::handler::Handler::CounterRollover(
                    utilities::handler::CounterRollover::from_le_stream_exact(stream)?,
                ),
            )),
            utilities::handler::CustomFrame::ID => {
                Ok(Self::Utilities(utilities::handler::Handler::CustomFrame(
                    utilities::handler::CustomFrame::from_le_stream_exact(stream)?.into(),
                )))
            }
            utilities::handler::StackTokenChanged::ID => Ok(Self::Utilities(
                utilities::handler::Handler::StackTokenChanged(
                    utilities::handler::StackTokenChanged::from_le_stream_exact(stream)?,
                ),
            )),
            utilities::handler::Timer::ID => {
                Ok(Self::Utilities(utilities::handler::Handler::Timer(
                    utilities::handler::Timer::from_le_stream_exact(stream)?,
                )))
            }
            // ZLL callbacks.
            zll::handler::AddressAssignment::ID => {
                Ok(Self::Zll(zll::handler::Handler::AddressAssignment(
                    zll::handler::AddressAssignment::from_le_stream_exact(stream)?,
                )))
            }
            zll::handler::NetworkFound::ID => Ok(Self::Zll(zll::handler::Handler::NetworkFound(
                zll::handler::NetworkFound::from_le_stream_exact(stream)?,
            ))),
            zll::handler::ScanComplete::ID => Ok(Self::Zll(zll::handler::Handler::ScanComplete(
                zll::handler::ScanComplete::from_le_stream_exact(stream)?,
            ))),
            zll::handler::TouchLinkTarget::ID => {
                Ok(Self::Zll(zll::handler::Handler::TouchLinkTarget(
                    zll::handler::TouchLinkTarget::from_le_stream_exact(stream)?,
                )))
            }
            _ => Err(Decode::InvalidFrameId(id)),
        }
    }
}