Skip to main content

fx_torrent/bencode/
value.rs

1use crate::bencode::{Error, Result};
2use serde::de::{Error as _, IntoDeserializer, Unexpected};
3use serde::ser::{SerializeMap, SerializeSeq};
4use serde::{de, forward_to_deserialize_any, Deserializer, Serialize, Serializer};
5use serde_bytes::{ByteBuf, Bytes};
6use std::collections::HashMap;
7use std::{fmt, result};
8
9/// A bencode value that can represent any type.
10#[derive(PartialEq, Eq, Clone, Debug)]
11pub enum Value {
12    /// A generic list of bytes.
13    Bytes(Vec<u8>),
14    /// An integer.
15    Int(i64),
16    /// A list of other bencoded values.
17    List(Vec<Value>),
18    /// A map of (key, value) pairs.
19    Dict(HashMap<Vec<u8>, Value>),
20}
21
22impl Serialize for Value {
23    #[inline]
24    fn serialize<S>(&self, s: S) -> result::Result<S::Ok, S::Error>
25    where
26        S: Serializer,
27    {
28        match *self {
29            Value::Bytes(ref v) => s.serialize_bytes(v),
30            Value::Int(v) => s.serialize_i64(v),
31            Value::List(ref v) => {
32                let mut seq = s.serialize_seq(Some(v.len()))?;
33                for e in v {
34                    seq.serialize_element(e)?;
35                }
36                seq.end()
37            }
38            Value::Dict(ref vs) => {
39                let mut map = s.serialize_map(Some(vs.len()))?;
40                for (k, v) in vs {
41                    map.serialize_entry(&Bytes::new(k), v)?;
42                }
43                map.end()
44            }
45        }
46    }
47}
48
49impl<'de> Deserializer<'de> for &'de Value {
50    type Error = Error;
51
52    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value>
53    where
54        V: de::Visitor<'de>,
55    {
56        match self {
57            Value::Int(i) => visitor.visit_i64(*i),
58            Value::Bytes(v) => visitor.visit_bytes(v.as_slice()),
59            Value::List(v) => {
60                let mut seq = de::value::SeqDeserializer::new(v.iter());
61                visitor.visit_seq(&mut seq)
62            }
63            Value::Dict(v) => {
64                let mut map =
65                    de::value::MapDeserializer::new(v.iter().map(|(k, v)| (k.as_slice(), v)));
66                visitor.visit_map(&mut map)
67            }
68        }
69    }
70
71    // bencoded strings are just bytes, so we attempt to treat them as UTF-8 here
72    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value>
73    where
74        V: de::Visitor<'de>,
75    {
76        match self {
77            Value::Bytes(v) => {
78                let s = String::from_utf8(v.clone()).map_err(|e| {
79                    Error::invalid_value(Unexpected::Bytes(&e.into_bytes()), &"valid utf-8")
80                })?;
81                visitor.visit_string(s)
82            }
83            _ => self.deserialize_any(visitor),
84        }
85    }
86
87    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value>
88    where
89        V: de::Visitor<'de>,
90    {
91        self.deserialize_str(visitor)
92    }
93
94    fn deserialize_enum<V>(
95        self,
96        _name: &'static str,
97        _variants: &'static [&'static str],
98        visitor: V,
99    ) -> Result<V::Value>
100    where
101        V: de::Visitor<'de>,
102    {
103        match self {
104            Value::Bytes(v) => {
105                let s = String::from_utf8(v.clone()).map_err(|e| {
106                    Error::invalid_value(Unexpected::Bytes(&e.into_bytes()), &"valid utf-8")
107                })?;
108                visitor.visit_enum(s.into_deserializer())
109            }
110            Value::Dict(ref v) => {
111                let (key, value) = v
112                    .iter()
113                    .next()
114                    .ok_or(Error::invalid_length(v.len(), &"map with 1 entry"))?;
115                let s = str::from_utf8(key)
116                    .map_err(|_| Error::invalid_value(Unexpected::Bytes(key), &"valid utf-8"))?;
117                visitor.visit_enum(EnumDeserializer {
118                    variant: s,
119                    value: &value,
120                })
121            }
122            _ => Err(Error::invalid_type(Unexpected::Unit, &"string or map")),
123        }
124    }
125
126    fn deserialize_option<V>(self, visitor: V) -> result::Result<V::Value, Self::Error>
127    where
128        V: de::Visitor<'de>,
129    {
130        visitor.visit_some(self)
131    }
132
133    fn deserialize_bool<V>(self, visitor: V) -> result::Result<V::Value, Self::Error>
134    where
135        V: de::Visitor<'de>,
136    {
137        let val = match self {
138            Value::Int(i) => Ok(*i == 1),
139            Value::Bytes(e) => Err(Error::invalid_type(Unexpected::Bytes(e), &"bool")),
140            Value::List(_) => Err(Error::invalid_type(Unexpected::Seq, &"bool")),
141            Value::Dict(_) => Err(Error::invalid_type(Unexpected::Map, &"bool")),
142        }?;
143        visitor.visit_bool(val)
144    }
145
146    forward_to_deserialize_any! {
147        char i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 unit unit_struct
148        seq map tuple_struct struct identifier tuple ignored_any bytes
149        byte_buf newtype_struct
150    }
151}
152
153impl<'de> IntoDeserializer<'de, Error> for &'de Value {
154    type Deserializer = Self;
155    fn into_deserializer(self) -> Self::Deserializer {
156        self
157    }
158}
159
160#[derive(Debug)]
161struct ValueVisitor;
162impl<'de> de::Visitor<'de> for ValueVisitor {
163    type Value = Value;
164
165    fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
166        formatter.write_str("any valid bencode value")
167    }
168
169    #[inline]
170    fn visit_i64<E>(self, value: i64) -> result::Result<Value, E> {
171        Ok(Value::Int(value))
172    }
173
174    #[inline]
175    fn visit_u64<E>(self, value: u64) -> result::Result<Value, E> {
176        Ok(Value::Int(value as i64))
177    }
178
179    #[inline]
180    fn visit_str<E>(self, value: &str) -> result::Result<Value, E>
181    where
182        E: de::Error,
183    {
184        Ok(Value::Bytes(value.into()))
185    }
186
187    #[inline]
188    fn visit_string<E>(self, value: String) -> result::Result<Value, E> {
189        Ok(Value::Bytes(value.into()))
190    }
191
192    #[inline]
193    fn visit_bytes<E>(self, value: &[u8]) -> result::Result<Value, E> {
194        Ok(Value::Bytes(value.into()))
195    }
196
197    #[inline]
198    fn visit_seq<V>(self, mut access: V) -> result::Result<Value, V::Error>
199    where
200        V: de::SeqAccess<'de>,
201    {
202        let mut seq = Vec::new();
203        while let Some(e) = access.next_element()? {
204            seq.push(e);
205        }
206        Ok(Value::List(seq))
207    }
208
209    #[inline]
210    fn visit_map<V>(self, mut access: V) -> result::Result<Value, V::Error>
211    where
212        V: de::MapAccess<'de>,
213    {
214        let mut map = HashMap::new();
215        while let Some((k, v)) = access.next_entry::<ByteBuf, _>()? {
216            map.insert(k.into_vec(), v);
217        }
218        Ok(Value::Dict(map))
219    }
220}
221
222impl<'de> de::Deserialize<'de> for Value {
223    #[inline]
224    fn deserialize<D>(deserializer: D) -> result::Result<Value, D::Error>
225    where
226        D: Deserializer<'de>,
227    {
228        deserializer.deserialize_any(ValueVisitor)
229    }
230}
231
232impl From<i64> for Value {
233    fn from(v: i64) -> Value {
234        Value::Int(v)
235    }
236}
237
238impl From<String> for Value {
239    fn from(s: String) -> Value {
240        Value::Bytes(s.into_bytes())
241    }
242}
243
244impl<'a> From<&'a str> for Value {
245    fn from(v: &str) -> Value {
246        Value::Bytes(v.as_bytes().to_vec())
247    }
248}
249
250impl From<Vec<u8>> for Value {
251    fn from(v: Vec<u8>) -> Value {
252        Value::Bytes(v)
253    }
254}
255
256impl From<Vec<Value>> for Value {
257    fn from(v: Vec<Value>) -> Value {
258        Value::List(v)
259    }
260}
261
262impl From<HashMap<Vec<u8>, Value>> for Value {
263    fn from(v: HashMap<Vec<u8>, Value>) -> Value {
264        Value::Dict(v)
265    }
266}
267
268#[derive(Debug)]
269struct EnumDeserializer<'de> {
270    variant: &'de str,
271    value: &'de Value,
272}
273
274impl<'de> de::EnumAccess<'de> for EnumDeserializer<'de> {
275    type Error = Error;
276    type Variant = Self;
277
278    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant)>
279    where
280        V: de::DeserializeSeed<'de>,
281    {
282        let variant_de: de::value::StrDeserializer<Error> = self.variant.into_deserializer();
283        let variant = seed.deserialize(variant_de)?;
284        Ok((variant, self))
285    }
286}
287
288impl<'de> de::VariantAccess<'de> for EnumDeserializer<'de> {
289    type Error = Error;
290
291    fn unit_variant(self) -> Result<()> {
292        de::Deserialize::deserialize(self.value)
293    }
294
295    fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value>
296    where
297        T: de::DeserializeSeed<'de>,
298    {
299        seed.deserialize(self.value)
300    }
301
302    fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value>
303    where
304        V: de::Visitor<'de>,
305    {
306        Deserializer::deserialize_seq(self.value, visitor)
307    }
308
309    fn struct_variant<V>(self, _fields: &'static [&'static str], visitor: V) -> Result<V::Value>
310    where
311        V: de::Visitor<'de>,
312    {
313        Deserializer::deserialize_map(self.value, visitor)
314    }
315}
316
317/// Deserialize a [Value] instance into concrete type `T`.
318pub fn from_value<'de, T>(value: &'de Value) -> Result<T>
319where
320    T: de::Deserialize<'de>,
321{
322    T::deserialize(value)
323}
324
325#[cfg(test)]
326mod tests {
327    use super::*;
328    use crate::bencode;
329    use serde::Deserialize;
330
331    #[derive(Debug, Serialize, Deserialize, PartialEq)]
332    struct TestStruct {
333        pub id: u64,
334        pub enabled: bool,
335        #[serde(default)]
336        pub version: Option<String>,
337    }
338
339    mod from_value {
340        use super::*;
341
342        #[test]
343        fn test_deserialize() {
344            let expected_result = TestStruct {
345                id: 1,
346                enabled: true,
347                version: Some("my-version".to_string()),
348            };
349
350            let bytes = bencode::to_bytes(&expected_result).unwrap();
351            let value: Value = bencode::from_bytes(bytes.as_slice()).unwrap();
352
353            let result: TestStruct = from_value(&value).expect("expected value to be deserialized");
354            assert_eq!(
355                expected_result, result,
356                "expected deserialized value to match expected"
357            )
358        }
359
360        #[test]
361        fn test_deserialize_none_field() {
362            let expected_result = TestStruct {
363                id: 67,
364                enabled: false,
365                version: None,
366            };
367
368            let message = bencode::to_string(&expected_result).unwrap();
369            let value: Value = bencode::from_str(message.as_str()).unwrap();
370
371            let result: TestStruct = from_value(&value).expect("expected value to be deserialized");
372            assert_eq!(
373                expected_result, result,
374                "expected deserialized value to match expected"
375            )
376        }
377    }
378}