fix: replace bincode with postcard

Author: Banyc

Cargo.lock

@@ -15,7 +15,6 @@ async-speed-limit = { version = "0.4", features = ["tokio"] }
 async-trait = "0.1"
 axum = "0.8"
 base64 = "0.22"
-bincode = "2"
 bytes = "1"
 clap = "4"
 derive_more = "2"
@@ -36,6 +35,7 @@ monitor_table = { git = "https://github.com/Banyc/monitor_table.git", tag = "v0.
 mptcp = { git = "https://github.com/Banyc/mptcp.git", tag = "v0.0.2" }
 mux = { git = "https://github.com/Banyc/mux.git", tag = "v0.0.10" }
 pin-project-lite = "0.2"
+postcard = "1"
 primitive = { git = "https://github.com/Banyc/primitive.git", tag = "v0.0.59" }
 rand = "0.9"
 regex = "1"

Cargo.toml

@@ -11,7 +11,6 @@ ahash = { workspace = true }
 async-speed-limit = { workspace = true }
 async-trait = { workspace = true }
 base64 = { workspace = true }
-bincode = { workspace = true }
 bytes = { workspace = true }
 derive_more = { workspace = true, features = ["full"] }
 duplicate = { workspace = true }
@@ -22,6 +21,7 @@ hdv_derive = { workspace = true }
 metrics = { workspace = true }
 monitor_table = { workspace = true, features = ["hdv"] }
 pin-project-lite = { workspace = true }
+postcard = { workspace = true }
 primitive = { workspace = true }
 rand = { workspace = true }
 regex = { workspace = true }

common/Cargo.toml

@@ -42,9 +42,7 @@ pub fn any_addr(ip_version: &IpAddr) -> SocketAddr {
     SocketAddr::new(any_ip, 0)
 }
 
-#[derive(
-    Debug, Clone, PartialEq, Eq, Hash, Deserialize, Serialize, bincode::Encode, bincode::Decode,
-)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash, Deserialize, Serialize)]
 pub struct InternetAddr(InternetAddrKind);
 impl Deref for InternetAddr {
     type Target = InternetAddrKind;
@@ -86,9 +84,7 @@ impl FromStr for InternetAddr {
     }
 }
 
