1#![allow(unused_imports)]
15
16use crate::dm::conformance::{Clause, Condition, Conform, Conformance};
17use crate::dm::meta::{EventPriority, Reporting};
18use crate::dm::spec::{Attribute, Cluster, Command, Event, Feature};
19use crate::dm::{Access, AccessQualities, AttributeQualities, Privilege};
20use crate::error::Result;
21use crate::im::{AttributeId, ClusterId, CommandId, EventId};
22use crate::tlv::{
23 ContainerKind, Element, FromTlv, Nullable, Tag, TlvList, TlvReader, TlvWriter, ToTlv, Value,
24};
25
26pub const ID: ClusterId = 0x003C;
28
29pub const REVISION: u16 = 1;
32
33pub const PICS: &str = "CADMIN";
35
36pub mod feature {
41 pub const BASIC: u32 = 1 << 0;
45}
46
47pub const FEATURES: &[Feature] = &[Feature {
49 bit: 0,
50 code: "BC",
51 name: "Basic",
52 conform: Conform::OPTIONAL,
53}];
54
55pub mod attribute {
57 use crate::im::AttributeId;
58
59 pub const WINDOW_STATUS: AttributeId = 0x00;
61 pub const ADMIN_FABRIC_INDEX: AttributeId = 0x01;
63 pub const ADMIN_VENDOR_ID: AttributeId = 0x02;
65}
66
67pub mod command {
69 use crate::im::CommandId;
70
71 pub const OPEN_COMMISSIONING_WINDOW: CommandId = 0x00;
73 pub const OPEN_BASIC_COMMISSIONING_WINDOW: CommandId = 0x01;
75 pub const REVOKE_COMMISSIONING: CommandId = 0x02;
77}
78
79#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
81#[repr(u8)]
82pub enum CommissioningWindowStatusEnum {
83 WindowNotOpen = 0,
85 EnhancedWindowOpen = 1,
87 BasicWindowOpen = 2,
89}
90
91impl CommissioningWindowStatusEnum {
92 #[must_use]
94 pub const fn from_value(value: u8) -> Option<Self> {
95 match value {
96 0 => Some(Self::WindowNotOpen),
97 1 => Some(Self::EnhancedWindowOpen),
98 2 => Some(Self::BasicWindowOpen),
99 _ => None,
100 }
101 }
102
103 #[must_use]
105 pub const fn value(self) -> u8 {
106 self as u8
107 }
108}
109
110impl ToTlv for CommissioningWindowStatusEnum {
111 fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
112 self.value().to_tlv(w, tag)
113 }
114}
115
116impl<'a> FromTlv<'a> for CommissioningWindowStatusEnum {
117 fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
118 let value = <u8 as FromTlv<'a>>::from_tlv(reader, element)?;
119 Self::from_value(value).ok_or(crate::Error::new(crate::ErrorCode::TlvOutOfRange))
120 }
121}
122
123#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
125#[repr(u8)]
126pub enum StatusCodeEnum {
127 Busy = 2,
129 PAKEParameterError = 3,
131 WindowNotOpen = 4,
133}
134
135impl StatusCodeEnum {
136 #[must_use]
138 pub const fn from_value(value: u8) -> Option<Self> {
139 match value {
140 2 => Some(Self::Busy),
141 3 => Some(Self::PAKEParameterError),
142 4 => Some(Self::WindowNotOpen),
143 _ => None,
144 }
145 }
146
147 #[must_use]
149 pub const fn value(self) -> u8 {
150 self as u8
151 }
152}
153
154impl ToTlv for StatusCodeEnum {
155 fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
156 self.value().to_tlv(w, tag)
157 }
158}
159
160impl<'a> FromTlv<'a> for StatusCodeEnum {
161 fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
162 let value = <u8 as FromTlv<'a>>::from_tlv(reader, element)?;
163 Self::from_value(value).ok_or(crate::Error::new(crate::ErrorCode::TlvOutOfRange))
164 }
165}
166
167#[derive(Debug, Clone, Copy, PartialEq)]
169pub struct OpenCommissioningWindowFields<'a> {
170 pub commissioning_timeout: u16,
172 pub pake_passcode_verifier: &'a [u8],
174 pub discriminator: u16,
176 pub iterations: u32,
178 pub salt: &'a [u8],
180}
181
182impl<'a> ToTlv for OpenCommissioningWindowFields<'a> {
183 fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
184 w.start_structure(tag)?;
185 self.commissioning_timeout.to_tlv(w, Tag::Context(0))?;
186 self.pake_passcode_verifier.to_tlv(w, Tag::Context(1))?;
187 self.discriminator.to_tlv(w, Tag::Context(2))?;
188 self.iterations.to_tlv(w, Tag::Context(3))?;
189 self.salt.to_tlv(w, Tag::Context(4))?;
190 w.end_container()
191 }
192}
193
194impl<'a> FromTlv<'a> for OpenCommissioningWindowFields<'a> {
195 fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
196 if element.value.container() != Some(ContainerKind::Structure) {
197 return Err(crate::Error::new(crate::ErrorCode::TlvWrongType));
198 }
199 let mut commissioning_timeout = None;
200 let mut pake_passcode_verifier = None;
201 let mut discriminator = None;
202 let mut iterations = None;
203 let mut salt = None;
204 loop {
205 let Some(field) = reader.next_element()? else {
206 return Err(crate::Error::new(crate::ErrorCode::TlvTruncated));
207 };
208 if field.value == Value::EndOfContainer {
209 break;
210 }
211 match field.tag.context() {
212 Some(0) => commissioning_timeout = Some(<u16>::from_tlv(reader, &field)?),
213 Some(1) => pake_passcode_verifier = Some(<&'a [u8]>::from_tlv(reader, &field)?),
214 Some(2) => discriminator = Some(<u16>::from_tlv(reader, &field)?),
215 Some(3) => iterations = Some(<u32>::from_tlv(reader, &field)?),
216 Some(4) => salt = Some(<&'a [u8]>::from_tlv(reader, &field)?),
217 _ => reader.skip_value(&field)?,
221 }
222 }
223 Ok(Self {
224 commissioning_timeout: commissioning_timeout
225 .ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
226 pake_passcode_verifier: pake_passcode_verifier
227 .ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
228 discriminator: discriminator.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
229 iterations: iterations.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
230 salt: salt.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
231 })
232 }
233}
234
235#[derive(Debug, Clone, Copy, PartialEq)]
237pub struct OpenBasicCommissioningWindowFields {
238 pub commissioning_timeout: u16,
240}
241
242impl ToTlv for OpenBasicCommissioningWindowFields {
243 fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
244 w.start_structure(tag)?;
245 self.commissioning_timeout.to_tlv(w, Tag::Context(0))?;
246 w.end_container()
247 }
248}
249
250impl<'a> FromTlv<'a> for OpenBasicCommissioningWindowFields {
251 fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
252 if element.value.container() != Some(ContainerKind::Structure) {
253 return Err(crate::Error::new(crate::ErrorCode::TlvWrongType));
254 }
255 let mut commissioning_timeout = None;
256 loop {
257 let Some(field) = reader.next_element()? else {
258 return Err(crate::Error::new(crate::ErrorCode::TlvTruncated));
259 };
260 if field.value == Value::EndOfContainer {
261 break;
262 }
263 match field.tag.context() {
264 Some(0) => commissioning_timeout = Some(<u16>::from_tlv(reader, &field)?),
265 _ => reader.skip_value(&field)?,
269 }
270 }
271 Ok(Self {
272 commissioning_timeout: commissioning_timeout
273 .ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
274 })
275 }
276}
277
278pub const ATTRIBUTES: &[Attribute] = &[
280 Attribute {
281 id: 0x0000,
282 name: "WindowStatus",
283 kind: "CommissioningWindowStatusEnum",
284 access: Access::read_only(Privilege::View),
285 qualities: AttributeQualities::empty(),
286 reporting: Reporting::OnChange,
287 conform: Conform::MANDATORY,
288 },
289 Attribute {
290 id: 0x0001,
291 name: "AdminFabricIndex",
292 kind: "fabric-idx",
293 access: Access::read_only(Privilege::View),
294 qualities: AttributeQualities::NULLABLE,
295 reporting: Reporting::OnChange,
296 conform: Conform::MANDATORY,
297 },
298 Attribute {
299 id: 0x0002,
300 name: "AdminVendorId",
301 kind: "vendor-id",
302 access: Access::read_only(Privilege::View),
303 qualities: AttributeQualities::NULLABLE,
304 reporting: Reporting::OnChange,
305 conform: Conform::MANDATORY,
306 },
307];
308
309pub const COMMANDS: &[Command] = &[
311 Command {
312 id: 0x00,
313 name: "OpenCommissioningWindow",
314 to_server: true,
315 response: None,
316 access: Access::invoke(Privilege::Administer).with_qualities(AccessQualities::TIMED),
317 conform: Conform::MANDATORY,
318 },
319 Command {
320 id: 0x01,
321 name: "OpenBasicCommissioningWindow",
322 to_server: true,
323 response: None,
324 access: Access::invoke(Privilege::Administer).with_qualities(AccessQualities::TIMED),
325 conform: Conform {
326 clauses: &[Clause {
327 verdict: Conformance::Mandatory,
328 when: Condition::Feature(0),
329 }],
330 },
331 },
332 Command {
333 id: 0x02,
334 name: "RevokeCommissioning",
335 to_server: true,
336 response: None,
337 access: Access::invoke(Privilege::Administer).with_qualities(AccessQualities::TIMED),
338 conform: Conform::MANDATORY,
339 },
340];
341
342pub const EVENTS: &[Event] = &[];
344
345pub const CLUSTER: Cluster = Cluster {
347 id: ID,
348 name: "Administrator Commissioning",
349 revision: REVISION,
350 pics: "CADMIN",
351 derived_from: None,
352 features: FEATURES,
353 attributes: ATTRIBUTES,
354 commands: COMMANDS,
355 events: EVENTS,
356};