1use crate::error::{Error, ErrorCode, Result, bail};
24use crate::im::ib::{
25 AttributeData, AttributeReport, CommandData, DataVersionFilter, EventFilter, InvokeResponse,
26};
27use crate::im::path::{AttributePath, EventPath};
28use crate::im::status::Status;
29use crate::tlv::{ContainerKind, Element, Tag, TlvReader, TlvWriter, Value, set_once};
30
31pub const REVISION_TAG: u8 = 0xFF;
33
34pub const INTERACTION_MODEL_REVISION: u16 = 13;
37
38pub mod opcode {
40 pub const STATUS_RESPONSE: u8 = 0x01;
42 pub const READ_REQUEST: u8 = 0x02;
44 pub const SUBSCRIBE_REQUEST: u8 = 0x03;
46 pub const SUBSCRIBE_RESPONSE: u8 = 0x04;
48 pub const REPORT_DATA: u8 = 0x05;
50 pub const WRITE_REQUEST: u8 = 0x06;
52 pub const WRITE_RESPONSE: u8 = 0x07;
54 pub const INVOKE_REQUEST: u8 = 0x08;
56 pub const INVOKE_RESPONSE: u8 = 0x09;
58 pub const TIMED_REQUEST: u8 = 0x0A;
60}
61
62fn open(buf: &[u8]) -> Result<TlvReader<'_>> {
64 let mut reader = TlvReader::new(buf);
65 let Some(head) = reader.next_element()? else {
66 bail!(TlvTruncated)
67 };
68 if head.value.container() != Some(ContainerKind::Structure) || !head.tag.is_anonymous() {
69 bail!(TlvWrongType)
70 }
71 Ok(reader)
72}
73
74fn take_array<'a>(
76 reader: &mut TlvReader<'a>,
77 element: &Element<'a>,
78 start: usize,
79) -> Result<&'a [u8]> {
80 if element.value.container() != Some(ContainerKind::Array) {
81 bail!(TlvWrongType)
82 }
83 reader.skip_value(element)?;
84 reader.slice_from(start)
85}
86
87#[derive(Debug, Clone)]
95pub struct ArrayIter<'a, T> {
96 reader: TlvReader<'a>,
97 done: bool,
98 member: ContainerKind,
99 decode: fn(&mut TlvReader<'a>) -> Result<T>,
100}
101
102impl<'a, T> ArrayIter<'a, T> {
103 pub(crate) fn new(
105 bytes: &'a [u8],
106 member: ContainerKind,
107 decode: fn(&mut TlvReader<'a>) -> Result<T>,
108 ) -> Result<Self> {
109 let mut reader = TlvReader::new_in(bytes, ContainerKind::Structure);
112 let Some(head) = reader.next_element()? else {
113 bail!(TlvTruncated)
114 };
115 if head.value.container() != Some(ContainerKind::Array) {
116 bail!(TlvWrongType)
117 }
118 Ok(Self {
119 reader,
120 done: false,
121 member,
122 decode,
123 })
124 }
125}
126
127impl<'a, T> Iterator for ArrayIter<'a, T> {
128 type Item = Result<T>;
129
130 fn next(&mut self) -> Option<Self::Item> {
131 if self.done {
132 return None;
133 }
134 let element = match self.reader.next_element() {
135 Ok(Some(element)) => element,
136 Ok(None) => {
137 self.done = true;
138 return None;
139 }
140 Err(e) => {
141 self.done = true;
142 return Some(Err(e));
143 }
144 };
145 if element.value == Value::EndOfContainer {
146 self.done = true;
147 return None;
148 }
149 if element.value.container() != Some(self.member) || !element.tag.is_anonymous() {
152 self.done = true;
153 return Some(Err(Error::new(ErrorCode::TlvWrongType)));
154 }
155 let out = (self.decode)(&mut self.reader);
156 if out.is_err() {
157 self.done = true;
158 }
159 Some(out)
160 }
161}
162
163fn write_revision(w: &mut TlvWriter<'_>) -> Result<()> {
165 w.unsigned(
166 Tag::Context(REVISION_TAG),
167 u64::from(INTERACTION_MODEL_REVISION),
168 )
169}
170
171#[derive(Debug, Clone, Copy, PartialEq, Eq)]
175pub struct StatusResponse {
176 pub status: Status,
178 pub revision: Option<u16>,
180}
181
182impl StatusResponse {
183 #[must_use]
185 pub const fn new(status: Status) -> Self {
186 Self {
187 status,
188 revision: Some(INTERACTION_MODEL_REVISION),
189 }
190 }
191
192 pub fn encode<'b>(&self, buf: &'b mut [u8]) -> Result<&'b [u8]> {
194 let mut w = TlvWriter::new(buf);
195 w.start_structure(Tag::Anonymous)?;
196 w.unsigned(Tag::Context(0), u64::from(self.status.value()))?;
197 write_revision(&mut w)?;
198 w.end_container()?;
199 w.finish()
200 }
201
202 pub fn decode(buf: &[u8]) -> Result<Self> {
204 let mut reader = open(buf)?;
205 let mut status = None;
206 let mut revision = None;
207 loop {
208 let Some(element) = reader.next_element()? else {
209 bail!(TlvTruncated)
210 };
211 if element.value == Value::EndOfContainer {
212 break;
213 }
214 match element.tag.context() {
215 Some(0) => set_once(
216 &mut status,
217 Status::from_value(
218 u8::try_from(element.unsigned()?)
219 .map_err(|_| Error::new(ErrorCode::TlvOutOfRange))?,
220 ),
221 )?,
222 Some(REVISION_TAG) => set_once(&mut revision, narrow16(element.unsigned()?)?)?,
223 _ => reader.skip_value(&element)?,
224 }
225 }
226 reader.finish()?;
227 Ok(Self {
228 status: status.ok_or(Error::new(ErrorCode::TlvNotFound))?,
229 revision,
230 })
231 }
232}
233
234#[derive(Debug, Clone, Copy, PartialEq, Eq)]
238pub struct ReadRequest<'a> {
239 attribute_requests: Option<&'a [u8]>,
240 event_requests: Option<&'a [u8]>,
241 event_filters: Option<&'a [u8]>,
242 data_version_filters: Option<&'a [u8]>,
243 pub fabric_filtered: bool,
246 pub revision: Option<u16>,
248}
249
250impl<'a> ReadRequest<'a> {
251 pub fn attribute_paths(&self) -> Result<Option<ArrayIter<'a, AttributePath>>> {
253 self.attribute_requests
254 .map(|bytes| ArrayIter::new(bytes, ContainerKind::List, path_from_list))
255 .transpose()
256 }
257
258 pub fn event_paths(&self) -> Result<Option<ArrayIter<'a, EventPath>>> {
260 self.event_requests
261 .map(|bytes| ArrayIter::new(bytes, ContainerKind::List, event_path_from_list))
262 .transpose()
263 }
264
265 #[must_use]
268 pub const fn event_filters_raw(&self) -> Option<&'a [u8]> {
269 self.event_filters
270 }
271
272 pub fn event_filters(&self) -> Result<Option<ArrayIter<'a, EventFilter>>> {
274 self.event_filters
275 .map(|bytes| ArrayIter::new(bytes, ContainerKind::Structure, EventFilter::decode))
276 .transpose()
277 }
278
279 #[must_use]
282 pub const fn data_version_filters_raw(&self) -> Option<&'a [u8]> {
283 self.data_version_filters
284 }
285
286 pub fn data_version_filters(&self) -> Result<Option<ArrayIter<'a, DataVersionFilter>>> {
288 self.data_version_filters
289 .map(|bytes| ArrayIter::new(bytes, ContainerKind::Structure, DataVersionFilter::decode))
290 .transpose()
291 }
292
293 pub fn decode(buf: &'a [u8]) -> Result<Self> {
295 let mut reader = open(buf)?;
296 let mut attribute_requests = None;
297 let mut event_requests = None;
298 let mut event_filters = None;
299 let mut data_version_filters = None;
300 let mut fabric_filtered = None;
301 let mut revision = None;
302
303 loop {
304 let start = reader.position();
305 let Some(element) = reader.next_element()? else {
306 bail!(TlvTruncated)
307 };
308 if element.value == Value::EndOfContainer {
309 break;
310 }
311 match element.tag.context() {
312 Some(0) => set_once(
313 &mut attribute_requests,
314 take_array(&mut reader, &element, start)?,
315 )?,
316 Some(1) => set_once(
317 &mut event_requests,
318 take_array(&mut reader, &element, start)?,
319 )?,
320 Some(2) => {
321 set_once(
322 &mut event_filters,
323 take_array(&mut reader, &element, start)?,
324 )?;
325 }
326 Some(3) => set_once(&mut fabric_filtered, element.bool()?)?,
327 Some(4) => set_once(
328 &mut data_version_filters,
329 take_array(&mut reader, &element, start)?,
330 )?,
331 Some(REVISION_TAG) => set_once(&mut revision, narrow16(element.unsigned()?)?)?,
332 _ => reader.skip_value(&element)?,
333 }
334 }
335 reader.finish()?;
336
337 Ok(Self {
338 attribute_requests,
339 event_requests,
340 event_filters,
341 data_version_filters,
342 fabric_filtered: fabric_filtered.ok_or(Error::new(ErrorCode::TlvNotFound))?,
345 revision,
346 })
347 }
348}
349
350pub fn encode_read_request<A, E>(
355 buf: &mut [u8],
356 attribute_paths: A,
357 event_paths: E,
358 fabric_filtered: bool,
359) -> Result<&[u8]>
360where
361 A: IntoIterator<Item = AttributePath>,
362 E: IntoIterator<Item = EventPath>,
363{
364 let mut w = TlvWriter::new(buf);
365 w.start_structure(Tag::Anonymous)?;
366
367 let mut attributes = attribute_paths.into_iter().peekable();
368 if attributes.peek().is_some() {
369 w.start_array(Tag::Context(0))?;
370 for path in attributes {
371 path.encode(&mut w, Tag::Anonymous)?;
372 }
373 w.end_container()?;
374 }
375
376 let mut events = event_paths.into_iter().peekable();
377 if events.peek().is_some() {
378 w.start_array(Tag::Context(1))?;
379 for path in events {
380 path.encode(&mut w, Tag::Anonymous)?;
381 }
382 w.end_container()?;
383 }
384
385 w.bool(Tag::Context(3), fabric_filtered)?;
386 write_revision(&mut w)?;
387 w.end_container()?;
388 w.finish()
389}
390
391pub fn encode_subscribe_request<A, E>(
402 buf: &mut [u8],
403 attribute_paths: A,
404 event_paths: E,
405 min_interval_floor_s: u16,
406 max_interval_ceiling_s: u16,
407 keep_subscriptions: bool,
408 fabric_filtered: bool,
409) -> Result<&[u8]>
410where
411 A: IntoIterator<Item = AttributePath>,
412 E: IntoIterator<Item = EventPath>,
413{
414 let mut w = TlvWriter::new(buf);
415 w.start_structure(Tag::Anonymous)?;
416 w.bool(Tag::Context(0), keep_subscriptions)?;
417 w.unsigned(Tag::Context(1), u64::from(min_interval_floor_s))?;
418 w.unsigned(Tag::Context(2), u64::from(max_interval_ceiling_s))?;
419
420 let mut attributes = attribute_paths.into_iter().peekable();
421 if attributes.peek().is_some() {
422 w.start_array(Tag::Context(3))?;
423 for path in attributes {
424 path.encode(&mut w, Tag::Anonymous)?;
425 }
426 w.end_container()?;
427 }
428
429 let mut events = event_paths.into_iter().peekable();
430 if events.peek().is_some() {
431 w.start_array(Tag::Context(4))?;
432 for path in events {
433 path.encode(&mut w, Tag::Anonymous)?;
434 }
435 w.end_container()?;
436 }
437
438 w.bool(Tag::Context(7), fabric_filtered)?;
439 write_revision(&mut w)?;
440 w.end_container()?;
441 w.finish()
442}
443
444#[derive(Debug, Clone, Copy, PartialEq, Eq)]
448pub struct ReportData<'a> {
449 pub subscription_id: Option<u32>,
451 attribute_reports: Option<&'a [u8]>,
452 event_reports: Option<&'a [u8]>,
453 pub more_chunked_messages: bool,
455 pub suppress_response: bool,
457 pub revision: Option<u16>,
459}
460
461impl<'a> ReportData<'a> {
462 pub fn attribute_reports(&self) -> Result<Option<ArrayIter<'a, AttributeReport<'a>>>> {
464 self.attribute_reports
465 .map(|bytes| ArrayIter::new(bytes, ContainerKind::Structure, AttributeReport::decode))
466 .transpose()
467 }
468
469 pub fn event_reports(&self) -> Result<Option<ArrayIter<'a, crate::im::EventReport<'a>>>> {
471 self.event_reports
472 .map(|bytes| {
473 ArrayIter::new(
474 bytes,
475 ContainerKind::Structure,
476 crate::im::EventReport::decode,
477 )
478 })
479 .transpose()
480 }
481
482 #[must_use]
489 pub const fn attribute_reports_bytes(&self) -> Option<&'a [u8]> {
490 self.attribute_reports
491 }
492
493 #[must_use]
496 pub const fn event_reports_bytes(&self) -> Option<&'a [u8]> {
497 self.event_reports
498 }
499
500 pub fn decode(buf: &'a [u8]) -> Result<Self> {
502 let mut reader = open(buf)?;
503 let mut subscription_id = None;
504 let mut attribute_reports = None;
505 let mut event_reports = None;
506 let mut more_chunked_messages = None;
507 let mut suppress_response = None;
508 let mut revision = None;
509
510 loop {
511 let start = reader.position();
512 let Some(element) = reader.next_element()? else {
513 bail!(TlvTruncated)
514 };
515 if element.value == Value::EndOfContainer {
516 break;
517 }
518 match element.tag.context() {
519 Some(0) => set_once(&mut subscription_id, narrow32(element.unsigned()?)?)?,
520 Some(1) => set_once(
521 &mut attribute_reports,
522 take_array(&mut reader, &element, start)?,
523 )?,
524 Some(2) => {
525 set_once(
526 &mut event_reports,
527 take_array(&mut reader, &element, start)?,
528 )?;
529 }
530 Some(3) => set_once(&mut more_chunked_messages, element.bool()?)?,
531 Some(4) => set_once(&mut suppress_response, element.bool()?)?,
532 Some(REVISION_TAG) => set_once(&mut revision, narrow16(element.unsigned()?)?)?,
533 _ => reader.skip_value(&element)?,
534 }
535 }
536 reader.finish()?;
537
538 Ok(Self {
539 subscription_id,
540 attribute_reports,
541 event_reports,
542 more_chunked_messages: more_chunked_messages.unwrap_or(false),
544 suppress_response: suppress_response.unwrap_or(false),
545 revision,
546 })
547 }
548}
549
550pub fn encode_report_data<'b, R>(
552 buf: &'b mut [u8],
553 subscription_id: Option<u32>,
554 reports: R,
555 more_chunked_messages: bool,
556 suppress_response: bool,
557) -> Result<&'b [u8]>
558where
559 R: IntoIterator<Item = AttributeReport<'b>>,
560{
561 let mut w = TlvWriter::new(buf);
562 w.start_structure(Tag::Anonymous)?;
563 if let Some(id) = subscription_id {
564 w.unsigned(Tag::Context(0), u64::from(id))?;
565 }
566 let mut reports = reports.into_iter().peekable();
567 if reports.peek().is_some() {
568 w.start_array(Tag::Context(1))?;
569 for report in reports {
570 report.encode(&mut w)?;
571 }
572 w.end_container()?;
573 }
574 if more_chunked_messages {
577 w.bool(Tag::Context(3), true)?;
578 }
579 if suppress_response {
580 w.bool(Tag::Context(4), true)?;
581 }
582 write_revision(&mut w)?;
583 w.end_container()?;
584 w.finish()
585}
586
587#[derive(Debug, Clone, Copy, PartialEq, Eq)]
591pub struct WriteRequest<'a> {
592 pub suppress_response: bool,
594 pub timed_request: bool,
596 write_requests: &'a [u8],
597 pub more_chunked_messages: bool,
599 pub revision: Option<u16>,
601}
602
603impl<'a> WriteRequest<'a> {
604 pub fn writes(&self) -> Result<ArrayIter<'a, AttributeData<'a>>> {
606 ArrayIter::new(
607 self.write_requests,
608 ContainerKind::Structure,
609 AttributeData::decode,
610 )
611 }
612
613 pub fn decode(buf: &'a [u8]) -> Result<Self> {
615 let mut reader = open(buf)?;
616 let mut suppress_response = None;
617 let mut timed_request = None;
618 let mut write_requests = None;
619 let mut more_chunked_messages = None;
620 let mut revision = None;
621
622 loop {
623 let start = reader.position();
624 let Some(element) = reader.next_element()? else {
625 bail!(TlvTruncated)
626 };
627 if element.value == Value::EndOfContainer {
628 break;
629 }
630 match element.tag.context() {
631 Some(0) => set_once(&mut suppress_response, element.bool()?)?,
632 Some(1) => set_once(&mut timed_request, element.bool()?)?,
633 Some(2) => set_once(
634 &mut write_requests,
635 take_array(&mut reader, &element, start)?,
636 )?,
637 Some(3) => set_once(&mut more_chunked_messages, element.bool()?)?,
638 Some(REVISION_TAG) => set_once(&mut revision, narrow16(element.unsigned()?)?)?,
639 _ => reader.skip_value(&element)?,
640 }
641 }
642 reader.finish()?;
643
644 Ok(Self {
645 suppress_response: suppress_response.unwrap_or(false),
646 timed_request: timed_request.unwrap_or(false),
647 write_requests: write_requests.ok_or(Error::new(ErrorCode::TlvNotFound))?,
650 more_chunked_messages: more_chunked_messages.unwrap_or(false),
651 revision,
652 })
653 }
654}
655
656pub fn encode_write_request<'b, W>(
658 buf: &'b mut [u8],
659 writes: W,
660 timed_request: bool,
661 suppress_response: bool,
662) -> Result<&'b [u8]>
663where
664 W: IntoIterator<Item = AttributeData<'b>>,
665{
666 let mut w = TlvWriter::new(buf);
667 w.start_structure(Tag::Anonymous)?;
668 if suppress_response {
669 w.bool(Tag::Context(0), true)?;
670 }
671 w.bool(Tag::Context(1), timed_request)?;
672 w.start_array(Tag::Context(2))?;
673 for data in writes {
674 data.encode(&mut w, Tag::Anonymous)?;
676 }
677 w.end_container()?;
678 write_revision(&mut w)?;
679 w.end_container()?;
680 w.finish()
681}
682
683#[derive(Debug, Clone, Copy, PartialEq, Eq)]
685pub struct WriteResponse<'a> {
686 write_responses: &'a [u8],
687 pub revision: Option<u16>,
689}
690
691impl<'a> WriteResponse<'a> {
692 pub fn statuses(&self) -> Result<ArrayIter<'a, crate::im::ib::AttributeStatus>> {
694 ArrayIter::new(
695 self.write_responses,
696 ContainerKind::Structure,
697 crate::im::ib::AttributeStatus::decode,
698 )
699 }
700
701 pub fn decode(buf: &'a [u8]) -> Result<Self> {
703 let mut reader = open(buf)?;
704 let mut write_responses = None;
705 let mut revision = None;
706 loop {
707 let start = reader.position();
708 let Some(element) = reader.next_element()? else {
709 bail!(TlvTruncated)
710 };
711 if element.value == Value::EndOfContainer {
712 break;
713 }
714 match element.tag.context() {
715 Some(0) => set_once(
716 &mut write_responses,
717 take_array(&mut reader, &element, start)?,
718 )?,
719 Some(REVISION_TAG) => set_once(&mut revision, narrow16(element.unsigned()?)?)?,
720 _ => reader.skip_value(&element)?,
721 }
722 }
723 reader.finish()?;
724 Ok(Self {
725 write_responses: write_responses.ok_or(Error::new(ErrorCode::TlvNotFound))?,
726 revision,
727 })
728 }
729}
730
731pub fn encode_write_response<S>(buf: &mut [u8], statuses: S) -> Result<&[u8]>
733where
734 S: IntoIterator<Item = crate::im::ib::AttributeStatus>,
735{
736 let mut w = TlvWriter::new(buf);
737 w.start_structure(Tag::Anonymous)?;
738 w.start_array(Tag::Context(0))?;
739 for status in statuses {
740 status.encode(&mut w, Tag::Anonymous)?;
741 }
742 w.end_container()?;
743 write_revision(&mut w)?;
744 w.end_container()?;
745 w.finish()
746}
747
748#[derive(Debug, Clone, Copy, PartialEq, Eq)]
752pub struct InvokeRequest<'a> {
753 pub suppress_response: bool,
755 pub timed_request: bool,
757 invoke_requests: &'a [u8],
758 pub revision: Option<u16>,
760}
761
762impl<'a> InvokeRequest<'a> {
763 pub fn commands(&self) -> Result<ArrayIter<'a, CommandData<'a>>> {
769 ArrayIter::new(
770 self.invoke_requests,
771 ContainerKind::Structure,
772 CommandData::decode,
773 )
774 }
775
776 pub fn decode(buf: &'a [u8]) -> Result<Self> {
778 let mut reader = open(buf)?;
779 let mut suppress_response = None;
780 let mut timed_request = None;
781 let mut invoke_requests = None;
782 let mut revision = None;
783
784 loop {
785 let start = reader.position();
786 let Some(element) = reader.next_element()? else {
787 bail!(TlvTruncated)
788 };
789 if element.value == Value::EndOfContainer {
790 break;
791 }
792 match element.tag.context() {
793 Some(0) => set_once(&mut suppress_response, element.bool()?)?,
794 Some(1) => set_once(&mut timed_request, element.bool()?)?,
795 Some(2) => set_once(
796 &mut invoke_requests,
797 take_array(&mut reader, &element, start)?,
798 )?,
799 Some(REVISION_TAG) => set_once(&mut revision, narrow16(element.unsigned()?)?)?,
800 _ => reader.skip_value(&element)?,
801 }
802 }
803 reader.finish()?;
804
805 Ok(Self {
806 suppress_response: suppress_response.unwrap_or(false),
807 timed_request: timed_request.unwrap_or(false),
808 invoke_requests: invoke_requests.ok_or(Error::new(ErrorCode::TlvNotFound))?,
809 revision,
810 })
811 }
812}
813
814pub fn encode_invoke_request<'b, C>(
816 buf: &'b mut [u8],
817 commands: C,
818 timed_request: bool,
819 suppress_response: bool,
820) -> Result<&'b [u8]>
821where
822 C: IntoIterator<Item = CommandData<'b>>,
823{
824 let mut w = TlvWriter::new(buf);
825 w.start_structure(Tag::Anonymous)?;
826 w.bool(Tag::Context(0), suppress_response)?;
827 w.bool(Tag::Context(1), timed_request)?;
828 w.start_array(Tag::Context(2))?;
829 for command in commands {
830 command.encode(&mut w)?;
831 }
832 w.end_container()?;
833 write_revision(&mut w)?;
834 w.end_container()?;
835 w.finish()
836}
837
838#[derive(Debug, Clone, Copy, PartialEq, Eq)]
840pub struct InvokeResponseMessage<'a> {
841 pub suppress_response: bool,
843 invoke_responses: &'a [u8],
844 pub more_chunked_messages: bool,
846 pub revision: Option<u16>,
848}
849
850impl<'a> InvokeResponseMessage<'a> {
851 pub fn responses(&self) -> Result<ArrayIter<'a, InvokeResponse<'a>>> {
853 ArrayIter::new(
854 self.invoke_responses,
855 ContainerKind::Structure,
856 InvokeResponse::decode,
857 )
858 }
859
860 pub fn decode(buf: &'a [u8]) -> Result<Self> {
862 let mut reader = open(buf)?;
863 let mut suppress_response = None;
864 let mut invoke_responses = None;
865 let mut more_chunked_messages = None;
866 let mut revision = None;
867
868 loop {
869 let start = reader.position();
870 let Some(element) = reader.next_element()? else {
871 bail!(TlvTruncated)
872 };
873 if element.value == Value::EndOfContainer {
874 break;
875 }
876 match element.tag.context() {
877 Some(0) => set_once(&mut suppress_response, element.bool()?)?,
878 Some(1) => set_once(
879 &mut invoke_responses,
880 take_array(&mut reader, &element, start)?,
881 )?,
882 Some(2) => set_once(&mut more_chunked_messages, element.bool()?)?,
883 Some(REVISION_TAG) => set_once(&mut revision, narrow16(element.unsigned()?)?)?,
884 _ => reader.skip_value(&element)?,
885 }
886 }
887 reader.finish()?;
888
889 Ok(Self {
890 suppress_response: suppress_response.unwrap_or(false),
891 invoke_responses: invoke_responses.ok_or(Error::new(ErrorCode::TlvNotFound))?,
892 more_chunked_messages: more_chunked_messages.unwrap_or(false),
893 revision,
894 })
895 }
896}
897
898pub fn encode_invoke_response<'b, R>(
900 buf: &'b mut [u8],
901 responses: R,
902 suppress_response: bool,
903) -> Result<&'b [u8]>
904where
905 R: IntoIterator<Item = InvokeResponse<'b>>,
906{
907 let mut w = TlvWriter::new(buf);
908 w.start_structure(Tag::Anonymous)?;
909 w.bool(Tag::Context(0), suppress_response)?;
910 w.start_array(Tag::Context(1))?;
911 for response in responses {
912 response.encode(&mut w)?;
913 }
914 w.end_container()?;
915 write_revision(&mut w)?;
916 w.end_container()?;
917 w.finish()
918}
919
920#[derive(Debug, Clone, Copy, PartialEq, Eq)]
924pub struct TimedRequest {
925 pub timeout_ms: u16,
927 pub revision: Option<u16>,
929}
930
931impl TimedRequest {
932 #[must_use]
934 pub const fn new(timeout_ms: u16) -> Self {
935 Self {
936 timeout_ms,
937 revision: Some(INTERACTION_MODEL_REVISION),
938 }
939 }
940
941 pub fn encode<'b>(&self, buf: &'b mut [u8]) -> Result<&'b [u8]> {
943 let mut w = TlvWriter::new(buf);
944 w.start_structure(Tag::Anonymous)?;
945 w.unsigned(Tag::Context(0), u64::from(self.timeout_ms))?;
946 write_revision(&mut w)?;
947 w.end_container()?;
948 w.finish()
949 }
950
951 pub fn decode(buf: &[u8]) -> Result<Self> {
953 let mut reader = open(buf)?;
954 let mut timeout_ms = None;
955 let mut revision = None;
956 loop {
957 let Some(element) = reader.next_element()? else {
958 bail!(TlvTruncated)
959 };
960 if element.value == Value::EndOfContainer {
961 break;
962 }
963 match element.tag.context() {
964 Some(0) => set_once(&mut timeout_ms, narrow16(element.unsigned()?)?)?,
965 Some(REVISION_TAG) => set_once(&mut revision, narrow16(element.unsigned()?)?)?,
966 _ => reader.skip_value(&element)?,
967 }
968 }
969 reader.finish()?;
970 Ok(Self {
971 timeout_ms: timeout_ms.ok_or(Error::new(ErrorCode::TlvNotFound))?,
972 revision,
973 })
974 }
975}
976
977#[derive(Debug, Clone, Copy, PartialEq, Eq)]
981pub struct SubscribeRequest<'a> {
982 pub keep_subscriptions: bool,
984 pub min_interval_floor_s: u16,
986 pub max_interval_ceiling_s: u16,
988 attribute_requests: Option<&'a [u8]>,
989 event_requests: Option<&'a [u8]>,
990 event_filters: Option<&'a [u8]>,
991 data_version_filters: Option<&'a [u8]>,
992 pub fabric_filtered: bool,
994 pub revision: Option<u16>,
996}
997
998impl<'a> SubscribeRequest<'a> {
999 pub fn attribute_paths(&self) -> Result<Option<ArrayIter<'a, AttributePath>>> {
1001 self.attribute_requests
1002 .map(|bytes| ArrayIter::new(bytes, ContainerKind::List, path_from_list))
1003 .transpose()
1004 }
1005
1006 pub fn event_paths(&self) -> Result<Option<ArrayIter<'a, EventPath>>> {
1008 self.event_requests
1009 .map(|bytes| ArrayIter::new(bytes, ContainerKind::List, event_path_from_list))
1010 .transpose()
1011 }
1012
1013 #[must_use]
1016 pub const fn data_version_filters_raw(&self) -> Option<&'a [u8]> {
1017 self.data_version_filters
1018 }
1019
1020 pub fn data_version_filters(&self) -> Result<Option<ArrayIter<'a, DataVersionFilter>>> {
1022 self.data_version_filters
1023 .map(|bytes| ArrayIter::new(bytes, ContainerKind::Structure, DataVersionFilter::decode))
1024 .transpose()
1025 }
1026
1027 #[must_use]
1030 pub const fn event_filters_raw(&self) -> Option<&'a [u8]> {
1031 self.event_filters
1032 }
1033
1034 pub fn event_filters(&self) -> Result<Option<ArrayIter<'a, EventFilter>>> {
1036 self.event_filters
1037 .map(|bytes| ArrayIter::new(bytes, ContainerKind::Structure, EventFilter::decode))
1038 .transpose()
1039 }
1040
1041 pub fn decode(buf: &'a [u8]) -> Result<Self> {
1043 let mut reader = open(buf)?;
1044 let mut keep_subscriptions = None;
1045 let mut min_interval_floor_s = None;
1046 let mut max_interval_ceiling_s = None;
1047 let mut attribute_requests = None;
1048 let mut event_requests = None;
1049 let mut event_filters = None;
1050 let mut data_version_filters = None;
1051 let mut fabric_filtered = None;
1052 let mut revision = None;
1053
1054 loop {
1055 let start = reader.position();
1056 let Some(element) = reader.next_element()? else {
1057 bail!(TlvTruncated)
1058 };
1059 if element.value == Value::EndOfContainer {
1060 break;
1061 }
1062 match element.tag.context() {
1063 Some(0) => set_once(&mut keep_subscriptions, element.bool()?)?,
1064 Some(1) => set_once(&mut min_interval_floor_s, narrow16(element.unsigned()?)?)?,
1065 Some(2) => set_once(&mut max_interval_ceiling_s, narrow16(element.unsigned()?)?)?,
1066 Some(3) => set_once(
1067 &mut attribute_requests,
1068 take_array(&mut reader, &element, start)?,
1069 )?,
1070 Some(4) => set_once(
1071 &mut event_requests,
1072 take_array(&mut reader, &element, start)?,
1073 )?,
1074 Some(5) => {
1075 set_once(
1076 &mut event_filters,
1077 take_array(&mut reader, &element, start)?,
1078 )?;
1079 }
1080 Some(7) => set_once(&mut fabric_filtered, element.bool()?)?,
1081 Some(8) => set_once(
1082 &mut data_version_filters,
1083 take_array(&mut reader, &element, start)?,
1084 )?,
1085 Some(REVISION_TAG) => set_once(&mut revision, narrow16(element.unsigned()?)?)?,
1086 _ => reader.skip_value(&element)?,
1087 }
1088 }
1089 reader.finish()?;
1090
1091 Ok(Self {
1092 keep_subscriptions: keep_subscriptions.unwrap_or(false),
1093 min_interval_floor_s: min_interval_floor_s.ok_or(Error::new(ErrorCode::TlvNotFound))?,
1094 max_interval_ceiling_s: max_interval_ceiling_s
1095 .ok_or(Error::new(ErrorCode::TlvNotFound))?,
1096 attribute_requests,
1097 event_requests,
1098 event_filters,
1099 data_version_filters,
1100 fabric_filtered: fabric_filtered.ok_or(Error::new(ErrorCode::TlvNotFound))?,
1101 revision,
1102 })
1103 }
1104}
1105
1106#[derive(Debug, Clone, Copy, PartialEq, Eq)]
1112pub struct SubscribeResponse {
1113 pub subscription_id: u32,
1115 pub max_interval_s: u16,
1117 pub revision: Option<u16>,
1119}
1120
1121impl SubscribeResponse {
1122 #[must_use]
1124 pub const fn new(subscription_id: u32, max_interval_s: u16) -> Self {
1125 Self {
1126 subscription_id,
1127 max_interval_s,
1128 revision: Some(INTERACTION_MODEL_REVISION),
1129 }
1130 }
1131
1132 pub fn encode<'b>(&self, buf: &'b mut [u8]) -> Result<&'b [u8]> {
1134 let mut w = TlvWriter::new(buf);
1135 w.start_structure(Tag::Anonymous)?;
1136 w.unsigned(Tag::Context(0), u64::from(self.subscription_id))?;
1137 w.unsigned(Tag::Context(2), u64::from(self.max_interval_s))?;
1138 write_revision(&mut w)?;
1139 w.end_container()?;
1140 w.finish()
1141 }
1142
1143 pub fn decode(buf: &[u8]) -> Result<Self> {
1145 let mut reader = open(buf)?;
1146 let mut subscription_id = None;
1147 let mut max_interval_s = None;
1148 let mut revision = None;
1149 loop {
1150 let Some(element) = reader.next_element()? else {
1151 bail!(TlvTruncated)
1152 };
1153 if element.value == Value::EndOfContainer {
1154 break;
1155 }
1156 match element.tag.context() {
1157 Some(0) => set_once(&mut subscription_id, narrow32(element.unsigned()?)?)?,
1158 Some(2) => set_once(&mut max_interval_s, narrow16(element.unsigned()?)?)?,
1159 Some(REVISION_TAG) => set_once(&mut revision, narrow16(element.unsigned()?)?)?,
1160 _ => reader.skip_value(&element)?,
1161 }
1162 }
1163 reader.finish()?;
1164 Ok(Self {
1165 subscription_id: subscription_id.ok_or(Error::new(ErrorCode::TlvNotFound))?,
1166 max_interval_s: max_interval_s.ok_or(Error::new(ErrorCode::TlvNotFound))?,
1167 revision,
1168 })
1169 }
1170}
1171
1172fn path_from_list(reader: &mut TlvReader<'_>) -> Result<AttributePath> {
1173 AttributePath::decode(reader)
1174}
1175
1176fn event_path_from_list(reader: &mut TlvReader<'_>) -> Result<EventPath> {
1177 EventPath::decode(reader)
1178}
1179
1180fn narrow16(value: u64) -> Result<u16> {
1181 u16::try_from(value).map_err(|_| Error::new(ErrorCode::TlvOutOfRange))
1182}
1183
1184fn narrow32(value: u64) -> Result<u32> {
1185 u32::try_from(value).map_err(|_| Error::new(ErrorCode::TlvOutOfRange))
1186}