-#[derive(
-    Debug, Clone, PartialEq, Eq, Hash, Deserialize, Serialize, bincode::Encode, bincode::Decode,
-)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash, Deserialize, Serialize)]
 #[serde(deny_unknown_fields)]
 pub enum InternetAddrKind {
     SocketAddr(SocketAddr),

common/src/addr.rs

@@ -5,16 +5,12 @@ use std::{
 
 use ae::anti_replay::ValidatorRef;
 use duplicate::duplicate_item;
+use serde::{Serialize, de::DeserializeOwned};
 use thiserror::Error;
 use tokio::io::{AsyncRead, AsyncWrite};
 use tracing::{instrument, trace};
 
 pub const MAX_HEADER_LEN: usize = 1024;
-const BINCODE_CONFIG: bincode::config::Configuration<
-    bincode::config::LittleEndian,
-    bincode::config::Varint,
-    bincode::config::NoLimit,
-> = bincode::config::standard();
 
 pub trait AsHeader {}
 
@@ -31,7 +27,7 @@ pub async fn read_header<Reader, Header>(
 ) -> Result<Header, CodecError>
 where
     Reader: reader_bounds,
-    Header: std::fmt::Debug + AsHeader + bincode::Decode<()>,
+    Header: std::fmt::Debug + AsHeader + DeserializeOwned,
 {
     let mut buf = [0; MAX_HEADER_LEN * 2];
     let mut start_pos = 0;
@@ -61,8 +57,7 @@ where
         },
     };
     let hdr_buf = &buf[start_pos..end_pos];
-    let mut rdr = io::Cursor::new(hdr_buf);
-    let header = bincode::decode_from_std_read(&mut rdr, BINCODE_CONFIG)?;
+    let header = postcard::from_bytes(hdr_buf)?;
     trace!(?header, "Read header");
 
     Ok(header)
@@ -81,13 +76,10 @@ pub async fn write_header<Writer, Header>(
 ) -> Result<(), CodecError>
 where
     Writer: writer_bounds,
-    Header: std::fmt::Debug + AsHeader + bincode::Encode,
+    Header: std::fmt::Debug + AsHeader + Serialize,
 {
     let mut hdr_buf = [0; MAX_HEADER_LEN];
-    let mut hdr_wtr = io::Cursor::new(&mut hdr_buf[..]);
-    bincode::encode_into_std_write(header, &mut hdr_wtr, BINCODE_CONFIG)?;
-    let len = hdr_wtr.position();
-    let hdr_buf = &hdr_buf[..len as usize];
+    let hdr_buf = postcard::to_slice(header, &mut hdr_buf)?;
 
     let timestamped = true;
     let mut buf = [0; MAX_HEADER_LEN * 2];
@@ -121,7 +113,7 @@ pub async fn timed_read_header_async<Reader, Header>(
 ) -> Result<Header, CodecError>
 where
     Reader: AsyncRead + Unpin,
-    Header: std::fmt::Debug + AsHeader + bincode::Decode<()>,
+    Header: std::fmt::Debug + AsHeader + DeserializeOwned,
 {
     let res = tokio::time::timeout(timeout, read_header_async(reader, key, validator)).await;
     match res {
@@ -141,7 +133,7 @@ pub async fn timed_write_header_async<Writer, Header>(
 ) -> Result<(), CodecError>
 where
     Writer: AsyncWrite + Unpin,
-    Header: std::fmt::Debug + AsHeader + bincode::Encode,
+    Header: std::fmt::Debug + AsHeader + Serialize,
 {
     let res = tokio::time::timeout(timeout, write_header_async(writer, header, key)).await;
     match res {
@@ -157,10 +149,8 @@ where
 pub enum CodecError {
     #[error("IO error: {0}")]
     Io(#[from] io::Error),
-    #[error("Encode error: {0}")]
-    Encode(#[from] bincode::error::EncodeError),
-    #[error("Decode error: {0}")]
-    Decode(#[from] bincode::error::DecodeError),
+    #[error("Codec error: {0}")]
+    Codec(#[from] postcard::Error),
     #[error("Data tempered")]
     Integrity,
 }

common/src/header/codec.rs

@@ -56,9 +56,7 @@ where
     Ok(())
 }
 
-#[derive(
-    Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize, bincode::Encode, bincode::Decode,
-)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
 pub enum HeartbeatRequest {
     Noop,
     Upgrade,

common/src/header/heartbeat.rs

@@ -3,50 +3,24 @@ use thiserror::Error;
 
 use super::codec::AsHeader;
 
-#[derive(
-    Debug, Clone, PartialEq, Eq, Hash, Deserialize, Serialize, bincode::Encode, bincode::Decode,
-)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash, Deserialize, Serialize)]
 pub struct RouteRequest<Addr> {
     pub upstream: Option<Addr>,
 }
 impl<Addr> AsHeader for RouteRequest<Addr> {}
 
-#[derive(
-    Debug, Clone, PartialEq, Eq, Hash, Deserialize, Serialize, bincode::Encode, bincode::Decode,
-)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash, Deserialize, Serialize)]
 pub struct RouteResponse {
     pub result: Result<(), RouteError>,
 }
 impl AsHeader for RouteResponse {}
 
-#[derive(
-    Debug,
-    Error,
-    Clone,
-    PartialEq,
-    Eq,
-    Hash,
-    Deserialize,
-    Serialize,
-    bincode::Encode,
-    bincode::Decode,
-)]
+#[derive(Debug, Error, Clone, PartialEq, Eq, Hash, Deserialize, Serialize)]
 #[error("{kind}")]
 pub struct RouteError {
     pub kind: RouteErrorKind,
 }
-#[derive(
-    Debug,
-    Error,
-    Clone,
-    PartialEq,
-    Eq,
-    Hash,
-    Deserialize,
-    Serialize,
-    bincode::Encode,
-    bincode::Decode,
-)]
+#[derive(Debug, Error, Clone, PartialEq, Eq, Hash, Deserialize, Serialize)]
 pub enum RouteErrorKind {
     #[error("io error")]
     Io,

common/src/header/route.rs

@@ -20,9 +20,7 @@ impl StreamAddrBuilder {
 }
 
 /// A stream address
-#[derive(
-    Debug, Clone, PartialEq, Eq, Hash, Deserialize, Serialize, bincode::Encode, bincode::Decode,
-)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash, Deserialize, Serialize)]
 pub struct StreamAddr {
     pub address: InternetAddr,
     pub stream_type: Arc<str>,

common/src/proto/addr.rs

@@ -9,7 +9,6 @@ edition = "2024"
 ae = { workspace = true }
 async-speed-limit = { workspace = true }
 async-trait = { workspace = true }
-bincode = { workspace = true }
 common = { path = "../common" }
 metrics = { workspace = true }
 mptcp = { workspace = true }