dvb_si/descriptors/
data_broadcast_id.rs

1//! Data Broadcast Id Descriptor — ETSI EN 300 468 §6.2.13 (tag 0x66).
2//!
3//! Table 32 (PDF p. 72). Identifies the data broadcast specification used by a
4//! data component, plus an `id_selector_byte` tail whose interpretation depends
5//! on the `data_broadcast_id` (see ETSI TS 101 162).
6//!
7//! The `id_selector` is decoded into [`IdSelector`]:
8//!
9//! - `data_broadcast_id = 0x000A` (SSU) → [`IdSelector::Ssu`] carrying a typed
10//!   [`SsuIdSelector`] (TS 102 006 §7.1 Table 4).
11//! - All other ids → [`IdSelector::Raw`] carrying the raw bytes, preserving
12//!   unknown-id behaviour for all non-SSU users.
13
14use super::descriptor_body;
15use crate::error::{Error, Result};
16use alloc::vec::Vec;
17use dvb_common::{Parse, Serialize};
18
19/// SSU `update_type` — ETSI TS 102 006 §7.1 Table 5
20/// (`docs/ts_102_006_ssu.md`, Table 5 — Update_type coding).
21///
22/// 4-bit field in each OUI entry of the SSU `id_selector`.
23#[derive(Debug, Clone, Copy, PartialEq, Eq)]
24#[cfg_attr(feature = "serde", derive(serde::Serialize))]
25#[non_exhaustive]
26pub enum UpdateType {
27    /// `0x0` — proprietary update solution.
28    ProprietaryUpdateSolution,
29    /// `0x1` — standard update carousel (i.e. without notification table) via broadcast.
30    StandardUpdateCarousel,
31    /// `0x2` — system software update carousel with notification table (UNT) both available via broadcast.
32    UntCarousel,
33    /// `0x3` — system software update signalled via broadcast UNT, update available from the return channel.
34    UntReturnChannel,
35    /// `0x4` — system software update signalled via broadcast UNT, update available from the Internet.
36    UntInternet,
37    /// `0x5`–`0xF` — reserved for future use.
38    Reserved(u8),
39}
40
41impl UpdateType {
42    #[must_use]
43    /// Creates a value from a 4-bit wire nibble, preserving every possible
44    /// value for lossless round-trip.
45    pub fn from_u8(v: u8) -> Self {
46        match v & 0x0F {
47            0x0 => Self::ProprietaryUpdateSolution,
48            0x1 => Self::StandardUpdateCarousel,
49            0x2 => Self::UntCarousel,
50            0x3 => Self::UntReturnChannel,
51            0x4 => Self::UntInternet,
52            v => Self::Reserved(v),
53        }
54    }
55
56    #[must_use]
57    /// Returns the 4-bit wire nibble for this value.
58    pub fn to_u8(self) -> u8 {
59        match self {
60            Self::ProprietaryUpdateSolution => 0x0,
61            Self::StandardUpdateCarousel => 0x1,
62            Self::UntCarousel => 0x2,
63            Self::UntReturnChannel => 0x3,
64            Self::UntInternet => 0x4,
65            Self::Reserved(v) => v,
66        }
67    }
68
69    #[must_use]
70    /// Returns the spec token for this value.
71    pub fn name(self) -> &'static str {
72        match self {
73            Self::ProprietaryUpdateSolution => "proprietary update solution",
74            Self::StandardUpdateCarousel => "standard update carousel",
75            Self::UntCarousel => "SSU carousel with UNT",
76            Self::UntReturnChannel => "SSU UNT (return channel)",
77            Self::UntInternet => "SSU UNT (Internet)",
78            Self::Reserved(_) => "reserved",
79        }
80    }
81}
82dvb_common::impl_spec_display!(UpdateType, Reserved);
83
84/// Descriptor tag for data_broadcast_id_descriptor.
85pub const TAG: u8 = 0x66;
86const HEADER_LEN: usize = 2;
87/// Fixed prefix length: the 16-bit data_broadcast_id (EN 300 468 Table 32).
88const ID_LEN: usize = 2;
89
90/// `data_broadcast_id` value for DVB System Software Update (TS 102 006).
91pub const DATA_BROADCAST_ID_SSU: u16 = 0x000A;
92
93// SSU id_selector constants (TS 102 006 Table 4).
94/// OUI_data_length field: 1 byte.
95const SSU_OUI_DATA_LENGTH_LEN: usize = 1;
96/// Per-OUI fixed fields: OUI(3) + combined-byte-1(1) + combined-byte-2(1) +
97/// selector_length(1) = 6 bytes before the selector bytes.
98const SSU_OUI_FIXED_LEN: usize = 6;
99const SSU_UPDATE_TYPE_MASK: u8 = 0x0F;
100const SSU_UPDATE_VERSIONING_FLAG_MASK: u8 = 0x20;
101const SSU_UPDATE_VERSION_MASK: u8 = 0x1F;
102
103/// Returns the well-known name for a `data_broadcast_id`, or `None` if the
104/// ID is not recognised.
105///
106/// Verified entries from the DVB Services registry.
107#[must_use]
108pub fn data_broadcast_id_name(id: u16) -> Option<&'static str> {
109    match id {
110        0x0005 => Some("Multiprotocol Encapsulation (MPE)"),
111        0x0006 => Some("Data Carousel"),
112        0x0007 => Some("Object Carousel"),
113        DATA_BROADCAST_ID_SSU => Some("System Software Update (SSU)"),
114        0x000B => Some("IP/MAC Notification (INT)"),
115        0x00F0 => Some("MHP Object Carousel"),
116        0x0123 => Some("HbbTV"),
117        _ => None,
118    }
119}
120
121/// One OUI entry in an SSU `id_selector` — TS 102 006 §7.1 Table 4.
122///
123/// Wire layout per entry (all in bits):
124///
125/// ```text
126/// OUI                       24  bslbf
127/// reserved                   4  bslbf
128/// update_type                4  uimsbf  (Table 5)
129/// reserved                   2  bslbf
130/// update_versioning_flag     1  uimsbf
131/// update_version             5  uimsbf
132/// selector_length            8  uimsbf
133/// selector_byte × N          8  uimsbf
134/// ```
135#[derive(Debug, Clone, PartialEq, Eq)]
136#[cfg_attr(feature = "serde", derive(serde::Serialize))]
137pub struct SsuOuiEntry<'a> {
138    /// `OUI` — 24-bit IEEE Organizationally Unique Identifier.
139    pub oui: [u8; 3],
140    /// `update_type` `[3:0]` — TS 102 006 Table 5 coding.
141    pub update_type: UpdateType,
142    /// `update_versioning_flag` — when `1`, `update_version` is valid.
143    pub update_versioning_flag: bool,
144    /// `update_version` `[4:0]` — version counter; only meaningful when
145    /// `update_versioning_flag` is set.
146    pub update_version: u8,
147    /// `selector_byte` loop — additional targeting selector bytes.
148    #[cfg_attr(feature = "serde", serde(borrow))]
149    pub selector: &'a [u8],
150}
151
152/// Typed `id_selector` for `data_broadcast_id = 0x000A` (SSU) —
153/// TS 102 006 §7.1 Table 4 `system_software_update_info()`.
154///
155/// Wire layout:
156///
157/// ```text
158/// system_software_update_info() {
159///   OUI_data_length  8  uimsbf   (byte count of the OUI loop)
160///   for (i=0; i<N; i++) {
161///     OUI                       24
162///     reserved | update_type     8  (upper 4 = reserved, lower 4 = update_type)
163///     reserved | uvf | uversion  8  (upper 2 = reserved, bit5 = uvf, lower 5 = uversion)
164///     selector_length            8
165///     selector_byte × M          8
166///   }
167///   private_data_byte × P  8   (remainder after OUI loop)
168/// }
169/// ```
170#[derive(Debug, Clone, PartialEq, Eq)]
171#[cfg_attr(feature = "serde", derive(serde::Serialize))]
172pub struct SsuIdSelector<'a> {
173    /// OUI entries (the `OUI_data_length`-bounded loop).
174    pub oui_entries: Vec<SsuOuiEntry<'a>>,
175    /// `private_data_byte` tail — bytes after the OUI loop.
176    #[cfg_attr(feature = "serde", serde(borrow))]
177    pub private_data: &'a [u8],
178}
179
180/// Typed or raw `id_selector` — dispatch on `data_broadcast_id`.
181///
182/// Unknown ids fall through to `Raw`, preserving byte-exact content for
183/// non-SSU callers.
184#[derive(Debug, Clone, PartialEq, Eq)]
185#[cfg_attr(feature = "serde", derive(serde::Serialize))]
186#[non_exhaustive]
187pub enum IdSelector<'a> {
188    /// `data_broadcast_id = 0x000A` — TS 102 006 §7.1 Table 4 SSU selector.
189    Ssu(SsuIdSelector<'a>),
190    /// All other `data_broadcast_id` values — raw bytes, no interpretation.
191    #[cfg_attr(feature = "serde", serde(borrow))]
192    Raw(&'a [u8]),
193}
194
195impl<'a> IdSelector<'a> {
196    /// Parse bytes as the appropriate selector type for `data_broadcast_id`.
197    pub fn parse(data_broadcast_id: u16, bytes: &'a [u8]) -> Result<Self> {
198        if data_broadcast_id == DATA_BROADCAST_ID_SSU {
199            Ok(IdSelector::Ssu(SsuIdSelector::parse(bytes)?))
200        } else {
201            Ok(IdSelector::Raw(bytes))
202        }
203    }
204
205    /// Serialized byte length of this selector (not including the surrounding
206    /// descriptor tag/length or the 16-bit data_broadcast_id field).
207    pub fn serialized_len(&self) -> usize {
208        match self {
209            IdSelector::Ssu(s) => s.serialized_len(),
210            IdSelector::Raw(b) => b.len(),
211        }
212    }
213
214    /// Write the wire bytes into `buf` starting at offset `pos`.
215    pub fn serialize_into_at(&self, buf: &mut [u8], pos: usize) -> Result<usize> {
216        match self {
217            IdSelector::Ssu(s) => s.serialize_into(&mut buf[pos..]),
218            IdSelector::Raw(b) => {
219                buf[pos..pos + b.len()].copy_from_slice(b);
220                Ok(b.len())
221            }
222        }
223    }
224}
225
226impl<'a> Parse<'a> for SsuIdSelector<'a> {
227    type Error = crate::error::Error;
228
229    fn parse(bytes: &'a [u8]) -> Result<Self> {
230        if bytes.len() < SSU_OUI_DATA_LENGTH_LEN {
231            return Err(Error::InvalidDescriptor {
232                tag: TAG,
233                reason: "SSU id_selector too short for OUI_data_length",
234            });
235        }
236        let oui_data_length = bytes[0] as usize;
237        let oui_loop_end = SSU_OUI_DATA_LENGTH_LEN + oui_data_length;
238        if oui_loop_end > bytes.len() {
239            return Err(Error::InvalidDescriptor {
240                tag: TAG,
241                reason: "SSU id_selector OUI_data_length exceeds available bytes",
242            });
243        }
244        let mut pos = SSU_OUI_DATA_LENGTH_LEN;
245        let mut oui_entries = Vec::new();
246        while pos < oui_loop_end {
247            if pos + SSU_OUI_FIXED_LEN > oui_loop_end {
248                return Err(Error::InvalidDescriptor {
249                    tag: TAG,
250                    reason: "SSU id_selector OUI entry truncated",
251                });
252            }
253            let oui = [bytes[pos], bytes[pos + 1], bytes[pos + 2]];
254            let byte3 = bytes[pos + 3]; // reserved(4)|update_type(4)
255            let byte4 = bytes[pos + 4]; // reserved(2)|uvf(1)|uversion(5)
256            let selector_length = bytes[pos + 5] as usize;
257            pos += SSU_OUI_FIXED_LEN;
258            if pos + selector_length > oui_loop_end {
259                return Err(Error::InvalidDescriptor {
260                    tag: TAG,
261                    reason: "SSU id_selector OUI selector_length exceeds OUI loop",
262                });
263            }
264            let selector = &bytes[pos..pos + selector_length];
265            pos += selector_length;
266            oui_entries.push(SsuOuiEntry {
267                oui,
268                update_type: UpdateType::from_u8(byte3 & SSU_UPDATE_TYPE_MASK),
269                update_versioning_flag: (byte4 & SSU_UPDATE_VERSIONING_FLAG_MASK) != 0,
270                update_version: byte4 & SSU_UPDATE_VERSION_MASK,
271                selector,
272            });
273        }
274        let private_data = &bytes[oui_loop_end..];
275        Ok(SsuIdSelector {
276            oui_entries,
277            private_data,
278        })
279    }
280}
281
282impl Serialize for SsuIdSelector<'_> {
283    type Error = crate::error::Error;
284
285    fn serialized_len(&self) -> usize {
286        let oui_body: usize = self
287            .oui_entries
288            .iter()
289            .map(|e| SSU_OUI_FIXED_LEN + e.selector.len())
290            .sum();
291        SSU_OUI_DATA_LENGTH_LEN + oui_body + self.private_data.len()
292    }
293
294    fn serialize_into(&self, buf: &mut [u8]) -> Result<usize> {
295        let len = self.serialized_len();
296        if buf.len() < len {
297            return Err(Error::OutputBufferTooSmall {
298                need: len,
299                have: buf.len(),
300            });
301        }
302        let oui_body: usize = self
303            .oui_entries
304            .iter()
305            .map(|e| SSU_OUI_FIXED_LEN + e.selector.len())
306            .sum();
307        if oui_body > u8::MAX as usize {
308            return Err(Error::InvalidDescriptor {
309                tag: TAG,
310                reason: "SSU OUI loop exceeds 255 bytes (OUI_data_length field overflow)",
311            });
312        }
313        buf[0] = oui_body as u8;
314        let mut pos = SSU_OUI_DATA_LENGTH_LEN;
315        for e in &self.oui_entries {
316            if e.selector.len() > u8::MAX as usize {
317                return Err(Error::InvalidDescriptor {
318                    tag: TAG,
319                    reason: "SSU OUI entry selector exceeds 255 bytes",
320                });
321            }
322            buf[pos..pos + 3].copy_from_slice(&e.oui);
323            buf[pos + 3] = e.update_type.to_u8() & SSU_UPDATE_TYPE_MASK; // reserved=0 | update_type
324            let uvf_bit: u8 = if e.update_versioning_flag {
325                SSU_UPDATE_VERSIONING_FLAG_MASK
326            } else {
327                0
328            };
329            buf[pos + 4] = uvf_bit | (e.update_version & SSU_UPDATE_VERSION_MASK);
330            buf[pos + 5] = e.selector.len() as u8;
331            pos += SSU_OUI_FIXED_LEN;
332            buf[pos..pos + e.selector.len()].copy_from_slice(e.selector);
333            pos += e.selector.len();
334        }
335        buf[pos..pos + self.private_data.len()].copy_from_slice(self.private_data);
336        Ok(len)
337    }
338}
339
340/// Data Broadcast Id Descriptor (tag 0x66).
341#[derive(Debug, Clone, PartialEq, Eq)]
342#[cfg_attr(feature = "serde", derive(serde::Serialize))]
343#[cfg_attr(feature = "yoke", derive(yoke::Yokeable))]
344pub struct DataBroadcastIdDescriptor<'a> {
345    /// 16-bit data_broadcast_id (ETSI TS 101 162 registration).
346    pub data_broadcast_id: u16,
347    /// Raw `id_selector_byte` tail (wire bytes, unchanged on round-trip).
348    /// Decode it on demand with [`Self::id_selector_decoded`] — typed for
349    /// `data_broadcast_id = 0x000A` (SSU), raw for all other ids.
350    #[cfg_attr(feature = "serde", serde(borrow))]
351    pub id_selector: &'a [u8],
352}
353
354impl<'a> DataBroadcastIdDescriptor<'a> {
355    /// Decode the `id_selector` tail according to `data_broadcast_id`:
356    /// [`IdSelector::Ssu`] for `0x000A` (TS 102 006 §7.1 Table 4), else
357    /// [`IdSelector::Raw`]. Decode-on-demand; the raw bytes remain in
358    /// [`Self::id_selector`] and round-trip verbatim.
359    pub fn id_selector_decoded(&self) -> Result<IdSelector<'a>> {
360        IdSelector::parse(self.data_broadcast_id, self.id_selector)
361    }
362}
363
364impl<'a> Parse<'a> for DataBroadcastIdDescriptor<'a> {
365    type Error = crate::error::Error;
366    fn parse(bytes: &'a [u8]) -> Result<Self> {
367        let body = descriptor_body(
368            bytes,
369            TAG,
370            "DataBroadcastIdDescriptor",
371            "unexpected tag for data_broadcast_id_descriptor",
372        )?;
373        if body.len() < ID_LEN {
374            return Err(Error::InvalidDescriptor {
375                tag: TAG,
376                reason: "data_broadcast_id_descriptor body shorter than 2 bytes",
377            });
378        }
379        let data_broadcast_id = u16::from_be_bytes([body[0], body[1]]);
380        let id_selector = &body[ID_LEN..];
381        Ok(Self {
382            data_broadcast_id,
383            id_selector,
384        })
385    }
386}
387
388impl Serialize for DataBroadcastIdDescriptor<'_> {
389    type Error = crate::error::Error;
390    fn serialized_len(&self) -> usize {
391        HEADER_LEN + ID_LEN + self.id_selector.len()
392    }
393
394    fn serialize_into(&self, buf: &mut [u8]) -> Result<usize> {
395        let len = self.serialized_len();
396        let body = ID_LEN + self.id_selector.len();
397        if body > u8::MAX as usize {
398            return Err(Error::InvalidDescriptor {
399                tag: TAG,
400                reason: "data_broadcast_id_descriptor body exceeds 255 bytes",
401            });
402        }
403        if buf.len() < len {
404            return Err(Error::OutputBufferTooSmall {
405                need: len,
406                have: buf.len(),
407            });
408        }
409        buf[0] = TAG;
410        buf[1] = body as u8;
411        buf[HEADER_LEN..HEADER_LEN + ID_LEN].copy_from_slice(&self.data_broadcast_id.to_be_bytes());
412        buf[HEADER_LEN + ID_LEN..len].copy_from_slice(self.id_selector);
413        Ok(len)
414    }
415}
416impl<'a> crate::traits::DescriptorDef<'a> for DataBroadcastIdDescriptor<'a> {
417    const TAG: u8 = TAG;
418    const NAME: &'static str = "DATA_BROADCAST_ID";
419}
420
421#[cfg(test)]
422mod tests {
423    use super::*;
424
425    // ── DataBroadcastIdDescriptor (non-SSU raw path) ──────────────────────────
426
427    #[test]
428    fn parse_extracts_id_and_raw_selector() {
429        let bytes = [TAG, 0x05, 0x00, 0x0B, 0xAA, 0xBB, 0xCC];
430        let d = DataBroadcastIdDescriptor::parse(&bytes).unwrap();
431        assert_eq!(d.data_broadcast_id, 0x000B);
432        assert_eq!(d.id_selector, &[0xAA, 0xBB, 0xCC][..]);
433        assert_eq!(
434            d.id_selector_decoded().unwrap(),
435            IdSelector::Raw(&[0xAA, 0xBB, 0xCC])
436        );
437    }
438
439    #[test]
440    fn parse_accepts_empty_raw_selector() {
441        // Non-SSU id with no selector bytes.
442        let bytes = [TAG, 0x02, 0x00, 0x0B];
443        let d = DataBroadcastIdDescriptor::parse(&bytes).unwrap();
444        assert_eq!(d.data_broadcast_id, 0x000B);
445        assert!(d.id_selector.is_empty());
446        assert_eq!(d.id_selector_decoded().unwrap(), IdSelector::Raw(&[]));
447    }
448
449    #[test]
450    fn data_broadcast_id_name_verified() {
451        assert_eq!(
452            data_broadcast_id_name(0x0005),
453            Some("Multiprotocol Encapsulation (MPE)")
454        );
455        assert_eq!(data_broadcast_id_name(0x0006), Some("Data Carousel"));
456        assert_eq!(data_broadcast_id_name(0x0007), Some("Object Carousel"));
457        assert_eq!(
458            data_broadcast_id_name(DATA_BROADCAST_ID_SSU),
459            Some("System Software Update (SSU)")
460        );
461        assert_eq!(
462            data_broadcast_id_name(0x000B),
463            Some("IP/MAC Notification (INT)")
464        );
465        assert_eq!(data_broadcast_id_name(0x00F0), Some("MHP Object Carousel"));
466        assert_eq!(data_broadcast_id_name(0x0123), Some("HbbTV"));
467    }
468
469    #[test]
470    fn data_broadcast_id_name_removed_entries_return_none() {
471        assert_eq!(data_broadcast_id_name(0x00F1), None);
472        assert_eq!(data_broadcast_id_name(0x00F2), None);
473        assert_eq!(data_broadcast_id_name(0x00F3), None);
474        assert_eq!(data_broadcast_id_name(0x00F4), None);
475    }
476
477    #[test]
478    fn data_broadcast_id_name_unknown() {
479        assert_eq!(data_broadcast_id_name(0x0000), None);
480        assert_eq!(data_broadcast_id_name(0xFFFF), None);
481    }
482
483    #[test]
484    fn parse_rejects_wrong_tag() {
485        let err = DataBroadcastIdDescriptor::parse(&[0x65, 0x02, 0x00, 0x0A]).unwrap_err();
486        assert!(matches!(err, Error::InvalidDescriptor { tag: 0x65, .. }));
487    }
488
489    #[test]
490    fn parse_rejects_short_buffer() {
491        let err = DataBroadcastIdDescriptor::parse(&[TAG]).unwrap_err();
492        assert!(matches!(err, Error::BufferTooShort { .. }));
493    }
494
495    #[test]
496    fn parse_rejects_body_too_short() {
497        // length=1: not even the 16-bit id fits.
498        let err = DataBroadcastIdDescriptor::parse(&[TAG, 0x01, 0x00]).unwrap_err();
499        assert!(matches!(err, Error::InvalidDescriptor { .. }));
500    }
501
502    #[test]
503    fn parse_rejects_length_overrun() {
504        // length=5 but only 3 payload bytes available.
505        let err = DataBroadcastIdDescriptor::parse(&[TAG, 0x05, 0x00, 0x0B, 0xAA]).unwrap_err();
506        assert!(matches!(err, Error::BufferTooShort { .. }));
507    }
508
509    #[test]
510    fn raw_round_trip() {
511        let d = DataBroadcastIdDescriptor {
512            data_broadcast_id: 0x0123,
513            id_selector: &[0xDE, 0xAD, 0xBE, 0xEF],
514        };
515        let mut buf = vec![0u8; d.serialized_len()];
516        d.serialize_into(&mut buf).unwrap();
517        let re = DataBroadcastIdDescriptor::parse(&buf).unwrap();
518        assert_eq!(d, re);
519    }
520
521    #[test]
522    fn serialize_rejects_too_small_buffer() {
523        let d = DataBroadcastIdDescriptor {
524            data_broadcast_id: 0x0001,
525            id_selector: &[0x01],
526        };
527        let mut tiny = [0u8; 2];
528        let err = d.serialize_into(&mut tiny).unwrap_err();
529        assert!(matches!(err, Error::OutputBufferTooSmall { .. }));
530    }
531
532    #[test]
533    fn serialize_rejects_over_range_body() {
534        // 254 selector bytes + 2 id bytes = 256 > 255.
535        let sel = vec![0u8; 254];
536        let d = DataBroadcastIdDescriptor {
537            data_broadcast_id: 0x0001,
538            id_selector: &sel,
539        };
540        let mut buf = vec![0u8; d.serialized_len()];
541        let err = d.serialize_into(&mut buf).unwrap_err();
542        assert!(matches!(err, Error::InvalidDescriptor { tag: TAG, .. }));
543    }
544
545    #[cfg(feature = "serde")]
546    #[test]
547    fn serde_serialize_is_stable() {
548        let d = DataBroadcastIdDescriptor {
549            data_broadcast_id: 0x000B,
550            id_selector: &[0x01, 0x02],
551        };
552        let json = serde_json::to_string(&d).unwrap();
553        assert!(json.contains("\"data_broadcast_id\""));
554        assert!(json.contains("\"id_selector\""));
555        assert!(json.contains("11"));
556    }
557
558    // ── SsuIdSelector (data_broadcast_id = 0x000A) ───────────────────────────
559
560    /// Hand-built wire bytes for an SSU id_selector with one OUI entry and
561    /// no private data.
562    ///
563    /// Wire layout (inside the descriptor body, after the 2-byte
564    /// data_broadcast_id field):
565    ///
566    /// ```text
567    /// [0]    OUI_data_length = 0x09  (9 bytes = 1 entry × 6 fixed + 3 selector)
568    /// [1..4] OUI = 00:15:0A
569    /// [4]    0x02 = reserved(4)|update_type(4=0x2, UNT carousel)
570    /// [5]    0x61 = reserved(2)|uvf(1=1)|uversion(5=0x01)
571    ///              i.e. 0b00_1_00001 = 0x21 ... wait:
572    ///              uvf bit5 = 0x20, uversion = 0x01 → 0x21
573    /// [6]    selector_length = 0x03
574    /// [7..10] selector bytes = AA BB CC
575    /// [10]   (OUI loop ends; private_data empty)
576    /// Total = 10 bytes
577    /// ```
578    fn sample_ssu_selector() -> SsuIdSelector<'static> {
579        SsuIdSelector {
580            oui_entries: vec![SsuOuiEntry {
581                oui: [0x00, 0x15, 0x0A],
582                update_type: UpdateType::UntCarousel,
583                update_versioning_flag: true,
584                update_version: 0x01,
585                selector: &[0xAA, 0xBB, 0xCC],
586            }],
587            private_data: &[],
588        }
589    }
590
591    #[test]
592    fn ssu_selector_hand_built_byte_anchor() {
593        // OUI_data_length=9 (= 6 fixed + 3 selector), OUI=00:15:0A,
594        // byte3=0x02 (update_type=2), byte4=0x21 (uvf=1,uversion=1),
595        // selector_length=3, AA BB CC.
596        #[rustfmt::skip]
597        let expected: &[u8] = &[
598            0x09,                   // OUI_data_length = 9
599            0x00, 0x15, 0x0A,       // OUI
600            0x02,                   // reserved(0)|update_type(2)
601            0x21,                   // reserved(0)|uvf(1)|uversion(1)
602            0x03,                   // selector_length = 3
603            0xAA, 0xBB, 0xCC,       // selector bytes
604        ];
605        let s = sample_ssu_selector();
606        let mut buf = vec![0u8; s.serialized_len()];
607        s.serialize_into(&mut buf).unwrap();
608        assert_eq!(buf.as_slice(), expected);
609        let re = SsuIdSelector::parse(expected).unwrap();
610        assert_eq!(re, s);
611    }
612
613    #[test]
614    fn ssu_selector_round_trip() {
615        let s = sample_ssu_selector();
616        let mut buf = vec![0u8; s.serialized_len()];
617        s.serialize_into(&mut buf).unwrap();
618        let re = SsuIdSelector::parse(&buf).unwrap();
619        assert_eq!(re, s);
620        let mut buf2 = vec![0u8; re.serialized_len()];
621        re.serialize_into(&mut buf2).unwrap();
622        assert_eq!(buf, buf2, "SSU selector byte-exact re-serialize");
623    }
624
625    #[test]
626    fn ssu_selector_empty_oui_loop() {
627        let s = SsuIdSelector {
628            oui_entries: vec![],
629            private_data: &[0xDE, 0xAD],
630        };
631        let mut buf = vec![0u8; s.serialized_len()];
632        s.serialize_into(&mut buf).unwrap();
633        // OUI_data_length=0, then 2 private bytes.
634        assert_eq!(buf[0], 0x00);
635        assert_eq!(&buf[1..], &[0xDE, 0xAD]);
636        let re = SsuIdSelector::parse(&buf).unwrap();
637        assert_eq!(re, s);
638    }
639
640    #[test]
641    fn ssu_selector_no_versioning_flag() {
642        let s = SsuIdSelector {
643            oui_entries: vec![SsuOuiEntry {
644                oui: [0x00, 0x00, 0x00],
645                update_type: UpdateType::StandardUpdateCarousel,
646                update_versioning_flag: false,
647                update_version: 0x00,
648                selector: &[],
649            }],
650            private_data: &[],
651        };
652        let mut buf = vec![0u8; s.serialized_len()];
653        s.serialize_into(&mut buf).unwrap();
654        // Wire layout: [0]=OUI_data_length, [1..4]=OUI, [4]=byte3(update_type),
655        // [5]=byte4(uvf|uversion), [6]=selector_length.
656        // StandardUpdateCarousel.to_u8() = 0x01
657        assert_eq!(buf[4], 0x01); // byte3: update_type = 1
658        assert_eq!(buf[5], 0x00); // byte4: uvf=0, uversion=0
659        let re = SsuIdSelector::parse(&buf).unwrap();
660        assert_eq!(re, s);
661    }
662
663    /// End-to-end: DataBroadcastIdDescriptor with data_broadcast_id=0x000A
664    /// dispatches to IdSelector::Ssu.
665    ///
666    /// Wire layout (complete descriptor):
667    ///
668    /// ```text
669    /// [0]    tag = 0x66
670    /// [1]    length = 2 + 10 = 12
671    ///           (2 for data_broadcast_id + 10 for SSU selector)
672    /// [2..4] data_broadcast_id = 0x00 0x0A
673    /// [4..14] SSU id_selector (OUI_data_length=9, …)
674    /// ```
675    #[test]
676    fn descriptor_ssu_round_trip() {
677        let sel = sample_ssu_selector();
678        let mut sel_bytes = vec![0u8; sel.serialized_len()];
679        sel.serialize_into(&mut sel_bytes).unwrap();
680        let d = DataBroadcastIdDescriptor {
681            data_broadcast_id: DATA_BROADCAST_ID_SSU,
682            id_selector: &sel_bytes,
683        };
684        let mut buf = vec![0u8; d.serialized_len()];
685        d.serialize_into(&mut buf).unwrap();
686        // Sanity-check descriptor framing.
687        assert_eq!(buf[0], TAG);
688        assert_eq!(buf[1] as usize, ID_LEN + sel.serialized_len());
689        assert_eq!(&buf[2..4], &[0x00, 0x0A]); // data_broadcast_id
690        let re = DataBroadcastIdDescriptor::parse(&buf).unwrap();
691        assert_eq!(re, d);
692        // The raw id_selector decodes to the typed SSU selector.
693        assert_eq!(
694            re.id_selector_decoded().unwrap(),
695            IdSelector::Ssu(sample_ssu_selector())
696        );
697        // Byte-identical re-serialize.
698        let mut buf2 = vec![0u8; re.serialized_len()];
699        re.serialize_into(&mut buf2).unwrap();
700        assert_eq!(buf, buf2, "SSU descriptor byte-exact re-serialize");
701    }
702
703    #[test]
704    fn ssu_selector_parse_rejects_truncated_oui_loop() {
705        // OUI_data_length=6 but only 2 bytes follow.
706        let bytes = &[0x06, 0x00, 0x15];
707        assert!(matches!(
708            SsuIdSelector::parse(bytes).unwrap_err(),
709            Error::InvalidDescriptor { .. }
710        ));
711    }
712
713    #[test]
714    fn ssu_selector_parse_rejects_selector_overflows_oui_loop() {
715        // OUI_data_length=6 (exactly 1 entry with selector_length=0),
716        // but we set selector_length=5 which would overflow the oui loop.
717        #[rustfmt::skip]
718        let bytes = &[
719            0x06,                   // OUI_data_length = 6
720            0x00, 0x15, 0x0A,       // OUI
721            0x02,                   // byte3
722            0x21,                   // byte4
723            0x05,                   // selector_length=5 — overflows OUI loop
724        ];
725        assert!(matches!(
726            SsuIdSelector::parse(bytes).unwrap_err(),
727            Error::InvalidDescriptor { .. }
728        ));
729    }
730
731    #[cfg(feature = "serde")]
732    #[test]
733    fn ssu_descriptor_serde_json() {
734        let sel = sample_ssu_selector();
735        let mut sel_bytes = vec![0u8; sel.serialized_len()];
736        sel.serialize_into(&mut sel_bytes).unwrap();
737        let d = DataBroadcastIdDescriptor {
738            data_broadcast_id: DATA_BROADCAST_ID_SSU,
739            id_selector: &sel_bytes,
740        };
741        let json = serde_json::to_string(&d).unwrap();
742        assert!(json.contains("\"data_broadcast_id\":10"));
743        // The typed SSU fields appear in the decoded selector's JSON.
744        let decoded = d.id_selector_decoded().unwrap();
745        let sj = serde_json::to_string(&decoded).unwrap();
746        assert!(sj.contains("\"update_type\""));
747        assert!(sj.contains("\"update_versioning_flag\":true"));
748        assert!(sj.contains("\"update_version\":1"));
749    }
750
751    #[test]
752    fn update_type_full_range_round_trip() {
753        for v in 0u8..=0x0F {
754            let ut = UpdateType::from_u8(v);
755            assert_eq!(ut.to_u8(), v, "UpdateType round-trip failed for 0x{v:01X}");
756        }
757    }
758
759    #[test]
760    fn update_type_known_values() {
761        assert_eq!(
762            UpdateType::from_u8(0x0),
763            UpdateType::ProprietaryUpdateSolution
764        );
765        assert_eq!(UpdateType::from_u8(0x1), UpdateType::StandardUpdateCarousel);
766        assert_eq!(UpdateType::from_u8(0x2), UpdateType::UntCarousel);
767        assert_eq!(UpdateType::from_u8(0x3), UpdateType::UntReturnChannel);
768        assert_eq!(UpdateType::from_u8(0x4), UpdateType::UntInternet);
769        assert_eq!(UpdateType::from_u8(0x5), UpdateType::Reserved(0x5));
770        assert_eq!(
771            UpdateType::StandardUpdateCarousel.name(),
772            "standard update carousel"
773        );
774        assert_eq!(UpdateType::Reserved(0xF).name(), "reserved");
775    }
776}
dvb_si/descriptors/data_broadcast_id.rs

dvb_si/descriptors/
data_broadcast_id.rs
