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        let (id_bytes, id_selector) =
374            body.split_first_chunk::<ID_LEN>()
375                .ok_or(Error::InvalidDescriptor {
376                    tag: TAG,
377                    reason: "data_broadcast_id_descriptor body shorter than 2 bytes",
378                })?;
379        let data_broadcast_id = u16::from_be_bytes(*id_bytes);
380        Ok(Self {
381            data_broadcast_id,
382            id_selector,
383        })
384    }
385}
386
387impl Serialize for DataBroadcastIdDescriptor<'_> {
388    type Error = crate::error::Error;
389    fn serialized_len(&self) -> usize {
390        HEADER_LEN + ID_LEN + self.id_selector.len()
391    }
392
393    fn serialize_into(&self, buf: &mut [u8]) -> Result<usize> {
394        let len = self.serialized_len();
395        let body = ID_LEN + self.id_selector.len();
396        if body > u8::MAX as usize {
397            return Err(Error::InvalidDescriptor {
398                tag: TAG,
399                reason: "data_broadcast_id_descriptor body exceeds 255 bytes",
400            });
401        }
402        if buf.len() < len {
403            return Err(Error::OutputBufferTooSmall {
404                need: len,
405                have: buf.len(),
406            });
407        }
408        buf[0] = TAG;
409        buf[1] = body as u8;
410        buf[HEADER_LEN..HEADER_LEN + ID_LEN].copy_from_slice(&self.data_broadcast_id.to_be_bytes());
411        buf[HEADER_LEN + ID_LEN..len].copy_from_slice(self.id_selector);
412        Ok(len)
413    }
414}
415impl<'a> crate::traits::DescriptorDef<'a> for DataBroadcastIdDescriptor<'a> {
416    const TAG: u8 = TAG;
417    const NAME: &'static str = "DATA_BROADCAST_ID";
418}
419
420#[cfg(test)]
421mod tests {
422    use super::*;
423
424    // ── DataBroadcastIdDescriptor (non-SSU raw path) ──────────────────────────
425
426    #[test]
427    fn parse_extracts_id_and_raw_selector() {
428        let bytes = [TAG, 0x05, 0x00, 0x0B, 0xAA, 0xBB, 0xCC];
429        let d = DataBroadcastIdDescriptor::parse(&bytes).unwrap();
430        assert_eq!(d.data_broadcast_id, 0x000B);
431        assert_eq!(d.id_selector, &[0xAA, 0xBB, 0xCC][..]);
432        assert_eq!(
433            d.id_selector_decoded().unwrap(),
434            IdSelector::Raw(&[0xAA, 0xBB, 0xCC])
435        );
436    }
437
438    #[test]
439    fn parse_accepts_empty_raw_selector() {
440        // Non-SSU id with no selector bytes.
441        let bytes = [TAG, 0x02, 0x00, 0x0B];
442        let d = DataBroadcastIdDescriptor::parse(&bytes).unwrap();
443        assert_eq!(d.data_broadcast_id, 0x000B);
444        assert!(d.id_selector.is_empty());
445        assert_eq!(d.id_selector_decoded().unwrap(), IdSelector::Raw(&[]));
446    }
447
448    #[test]
449    fn data_broadcast_id_name_verified() {
450        assert_eq!(
451            data_broadcast_id_name(0x0005),
452            Some("Multiprotocol Encapsulation (MPE)")
453        );
454        assert_eq!(data_broadcast_id_name(0x0006), Some("Data Carousel"));
455        assert_eq!(data_broadcast_id_name(0x0007), Some("Object Carousel"));
456        assert_eq!(
457            data_broadcast_id_name(DATA_BROADCAST_ID_SSU),
458            Some("System Software Update (SSU)")
459        );
460        assert_eq!(
461            data_broadcast_id_name(0x000B),
462            Some("IP/MAC Notification (INT)")
463        );
464        assert_eq!(data_broadcast_id_name(0x00F0), Some("MHP Object Carousel"));
465        assert_eq!(data_broadcast_id_name(0x0123), Some("HbbTV"));
466    }
467
468    #[test]
469    fn data_broadcast_id_name_removed_entries_return_none() {
470        assert_eq!(data_broadcast_id_name(0x00F1), None);
471        assert_eq!(data_broadcast_id_name(0x00F2), None);
472        assert_eq!(data_broadcast_id_name(0x00F3), None);
473        assert_eq!(data_broadcast_id_name(0x00F4), None);
474    }
475
476    #[test]
477    fn data_broadcast_id_name_unknown() {
478        assert_eq!(data_broadcast_id_name(0x0000), None);
479        assert_eq!(data_broadcast_id_name(0xFFFF), None);
480    }
481
482    #[test]
483    fn parse_rejects_wrong_tag() {
484        let err = DataBroadcastIdDescriptor::parse(&[0x65, 0x02, 0x00, 0x0A]).unwrap_err();
485        assert!(matches!(err, Error::InvalidDescriptor { tag: 0x65, .. }));
486    }
487
488    #[test]
489    fn parse_rejects_short_buffer() {
490        let err = DataBroadcastIdDescriptor::parse(&[TAG]).unwrap_err();
491        assert!(matches!(err, Error::BufferTooShort { .. }));
492    }
493
494    #[test]
495    fn parse_rejects_body_too_short() {
496        // length=1: not even the 16-bit id fits.
497        let err = DataBroadcastIdDescriptor::parse(&[TAG, 0x01, 0x00]).unwrap_err();
498        assert!(matches!(err, Error::InvalidDescriptor { .. }));
499    }
500
501    #[test]
502    fn parse_rejects_length_overrun() {
503        // length=5 but only 3 payload bytes available.
504        let err = DataBroadcastIdDescriptor::parse(&[TAG, 0x05, 0x00, 0x0B, 0xAA]).unwrap_err();
505        assert!(matches!(err, Error::BufferTooShort { .. }));
506    }
507
508    #[test]
509    fn raw_round_trip() {
510        let d = DataBroadcastIdDescriptor {
511            data_broadcast_id: 0x0123,
512            id_selector: &[0xDE, 0xAD, 0xBE, 0xEF],
513        };
514        let mut buf = vec![0u8; d.serialized_len()];
515        d.serialize_into(&mut buf).unwrap();
516        let re = DataBroadcastIdDescriptor::parse(&buf).unwrap();
517        assert_eq!(d, re);
518    }
519
520    #[test]
521    fn serialize_rejects_too_small_buffer() {
522        let d = DataBroadcastIdDescriptor {
523            data_broadcast_id: 0x0001,
524            id_selector: &[0x01],
525        };
526        let mut tiny = [0u8; 2];
527        let err = d.serialize_into(&mut tiny).unwrap_err();
528        assert!(matches!(err, Error::OutputBufferTooSmall { .. }));
529    }
530
531    #[test]
532    fn serialize_rejects_over_range_body() {
533        // 254 selector bytes + 2 id bytes = 256 > 255.
534        let sel = vec![0u8; 254];
535        let d = DataBroadcastIdDescriptor {
536            data_broadcast_id: 0x0001,
537            id_selector: &sel,
538        };
539        let mut buf = vec![0u8; d.serialized_len()];
540        let err = d.serialize_into(&mut buf).unwrap_err();
541        assert!(matches!(err, Error::InvalidDescriptor { tag: TAG, .. }));
542    }
543
544    #[cfg(feature = "serde")]
545    #[test]
546    fn serde_serialize_is_stable() {
547        let d = DataBroadcastIdDescriptor {
548            data_broadcast_id: 0x000B,
549            id_selector: &[0x01, 0x02],
550        };
551        let json = serde_json::to_string(&d).unwrap();
552        assert!(json.contains("\"data_broadcast_id\""));
553        assert!(json.contains("\"id_selector\""));
554        assert!(json.contains("11"));
555    }
556
557    // ── SsuIdSelector (data_broadcast_id = 0x000A) ───────────────────────────
558
559    /// Hand-built wire bytes for an SSU id_selector with one OUI entry and
560    /// no private data.
561    ///
562    /// Wire layout (inside the descriptor body, after the 2-byte
563    /// data_broadcast_id field):
564    ///
565    /// ```text
566    /// [0]    OUI_data_length = 0x09  (9 bytes = 1 entry × 6 fixed + 3 selector)
567    /// [1..4] OUI = 00:15:0A
568    /// [4]    0x02 = reserved(4)|update_type(4=0x2, UNT carousel)
569    /// [5]    0x61 = reserved(2)|uvf(1=1)|uversion(5=0x01)
570    ///              i.e. 0b00_1_00001 = 0x21 ... wait:
571    ///              uvf bit5 = 0x20, uversion = 0x01 → 0x21
572    /// [6]    selector_length = 0x03
573    /// [7..10] selector bytes = AA BB CC
574    /// [10]   (OUI loop ends; private_data empty)
575    /// Total = 10 bytes
576    /// ```
577    fn sample_ssu_selector() -> SsuIdSelector<'static> {
578        SsuIdSelector {
579            oui_entries: vec![SsuOuiEntry {
580                oui: [0x00, 0x15, 0x0A],
581                update_type: UpdateType::UntCarousel,
582                update_versioning_flag: true,
583                update_version: 0x01,
584                selector: &[0xAA, 0xBB, 0xCC],
585            }],
586            private_data: &[],
587        }
588    }
589
590    #[test]
591    fn ssu_selector_hand_built_byte_anchor() {
592        // OUI_data_length=9 (= 6 fixed + 3 selector), OUI=00:15:0A,
593        // byte3=0x02 (update_type=2), byte4=0x21 (uvf=1,uversion=1),
594        // selector_length=3, AA BB CC.
595        #[rustfmt::skip]
596        let expected: &[u8] = &[
597            0x09,                   // OUI_data_length = 9
598            0x00, 0x15, 0x0A,       // OUI
599            0x02,                   // reserved(0)|update_type(2)
600            0x21,                   // reserved(0)|uvf(1)|uversion(1)
601            0x03,                   // selector_length = 3
602            0xAA, 0xBB, 0xCC,       // selector bytes
603        ];
604        let s = sample_ssu_selector();
605        let mut buf = vec![0u8; s.serialized_len()];
606        s.serialize_into(&mut buf).unwrap();
607        assert_eq!(buf.as_slice(), expected);
608        let re = SsuIdSelector::parse(expected).unwrap();
609        assert_eq!(re, s);
610    }
611
612    #[test]
613    fn ssu_selector_round_trip() {
614        let s = sample_ssu_selector();
615        let mut buf = vec![0u8; s.serialized_len()];
616        s.serialize_into(&mut buf).unwrap();
617        let re = SsuIdSelector::parse(&buf).unwrap();
618        assert_eq!(re, s);
619        let mut buf2 = vec![0u8; re.serialized_len()];
620        re.serialize_into(&mut buf2).unwrap();
621        assert_eq!(buf, buf2, "SSU selector byte-exact re-serialize");
622    }
623
624    #[test]
625    fn ssu_selector_empty_oui_loop() {
626        let s = SsuIdSelector {
627            oui_entries: vec![],
628            private_data: &[0xDE, 0xAD],
629        };
630        let mut buf = vec![0u8; s.serialized_len()];
631        s.serialize_into(&mut buf).unwrap();
632        // OUI_data_length=0, then 2 private bytes.
633        assert_eq!(buf[0], 0x00);
634        assert_eq!(&buf[1..], &[0xDE, 0xAD]);
635        let re = SsuIdSelector::parse(&buf).unwrap();
636        assert_eq!(re, s);
637    }
638
639    #[test]
640    fn ssu_selector_no_versioning_flag() {
641        let s = SsuIdSelector {
642            oui_entries: vec![SsuOuiEntry {
643                oui: [0x00, 0x00, 0x00],
644                update_type: UpdateType::StandardUpdateCarousel,
645                update_versioning_flag: false,
646                update_version: 0x00,
647                selector: &[],
648            }],
649            private_data: &[],
650        };
651        let mut buf = vec![0u8; s.serialized_len()];
652        s.serialize_into(&mut buf).unwrap();
653        // Wire layout: [0]=OUI_data_length, [1..4]=OUI, [4]=byte3(update_type),
654        // [5]=byte4(uvf|uversion), [6]=selector_length.
655        // StandardUpdateCarousel.to_u8() = 0x01
656        assert_eq!(buf[4], 0x01); // byte3: update_type = 1
657        assert_eq!(buf[5], 0x00); // byte4: uvf=0, uversion=0
658        let re = SsuIdSelector::parse(&buf).unwrap();
659        assert_eq!(re, s);
660    }
661
662    /// End-to-end: DataBroadcastIdDescriptor with data_broadcast_id=0x000A
663    /// dispatches to IdSelector::Ssu.
664    ///
665    /// Wire layout (complete descriptor):
666    ///
667    /// ```text
668    /// [0]    tag = 0x66
669    /// [1]    length = 2 + 10 = 12
670    ///           (2 for data_broadcast_id + 10 for SSU selector)
671    /// [2..4] data_broadcast_id = 0x00 0x0A
672    /// [4..14] SSU id_selector (OUI_data_length=9, …)
673    /// ```
674    #[test]
675    fn descriptor_ssu_round_trip() {
676        let sel = sample_ssu_selector();
677        let mut sel_bytes = vec![0u8; sel.serialized_len()];
678        sel.serialize_into(&mut sel_bytes).unwrap();
679        let d = DataBroadcastIdDescriptor {
680            data_broadcast_id: DATA_BROADCAST_ID_SSU,
681            id_selector: &sel_bytes,
682        };
683        let mut buf = vec![0u8; d.serialized_len()];
684        d.serialize_into(&mut buf).unwrap();
685        // Sanity-check descriptor framing.
686        assert_eq!(buf[0], TAG);
687        assert_eq!(buf[1] as usize, ID_LEN + sel.serialized_len());
688        assert_eq!(&buf[2..4], &[0x00, 0x0A]); // data_broadcast_id
689        let re = DataBroadcastIdDescriptor::parse(&buf).unwrap();
690        assert_eq!(re, d);
691        // The raw id_selector decodes to the typed SSU selector.
692        assert_eq!(
693            re.id_selector_decoded().unwrap(),
694            IdSelector::Ssu(sample_ssu_selector())
695        );
696        // Byte-identical re-serialize.
697        let mut buf2 = vec![0u8; re.serialized_len()];
698        re.serialize_into(&mut buf2).unwrap();
699        assert_eq!(buf, buf2, "SSU descriptor byte-exact re-serialize");
700    }
701
702    #[test]
703    fn ssu_selector_parse_rejects_truncated_oui_loop() {
704        // OUI_data_length=6 but only 2 bytes follow.
705        let bytes = &[0x06, 0x00, 0x15];
706        assert!(matches!(
707            SsuIdSelector::parse(bytes).unwrap_err(),
708            Error::InvalidDescriptor { .. }
709        ));
710    }
711
712    #[test]
713    fn ssu_selector_parse_rejects_selector_overflows_oui_loop() {
714        // OUI_data_length=6 (exactly 1 entry with selector_length=0),
715        // but we set selector_length=5 which would overflow the oui loop.
716        #[rustfmt::skip]
717        let bytes = &[
718            0x06,                   // OUI_data_length = 6
719            0x00, 0x15, 0x0A,       // OUI
720            0x02,                   // byte3
721            0x21,                   // byte4
722            0x05,                   // selector_length=5 — overflows OUI loop
723        ];
724        assert!(matches!(
725            SsuIdSelector::parse(bytes).unwrap_err(),
726            Error::InvalidDescriptor { .. }
727        ));
728    }
729
730    #[cfg(feature = "serde")]
731    #[test]
732    fn ssu_descriptor_serde_json() {
733        let sel = sample_ssu_selector();
734        let mut sel_bytes = vec![0u8; sel.serialized_len()];
735        sel.serialize_into(&mut sel_bytes).unwrap();
736        let d = DataBroadcastIdDescriptor {
737            data_broadcast_id: DATA_BROADCAST_ID_SSU,
738            id_selector: &sel_bytes,
739        };
740        let json = serde_json::to_string(&d).unwrap();
741        assert!(json.contains("\"data_broadcast_id\":10"));
742        // The typed SSU fields appear in the decoded selector's JSON.
743        let decoded = d.id_selector_decoded().unwrap();
744        let sj = serde_json::to_string(&decoded).unwrap();
745        assert!(sj.contains("\"update_type\""));
746        assert!(sj.contains("\"update_versioning_flag\":true"));
747        assert!(sj.contains("\"update_version\":1"));
748    }
749
750    #[test]
751    fn update_type_full_range_round_trip() {
752        for v in 0u8..=0x0F {
753            let ut = UpdateType::from_u8(v);
754            assert_eq!(ut.to_u8(), v, "UpdateType round-trip failed for 0x{v:01X}");
755        }
756    }
757
758    #[test]
759    fn update_type_known_values() {
760        assert_eq!(
761            UpdateType::from_u8(0x0),
762            UpdateType::ProprietaryUpdateSolution
763        );
764        assert_eq!(UpdateType::from_u8(0x1), UpdateType::StandardUpdateCarousel);
765        assert_eq!(UpdateType::from_u8(0x2), UpdateType::UntCarousel);
766        assert_eq!(UpdateType::from_u8(0x3), UpdateType::UntReturnChannel);
767        assert_eq!(UpdateType::from_u8(0x4), UpdateType::UntInternet);
768        assert_eq!(UpdateType::from_u8(0x5), UpdateType::Reserved(0x5));
769        assert_eq!(
770            UpdateType::StandardUpdateCarousel.name(),
771            "standard update carousel"
772        );
773        assert_eq!(UpdateType::Reserved(0xF).name(), "reserved");
774    }
775}
dvb_si/descriptors/data_broadcast_id.rs

dvb_si/descriptors/
data_broadcast_id.rs
