librqbit_bencode/
serde_bencode_ser.rs

1use std::collections::BTreeMap;
2
3use serde::{ser::Impossible, Serialize, Serializer};
4
5use buffers::ByteBufOwned;
6
7#[derive(Debug)]
8pub enum SerErrorKind {
9    Other(anyhow::Error),
10}
11
12impl std::fmt::Display for SerErrorKind {
13    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
14        match self {
15            SerErrorKind::Other(e) => write!(f, "{e}"),
16        }
17    }
18}
19
20#[derive(Debug)]
21pub struct SerError {
22    kind: SerErrorKind,
23}
24
25impl SerError {
26    fn custom_with_ser<T: std::fmt::Display, W: std::io::Write>(
27        msg: T,
28        _ser: &BencodeSerializer<W>,
29    ) -> Self {
30        serde::ser::Error::custom(msg)
31    }
32    fn from_err_with_ser<E: std::error::Error + Send + Sync + 'static, W: std::io::Write>(
33        err: E,
34        _ser: &BencodeSerializer<W>,
35    ) -> Self {
36        Self {
37            kind: SerErrorKind::Other(err.into()),
38        }
39    }
40}
41
42impl serde::ser::Error for SerError {
43    fn custom<T>(msg: T) -> Self
44    where
45        T: std::fmt::Display,
46    {
47        Self {
48            kind: SerErrorKind::Other(anyhow::anyhow!("{}", msg)),
49        }
50    }
51}
52
53impl std::error::Error for SerError {}
54
55impl std::fmt::Display for SerError {
56    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
57        write!(f, "{}", self.kind)
58    }
59}
60
61struct BencodeSerializer<W: std::io::Write> {
62    writer: W,
63    hack_no_bytestring_prefix: bool,
64}
65
66impl<W: std::io::Write> BencodeSerializer<W> {
67    pub fn new(writer: W) -> Self {
68        Self {
69            writer,
70            hack_no_bytestring_prefix: false,
71        }
72    }
73    fn write_raw(&mut self, buf: &[u8]) -> Result<(), SerError> {
74        self.writer
75            .write_all(buf)
76            .map_err(|e| SerError::from_err_with_ser(e, self))
77    }
78    fn write_fmt(&mut self, fmt: core::fmt::Arguments<'_>) -> Result<(), SerError> {
79        self.writer
80            .write_fmt(fmt)
81            .map_err(|e| SerError::from_err_with_ser(e, self))
82    }
83    fn write_byte(&mut self, byte: u8) -> Result<(), SerError> {
84        self.write_raw(&[byte])
85    }
86    fn write_number<N: std::fmt::Display>(&mut self, number: N) -> Result<(), SerError> {
87        self.write_fmt(format_args!("i{number}e"))
88    }
89    fn write_bytes(&mut self, bytes: &[u8]) -> Result<(), SerError> {
90        if !self.hack_no_bytestring_prefix {
91            self.write_fmt(format_args!("{}:", bytes.len()))?;
92        }
93        self.write_raw(bytes)
94    }
95}
96
97struct SerializeSeq<'ser, W: std::io::Write> {
98    ser: &'ser mut BencodeSerializer<W>,
99}
100impl<W: std::io::Write> serde::ser::SerializeSeq for SerializeSeq<'_, W> {
101    type Ok = ();
102
103    type Error = SerError;
104
105    fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
106    where
107        T: ?Sized + serde::Serialize,
108    {
109        value.serialize(&mut *self.ser)
110    }
111
112    fn end(self) -> Result<Self::Ok, Self::Error> {
113        self.ser.write_byte(b'e')
114    }
115}
116
117struct SerializeTuple<'ser, W: std::io::Write> {
118    ser: &'ser mut BencodeSerializer<W>,
119}
120impl<W: std::io::Write> serde::ser::SerializeTuple for SerializeTuple<'_, W> {
121    type Ok = ();
122
123    type Error = SerError;
124
125    fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
126    where
127        T: ?Sized + serde::Serialize,
128    {
129        value.serialize(&mut *self.ser)
130    }
131
132    fn end(self) -> Result<Self::Ok, Self::Error> {
133        self.ser.write_byte(b'e')
134    }
135}
136
137struct SerializeMap<'ser, W: std::io::Write> {
138    ser: &'ser mut BencodeSerializer<W>,
139    tmp: BTreeMap<ByteBufOwned, ByteBufOwned>,
140    last_key: Option<ByteBufOwned>,
141}
142impl<W: std::io::Write> serde::ser::SerializeMap for SerializeMap<'_, W> {
143    type Ok = ();
144
145    type Error = SerError;
146
147    fn serialize_key<T>(&mut self, key: &T) -> Result<(), Self::Error>
148    where
149        T: ?Sized + serde::Serialize,
150    {
151        let mut buf = Vec::new();
152        let mut ser = BencodeSerializer::new(&mut buf);
153        ser.hack_no_bytestring_prefix = true;
154        key.serialize(&mut ser)?;
155        self.last_key.replace(ByteBufOwned::from(buf));
156        Ok(())
157        // key.serialize(&mut *self.ser);
158    }
159
160    fn serialize_value<T>(&mut self, value: &T) -> Result<(), Self::Error>
161    where
162        T: ?Sized + serde::Serialize,
163    {
164        let mut buf = Vec::new();
165        let mut ser = BencodeSerializer::new(&mut buf);
166        value.serialize(&mut ser)?;
167        self.tmp
168            .insert(self.last_key.take().unwrap(), ByteBufOwned::from(buf));
169        Ok(())
170    }
171
172    fn end(self) -> Result<Self::Ok, Self::Error> {
173        for (key, value) in self.tmp {
174            self.ser.write_bytes(&key)?;
175            self.ser.write_raw(&value)?;
176        }
177        self.ser.write_byte(b'e')
178    }
179}
180
181struct SerializeStruct<'ser, W: std::io::Write> {
182    ser: &'ser mut BencodeSerializer<W>,
183    tmp: BTreeMap<&'static str, ByteBufOwned>,
184}
185impl<W: std::io::Write> serde::ser::SerializeStruct for SerializeStruct<'_, W> {
186    type Ok = ();
187
188    type Error = SerError;
189
190    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
191    where
192        T: ?Sized + serde::Serialize,
193    {
194        let mut buf = Vec::new();
195        let mut ser = BencodeSerializer::new(&mut buf);
196        value.serialize(&mut ser)?;
197        self.tmp.insert(key, ByteBufOwned::from(buf));
198        Ok(())
199    }
200
201    fn end(self) -> Result<Self::Ok, Self::Error> {
202        for (key, value) in self.tmp {
203            self.ser.write_bytes(key.as_bytes())?;
204            self.ser.write_raw(&value)?;
205        }
206        self.ser.write_byte(b'e')
207    }
208}
209
210impl<'ser, W: std::io::Write> Serializer for &'ser mut BencodeSerializer<W> {
211    type Ok = ();
212    type Error = SerError;
213    type SerializeSeq = SerializeSeq<'ser, W>;
214    type SerializeTuple = SerializeTuple<'ser, W>;
215    type SerializeTupleStruct = Impossible<(), SerError>;
216    type SerializeTupleVariant = Impossible<(), SerError>;
217    type SerializeMap = SerializeMap<'ser, W>;
218    type SerializeStruct = SerializeStruct<'ser, W>;
219    type SerializeStructVariant = Impossible<(), SerError>;
220
221    fn serialize_bool(self, value: bool) -> Result<Self::Ok, Self::Error> {
222        self.write_number(if value { 1 } else { 0 })
223    }
224
225    fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
226        self.write_number(v)
227    }
228
229    fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
230        self.write_number(v)
231    }
232
233    fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
234        self.write_number(v)
235    }
236
237    fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
238        self.write_number(v)
239    }
240
241    fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
242        self.write_number(v)
243    }
244
245    fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
246        self.write_number(v)
247    }
248
249    fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
250        self.write_number(v)
251    }
252
253    fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
254        self.write_number(v)
255    }
256
257    fn serialize_f32(self, _: f32) -> Result<Self::Ok, Self::Error> {
258        Err(SerError::custom_with_ser(
259            "bencode doesn't support f32",
260            self,
261        ))
262    }
263
264    fn serialize_f64(self, _: f64) -> Result<Self::Ok, Self::Error> {
265        Err(SerError::custom_with_ser(
266            "bencode doesn't support f32",
267            self,
268        ))
269    }
270
271    fn serialize_char(self, _: char) -> Result<Self::Ok, Self::Error> {
272        Err(SerError::custom_with_ser(
273            "bencode doesn't support chars",
274            self,
275        ))
276    }
277
278    fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
279        self.write_bytes(v.as_bytes())
280    }
281
282    fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error> {
283        self.write_bytes(v)
284    }
285
286    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
287        Err(SerError::custom_with_ser(
288            "bencode doesn't support None",
289            self,
290        ))
291    }
292
293    fn serialize_some<T>(self, value: &T) -> Result<Self::Ok, Self::Error>
294    where
295        T: ?Sized + serde::Serialize,
296    {
297        value.serialize(self)
298    }
299
300    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
301        Err(SerError::custom_with_ser(
302            "bencode doesn't support Rust unit ()",
303            self,
304        ))
305    }
306
307    fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {
308        Err(SerError::custom_with_ser(
309            "bencode doesn't support unit structs",
310            self,
311        ))
312    }
313
314    fn serialize_unit_variant(
315        self,
316        _name: &'static str,
317        _variant_index: u32,
318        _variant: &'static str,
319    ) -> Result<Self::Ok, Self::Error> {
320        Err(SerError::custom_with_ser(
321            "bencode doesn't support unit variants",
322            self,
323        ))
324    }
325
326    fn serialize_newtype_struct<T>(
327        self,
328        name: &'static str,
329        value: &T,
330    ) -> Result<Self::Ok, Self::Error>
331    where
332        T: ?Sized + serde::Serialize,
333    {
334        if name == crate::raw_value::TAG {
335            self.hack_no_bytestring_prefix = true;
336            value.serialize(&mut *self)?;
337            self.hack_no_bytestring_prefix = false;
338            return Ok(());
339        }
340        Err(SerError::custom_with_ser(
341            "bencode doesn't support newtype structs",
342            self,
343        ))
344    }
345
346    fn serialize_newtype_variant<T>(
347        self,
348        _name: &'static str,
349        _variant_index: u32,
350        _variant: &'static str,
351        _value: &T,
352    ) -> Result<Self::Ok, Self::Error>
353    where
354        T: ?Sized + serde::Serialize,
355    {
356        Err(SerError::custom_with_ser(
357            "bencode doesn't support newtype variants",
358            self,
359        ))
360    }
361
362    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
363        self.write_byte(b'l')?;
364        Ok(SerializeSeq { ser: self })
365    }
366
367    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Self::Error> {
368        Err(SerError::custom_with_ser(
369            "bencode doesn't support tuples",
370            self,
371        ))
372    }
373
374    fn serialize_tuple_struct(
375        self,
376        _name: &'static str,
377        _len: usize,
378    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
379        Err(SerError::custom_with_ser(
380            "bencode doesn't support tuple structs",
381            self,
382        ))
383    }
384
385    fn serialize_tuple_variant(
386        self,
387        _name: &'static str,
388        _variant_index: u32,
389        _variant: &'static str,
390        _len: usize,
391    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
392        Err(SerError::custom_with_ser(
393            "bencode doesn't support tuple variants",
394            self,
395        ))
396    }
397
398    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
399        self.write_byte(b'd')?;
400        Ok(SerializeMap {
401            ser: self,
402            tmp: Default::default(),
403            last_key: None,
404        })
405    }
406
407    fn serialize_struct(
408        self,
409        _name: &'static str,
410        _len: usize,
411    ) -> Result<Self::SerializeStruct, Self::Error> {
412        self.write_byte(b'd')?;
413        Ok(SerializeStruct {
414            ser: self,
415            tmp: Default::default(),
416        })
417    }
418
419    fn serialize_struct_variant(
420        self,
421        _name: &'static str,
422        _variant_index: u32,
423        _variant: &'static str,
424        _len: usize,
425    ) -> Result<Self::SerializeStructVariant, Self::Error> {
426        Err(SerError::custom_with_ser(
427            "bencode doesn't support struct variants",
428            self,
429        ))
430    }
431}
432
433pub fn bencode_serialize_to_writer<T: Serialize, W: std::io::Write>(
434    value: T,
435    writer: &mut W,
436) -> Result<(), SerError> {
437    let mut serializer = BencodeSerializer::new(writer);
438    value.serialize(&mut serializer)?;
439    Ok(())
440}
librqbit_bencode/serde_bencode_ser.rs

librqbit_bencode/
serde_bencode_ser.rs
