dvb_si/descriptors/
multilingual_network_name.rs

1//! Multilingual Network Name Descriptor — ETSI EN 300 468 §6.2.24 (tag 0x5B).
2//!
3//! Table 78 (PDF p. 94). Carried in the NIT. A loop of (ISO 639-2 language
4//! code, network 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_network_name_descriptor.
12pub const TAG: u8 = 0x5B;
13const HEADER_LEN: usize = 2;
14const LANG_LEN: usize = 3;
15const NAME_LEN_FIELD: usize = 1;
16
17/// One localised network 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 NetworkNameEntry<'a> {
22    /// ISO 639-2 language code.
23    pub language_code: LangCode,
24    /// DVB Annex-A encoded network name.
25    pub network_name: DvbText<'a>,
26}
27
28/// Multilingual Network Name Descriptor (tag 0x5B).
29#[derive(Debug, Clone, PartialEq, Eq)]
30#[cfg_attr(feature = "serde", derive(serde::Serialize))]
31#[cfg_attr(feature = "yoke", derive(yoke::Yokeable))]
32pub struct MultilingualNetworkNameDescriptor<'a> {
33    /// Localised names in wire order.
34    pub entries: Vec<NetworkNameEntry<'a>>,
35}
36
37impl<'a> Parse<'a> for MultilingualNetworkNameDescriptor<'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            "MultilingualNetworkNameDescriptor",
44            "unexpected tag for multilingual_network_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(NetworkNameEntry {
66                language_code,
67                network_name: DvbText::new(&body[name_start..name_end]),
68            });
69            pos = name_end;
70        }
71        Ok(Self { entries })
72    }
73}
74
75impl Serialize for MultilingualNetworkNameDescriptor<'_> {
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.network_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.network_name.len() > u8::MAX as usize {
89                return Err(Error::InvalidDescriptor {
90                    tag: TAG,
91                    reason: "network_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_network_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.network_name.len() as u8;
115            let name_start = pos + LANG_LEN + NAME_LEN_FIELD;
116            buf[name_start..name_start + e.network_name.len()]
117                .copy_from_slice(e.network_name.raw());
118            pos = name_start + e.network_name.len();
119        }
120        Ok(len)
121    }
122}
123impl<'a> crate::traits::DescriptorDef<'a> for MultilingualNetworkNameDescriptor<'a> {
124    const TAG: u8 = TAG;
125    const NAME: &'static str = "MULTILINGUAL_NETWORK_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"BBC")]);
148        let d = MultilingualNetworkNameDescriptor::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].network_name.raw(), b"BBC");
152    }
153
154    #[test]
155    fn parse_multiple_entries() {
156        let bytes = build(&[(*b"eng", b"Net"), (*b"fra", b"Reseau")]);
157        let d = MultilingualNetworkNameDescriptor::parse(&bytes).unwrap();
158        assert_eq!(d.entries.len(), 2);
159        assert_eq!(d.entries[1].network_name.raw(), b"Reseau");
160    }
161
162    #[test]
163    fn parse_rejects_wrong_tag() {
164        let err = MultilingualNetworkNameDescriptor::parse(&[0x5C, 0]).unwrap_err();
165        assert!(matches!(err, Error::InvalidDescriptor { tag: 0x5C, .. }));
166    }
167
168    #[test]
169    fn parse_rejects_short_buffer() {
170        let err = MultilingualNetworkNameDescriptor::parse(&[TAG]).unwrap_err();
171        assert!(matches!(err, Error::BufferTooShort { .. }));
172    }
173
174    #[test]
175    fn parse_rejects_name_length_overrun() {
176        // name_len=100 but body only carries a few bytes.
177        let bytes = [TAG, 5, b'e', b'n', b'g', 100, 0];
178        let err = MultilingualNetworkNameDescriptor::parse(&bytes).unwrap_err();
179        assert!(matches!(err, Error::InvalidDescriptor { .. }));
180    }
181
182    #[test]
183    fn parse_rejects_truncated_entry_header() {
184        // Only 2 bytes of a language code present in the body.
185        let bytes = [TAG, 2, b'e', b'n'];
186        let err = MultilingualNetworkNameDescriptor::parse(&bytes).unwrap_err();
187        assert!(matches!(err, Error::InvalidDescriptor { .. }));
188    }
189
190    #[test]
191    fn empty_descriptor_valid() {
192        let d = MultilingualNetworkNameDescriptor::parse(&[TAG, 0]).unwrap();
193        assert_eq!(d.entries.len(), 0);
194    }
195
196    #[test]
197    fn serialize_round_trip() {
198        let bytes = build(&[(*b"eng", b"Network"), (*b"deu", b"Netz")]);
199        let parsed = MultilingualNetworkNameDescriptor::parse(&bytes).unwrap();
200        let mut buf = vec![0u8; parsed.serialized_len()];
201        parsed.serialize_into(&mut buf).unwrap();
202        assert_eq!(buf, bytes);
203        let re = MultilingualNetworkNameDescriptor::parse(&buf).unwrap();
204        assert_eq!(parsed, re);
205    }
206
207    #[test]
208    fn serialize_rejects_too_small_buffer() {
209        let d = MultilingualNetworkNameDescriptor {
210            entries: vec![NetworkNameEntry {
211                language_code: LangCode(*b"eng"),
212                network_name: DvbText::new(b"X"),
213            }],
214        };
215        let mut tiny = [0u8; 3];
216        let err = d.serialize_into(&mut tiny).unwrap_err();
217        assert!(matches!(err, Error::OutputBufferTooSmall { .. }));
218    }
219
220    #[test]
221    fn serialize_rejects_over_range_name() {
222        let name = vec![0u8; 256];
223        let d = MultilingualNetworkNameDescriptor {
224            entries: vec![NetworkNameEntry {
225                language_code: LangCode(*b"eng"),
226                network_name: DvbText::new(&name),
227            }],
228        };
229        let mut buf = vec![0u8; d.serialized_len()];
230        let err = d.serialize_into(&mut buf).unwrap_err();
231        assert!(matches!(err, Error::InvalidDescriptor { tag: TAG, .. }));
232    }
233
234    #[cfg(feature = "serde")]
235    #[test]
236    fn serde_serialize_is_stable() {
237        let d = MultilingualNetworkNameDescriptor {
238            entries: vec![NetworkNameEntry {
239                language_code: LangCode(*b"eng"),
240                network_name: DvbText::new(b"BBC"),
241            }],
242        };
243        let json = serde_json::to_string(&d).unwrap();
244        assert!(json.contains("\"language_code\""));
245        assert!(json.contains("\"eng\""));
246        assert!(json.contains("\"BBC\""));
247    }
248}
dvb_si/descriptors/multilingual_network_name.rs

dvb_si/descriptors/
multilingual_network_name.rs
