dvb_si/descriptors/
multilingual_bouquet_name.rs

1//! Multilingual Bouquet Name Descriptor — ETSI EN 300 468 §6.2.22 (tag 0x5C).
2//!
3//! Table 76 (PDF p. 93). Carried in the BAT. A loop of (ISO 639-2 language
4//! code, bouquet name) pairs, each name length-prefixed by an 8-bit field.
5
6use super::descriptor_body;
7use crate::error::{Error, Result};
8use crate::text::{DvbText, LangCode};
9use dvb_common::{Parse, Serialize};
10
11/// Descriptor tag for multilingual_bouquet_name_descriptor.
12pub const TAG: u8 = 0x5C;
13const HEADER_LEN: usize = 2;
14const LANG_LEN: usize = 3;
15const NAME_LEN_FIELD: usize = 1;
16
17/// One localised bouquet name.
18#[derive(Debug, Clone, PartialEq, Eq)]
19#[cfg_attr(feature = "serde", derive(serde::Serialize))]
20#[cfg_attr(feature = "yoke", derive(yoke::Yokeable))]
21pub struct BouquetNameEntry<'a> {
22    /// ISO 639-2 language code.
23    pub language_code: LangCode,
24    /// DVB Annex-A encoded bouquet name.
25    pub bouquet_name: DvbText<'a>,
26}
27
28/// Multilingual Bouquet Name Descriptor (tag 0x5C).
29#[derive(Debug, Clone, PartialEq, Eq)]
30#[cfg_attr(feature = "serde", derive(serde::Serialize))]
31#[cfg_attr(feature = "yoke", derive(yoke::Yokeable))]
32pub struct MultilingualBouquetNameDescriptor<'a> {
33    /// Localised names in wire order.
34    pub entries: Vec<BouquetNameEntry<'a>>,
35}
36
37impl<'a> Parse<'a> for MultilingualBouquetNameDescriptor<'a> {
38    type Error = crate::error::Error;
39    fn parse(bytes: &'a [u8]) -> Result<Self> {
40        let body = descriptor_body(
41            bytes,
42            TAG,
43            "MultilingualBouquetNameDescriptor",
44            "unexpected tag for multilingual_bouquet_name_descriptor",
45        )?;
46        let mut entries = Vec::new();
47        let mut pos = 0;
48        while pos < body.len() {
49            if pos + LANG_LEN + NAME_LEN_FIELD > body.len() {
50                return Err(Error::InvalidDescriptor {
51                    tag: TAG,
52                    reason: "entry header runs past descriptor end",
53                });
54            }
55            let language_code = LangCode([body[pos], body[pos + 1], body[pos + 2]]);
56            let name_len = body[pos + LANG_LEN] as usize;
57            let name_start = pos + LANG_LEN + NAME_LEN_FIELD;
58            let name_end = name_start + name_len;
59            if name_end > body.len() {
60                return Err(Error::InvalidDescriptor {
61                    tag: TAG,
62                    reason: "name_length runs past descriptor end",
63                });
64            }
65            entries.push(BouquetNameEntry {
66                language_code,
67                bouquet_name: DvbText::new(&body[name_start..name_end]),
68            });
69            pos = name_end;
70        }
71        Ok(Self { entries })
72    }
73}
74
75impl Serialize for MultilingualBouquetNameDescriptor<'_> {
76    type Error = crate::error::Error;
77    fn serialized_len(&self) -> usize {
78        HEADER_LEN
79            + self
80                .entries
81                .iter()
82                .map(|e| LANG_LEN + NAME_LEN_FIELD + e.bouquet_name.len())
83                .sum::<usize>()
84    }
85
86    fn serialize_into(&self, buf: &mut [u8]) -> Result<usize> {
87        for e in &self.entries {
88            if e.bouquet_name.len() > u8::MAX as usize {
89                return Err(Error::InvalidDescriptor {
90                    tag: TAG,
91                    reason: "bouquet_name exceeds 255 bytes (name_length is 8-bit)",
92                });
93            }
94        }
95        let len = self.serialized_len();
96        let body = len - HEADER_LEN;
97        if body > u8::MAX as usize {
98            return Err(Error::InvalidDescriptor {
99                tag: TAG,
100                reason: "multilingual_bouquet_name_descriptor body exceeds 255 bytes",
101            });
102        }
103        if buf.len() < len {
104            return Err(Error::OutputBufferTooSmall {
105                need: len,
106                have: buf.len(),
107            });
108        }
109        buf[0] = TAG;
110        buf[1] = body as u8;
111        let mut pos = HEADER_LEN;
112        for e in &self.entries {
113            buf[pos..pos + LANG_LEN].copy_from_slice(&e.language_code.0);
114            buf[pos + LANG_LEN] = e.bouquet_name.len() as u8;
115            let name_start = pos + LANG_LEN + NAME_LEN_FIELD;
116            buf[name_start..name_start + e.bouquet_name.len()]
117                .copy_from_slice(e.bouquet_name.raw());
118            pos = name_start + e.bouquet_name.len();
119        }
120        Ok(len)
121    }
122}
123impl<'a> crate::traits::DescriptorDef<'a> for MultilingualBouquetNameDescriptor<'a> {
124    const TAG: u8 = TAG;
125    const NAME: &'static str = "MULTILINGUAL_BOUQUET_NAME";
126}
127
128#[cfg(test)]
129mod tests {
130    use super::*;
131
132    fn build(entries: &[([u8; 3], &[u8])]) -> Vec<u8> {
133        let body: usize = entries.iter().map(|(_, n)| LANG_LEN + 1 + n.len()).sum();
134        let mut v = Vec::with_capacity(HEADER_LEN + body);
135        v.push(TAG);
136        v.push(body as u8);
137        for (lang, name) in entries {
138            v.extend_from_slice(lang);
139            v.push(name.len() as u8);
140            v.extend_from_slice(name);
141        }
142        v
143    }
144
145    #[test]
146    fn parse_single_entry() {
147        let bytes = build(&[(*b"eng", b"Sky")]);
148        let d = MultilingualBouquetNameDescriptor::parse(&bytes).unwrap();
149        assert_eq!(d.entries.len(), 1);
150        assert_eq!(d.entries[0].language_code, LangCode(*b"eng"));
151        assert_eq!(d.entries[0].bouquet_name.raw(), b"Sky");
152    }
153
154    #[test]
155    fn parse_multiple_entries() {
156        let bytes = build(&[(*b"eng", b"Pack"), (*b"fra", b"Bouquet")]);
157        let d = MultilingualBouquetNameDescriptor::parse(&bytes).unwrap();
158        assert_eq!(d.entries.len(), 2);
159        assert_eq!(d.entries[1].bouquet_name.raw(), b"Bouquet");
160    }
161
162    #[test]
163    fn parse_rejects_wrong_tag() {
164        let err = MultilingualBouquetNameDescriptor::parse(&[0x5B, 0]).unwrap_err();
165        assert!(matches!(err, Error::InvalidDescriptor { tag: 0x5B, .. }));
166    }
167
168    #[test]
169    fn parse_rejects_short_buffer() {
170        let err = MultilingualBouquetNameDescriptor::parse(&[TAG]).unwrap_err();
171        assert!(matches!(err, Error::BufferTooShort { .. }));
172    }
173
174    #[test]
175    fn parse_rejects_name_length_overrun() {
176        let bytes = [TAG, 5, b'e', b'n', b'g', 100, 0];
177        let err = MultilingualBouquetNameDescriptor::parse(&bytes).unwrap_err();
178        assert!(matches!(err, Error::InvalidDescriptor { .. }));
179    }
180
181    #[test]
182    fn parse_rejects_truncated_entry_header() {
183        let bytes = [TAG, 2, b'e', b'n'];
184        let err = MultilingualBouquetNameDescriptor::parse(&bytes).unwrap_err();
185        assert!(matches!(err, Error::InvalidDescriptor { .. }));
186    }
187
188    #[test]
189    fn empty_descriptor_valid() {
190        let d = MultilingualBouquetNameDescriptor::parse(&[TAG, 0]).unwrap();
191        assert_eq!(d.entries.len(), 0);
192    }
193
194    #[test]
195    fn serialize_round_trip() {
196        let bytes = build(&[(*b"eng", b"Bouquet"), (*b"deu", b"Paket")]);
197        let parsed = MultilingualBouquetNameDescriptor::parse(&bytes).unwrap();
198        let mut buf = vec![0u8; parsed.serialized_len()];
199        parsed.serialize_into(&mut buf).unwrap();
200        assert_eq!(buf, bytes);
201        let re = MultilingualBouquetNameDescriptor::parse(&buf).unwrap();
202        assert_eq!(parsed, re);
203    }
204
205    #[test]
206    fn serialize_rejects_too_small_buffer() {
207        let d = MultilingualBouquetNameDescriptor {
208            entries: vec![BouquetNameEntry {
209                language_code: LangCode(*b"eng"),
210                bouquet_name: DvbText::new(b"X"),
211            }],
212        };
213        let mut tiny = [0u8; 3];
214        let err = d.serialize_into(&mut tiny).unwrap_err();
215        assert!(matches!(err, Error::OutputBufferTooSmall { .. }));
216    }
217
218    #[test]
219    fn serialize_rejects_over_range_name() {
220        let name = vec![0u8; 256];
221        let d = MultilingualBouquetNameDescriptor {
222            entries: vec![BouquetNameEntry {
223                language_code: LangCode(*b"eng"),
224                bouquet_name: DvbText::new(&name),
225            }],
226        };
227        let mut buf = vec![0u8; d.serialized_len()];
228        let err = d.serialize_into(&mut buf).unwrap_err();
229        assert!(matches!(err, Error::InvalidDescriptor { tag: TAG, .. }));
230    }
231
232    #[cfg(feature = "serde")]
233    #[test]
234    fn serde_serialize_is_stable() {
235        let d = MultilingualBouquetNameDescriptor {
236            entries: vec![BouquetNameEntry {
237                language_code: LangCode(*b"eng"),
238                bouquet_name: DvbText::new(b"Sky"),
239            }],
240        };
241        let json = serde_json::to_string(&d).unwrap();
242        assert!(json.contains("\"language_code\""));
243        assert!(json.contains("\"eng\""));
244        assert!(json.contains("\"Sky\""));
245    }
246}
dvb_si/descriptors/multilingual_bouquet_name.rs

dvb_si/descriptors/
multilingual_bouquet_name.rs
