From d9ec702f59aaebc4a4ab36b76791d43e18522460 Mon Sep 17 00:00:00 2001 From: Igor Katson Date: Fri, 29 Mar 2024 09:55:28 +0000 Subject: [PATCH] Remove panics in bencode serialization --- Cargo.lock | 2 +- crates/bencode/Cargo.toml | 10 +- crates/bencode/src/serde_bencode_ser.rs | 122 +++++++----------------- 3 files changed, 42 insertions(+), 92 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index eef80d6..4b25216 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1318,7 +1318,7 @@ dependencies = [ [[package]] name = "librqbit-bencode" -version = "2.2.1" +version = "2.2.2" dependencies = [ "anyhow", "librqbit-buffers", diff --git a/crates/bencode/Cargo.toml b/crates/bencode/Cargo.toml index 00366a4..9095673 100644 --- a/crates/bencode/Cargo.toml +++ b/crates/bencode/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "librqbit-bencode" -version = "2.2.1" +version = "2.2.2" edition = "2021" description = "Bencode serialization and deserialization using Serde" license = "Apache-2.0" @@ -17,8 +17,8 @@ sha1-openssl = ["sha1w/sha1-openssl"] sha1-rust = ["sha1w/sha1-rust"] [dependencies] -serde = {version = "1", features=["derive"]} -buffers = {path = "../buffers", package="librqbit-buffers", version = "2.2.1"} -clone_to_owned = {path = "../clone_to_owned", package="librqbit-clone-to-owned", version = "2.2.1"} +serde = { version = "1", features = ["derive"] } +buffers = { path = "../buffers", package = "librqbit-buffers", version = "2.2.1" } +clone_to_owned = { path = "../clone_to_owned", package = "librqbit-clone-to-owned", version = "2.2.1" } anyhow = "1" -sha1w = {path="../sha1w", default-features=false, package="librqbit-sha1-wrapper", version="2.2.1"} \ No newline at end of file +sha1w = { path = "../sha1w", default-features = false, package = "librqbit-sha1-wrapper", version = "2.2.1" } diff --git a/crates/bencode/src/serde_bencode_ser.rs b/crates/bencode/src/serde_bencode_ser.rs index cb1ecd4..2344e2e 100644 --- a/crates/bencode/src/serde_bencode_ser.rs +++ b/crates/bencode/src/serde_bencode_ser.rs @@ -1,6 +1,6 @@ use std::collections::BTreeMap; -use serde::{Serialize, Serializer}; +use serde::{ser::Impossible, Serialize, Serializer}; use buffers::ByteString; @@ -134,46 +134,6 @@ impl<'ser, W: std::io::Write> serde::ser::SerializeTuple for SerializeTuple<'ser } } -struct SerializeTupleStruct<'ser, W: std::io::Write> { - _ser: &'ser mut BencodeSerializer, -} -impl<'ser, W: std::io::Write> serde::ser::SerializeTupleStruct for SerializeTupleStruct<'ser, W> { - type Ok = (); - - type Error = SerError; - - fn serialize_field(&mut self, _value: &T) -> Result<(), Self::Error> - where - T: serde::Serialize, - { - todo!() - } - - fn end(self) -> Result { - todo!() - } -} - -struct SerializeTupleVariant<'ser, W: std::io::Write> { - _ser: &'ser mut BencodeSerializer, -} -impl<'ser, W: std::io::Write> serde::ser::SerializeTupleVariant for SerializeTupleVariant<'ser, W> { - type Ok = (); - - type Error = SerError; - - fn serialize_field(&mut self, _value: &T) -> Result<(), Self::Error> - where - T: serde::Serialize, - { - todo!() - } - - fn end(self) -> Result { - todo!() - } -} - struct SerializeMap<'ser, W: std::io::Write> { ser: &'ser mut BencodeSerializer, tmp: BTreeMap, @@ -251,50 +211,16 @@ impl<'ser, W: std::io::Write> serde::ser::SerializeStruct for SerializeStruct<'s } } -struct SerializeStructVariant<'ser, W: std::io::Write> { - _ser: &'ser mut BencodeSerializer, -} -impl<'ser, W: std::io::Write> serde::ser::SerializeStructVariant - for SerializeStructVariant<'ser, W> -{ - type Ok = (); - - type Error = SerError; - - fn serialize_field( - &mut self, - _key: &'static str, - _value: &T, - ) -> Result<(), Self::Error> - where - T: serde::Serialize, - { - todo!() - } - - fn end(self) -> Result { - todo!() - } -} - impl<'ser, W: std::io::Write> Serializer for &'ser mut BencodeSerializer { type Ok = (); - type Error = SerError; - type SerializeSeq = SerializeSeq<'ser, W>; - type SerializeTuple = SerializeTuple<'ser, W>; - - type SerializeTupleStruct = SerializeTupleStruct<'ser, W>; - - type SerializeTupleVariant = SerializeTupleVariant<'ser, W>; - + type SerializeTupleStruct = Impossible<(), SerError>; + type SerializeTupleVariant = Impossible<(), SerError>; type SerializeMap = SerializeMap<'ser, W>; - type SerializeStruct = SerializeStruct<'ser, W>; - - type SerializeStructVariant = SerializeStructVariant<'ser, W>; + type SerializeStructVariant = Impossible<(), SerError>; fn serialize_bool(self, _: bool) -> Result { Err(SerError::custom_with_ser( @@ -386,7 +312,10 @@ impl<'ser, W: std::io::Write> Serializer for &'ser mut BencodeSerializer { } fn serialize_unit_struct(self, _name: &'static str) -> Result { - todo!() + Err(SerError::custom_with_ser( + "bencode doesn't support unit structs", + self, + )) } fn serialize_unit_variant( @@ -395,7 +324,10 @@ impl<'ser, W: std::io::Write> Serializer for &'ser mut BencodeSerializer { _variant_index: u32, _variant: &'static str, ) -> Result { - todo!() + Err(SerError::custom_with_ser( + "bencode doesn't support unit variants", + self, + )) } fn serialize_newtype_struct( @@ -406,7 +338,10 @@ impl<'ser, W: std::io::Write> Serializer for &'ser mut BencodeSerializer { where T: serde::Serialize, { - todo!() + Err(SerError::custom_with_ser( + "bencode doesn't support newtype structs", + self, + )) } fn serialize_newtype_variant( @@ -419,7 +354,10 @@ impl<'ser, W: std::io::Write> Serializer for &'ser mut BencodeSerializer { where T: serde::Serialize, { - todo!() + Err(SerError::custom_with_ser( + "bencode doesn't support newtype variants", + self, + )) } fn serialize_seq(self, _len: Option) -> Result { @@ -428,7 +366,10 @@ impl<'ser, W: std::io::Write> Serializer for &'ser mut BencodeSerializer { } fn serialize_tuple(self, _len: usize) -> Result { - todo!() + Err(SerError::custom_with_ser( + "bencode doesn't support tuples", + self, + )) } fn serialize_tuple_struct( @@ -436,7 +377,10 @@ impl<'ser, W: std::io::Write> Serializer for &'ser mut BencodeSerializer { _name: &'static str, _len: usize, ) -> Result { - todo!() + Err(SerError::custom_with_ser( + "bencode doesn't support tuple structs", + self, + )) } fn serialize_tuple_variant( @@ -446,7 +390,10 @@ impl<'ser, W: std::io::Write> Serializer for &'ser mut BencodeSerializer { _variant: &'static str, _len: usize, ) -> Result { - todo!() + Err(SerError::custom_with_ser( + "bencode doesn't support tuple variants", + self, + )) } fn serialize_map(self, _len: Option) -> Result { @@ -477,7 +424,10 @@ impl<'ser, W: std::io::Write> Serializer for &'ser mut BencodeSerializer { _variant: &'static str, _len: usize, ) -> Result { - todo!() + Err(SerError::custom_with_ser( + "bencode doesn't support struct variants", + self, + )) } }