Serde Debugability netlink-packet-xfrm

Cargo.toml

@@ -16,8 +16,13 @@ byteorder = "1.4.2"
 libc= "0.2.86"
 netlink-packet-core = { version = "0.7.0" }
 netlink-packet-utils = { version = "0.5.2" }
+serde = { version = "1", features = ["derive"], optional = true }
+serde-big-array = { version ="0.5.1", optional = true }
 
 [dev-dependencies]
 lazy_static = "1.4.0"
 netlink-proto = { version = "0.11.2" }
 netlink-sys = { version = "0.8.4" }
+
+[features]
+serde = ["dep:serde", "dep:serde-big-array", "netlink-packet-utils/serde"]

src/address.rs

@@ -1,12 +1,15 @@
 // SPDX-License-Identifier: MIT
 
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
 use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
 
 use netlink_packet_utils::{buffer, traits::*, DecodeError};
 
 pub const XFRM_ADDRESS_LEN: usize = 16;
 
 #[derive(Debug, Clone, Copy, Eq, PartialEq, Default)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct Address {
     // Xfrm netlink API simply uses a 16 byte buffer for both IPv4 & IPv6
     // addresses and unfortunately doesn't always pair it with a family type.

src/async_event_id.rs

@@ -1,6 +1,8 @@
 // SPDX-License-Identifier: MIT
 
 use anyhow::Context;
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
 
 use core::ops::Range;
 
@@ -12,6 +14,7 @@ use crate::{
 use netlink_packet_utils::{buffer, traits::*, DecodeError};
 
 #[derive(Debug, Clone, Copy, Eq, PartialEq, Default)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct AsyncEventId {
     pub sa_id: UserSaId,
     pub saddr: Address,

src/id.rs

@@ -1,12 +1,15 @@
 // SPDX-License-Identifier: MIT
 
 use anyhow::Context;
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
 
 use crate::{Address, AddressBuffer, XFRM_ADDRESS_LEN};
 
 use netlink_packet_utils::{buffer, traits::*, DecodeError};
 
 #[derive(Debug, Clone, Copy, Eq, PartialEq, Default)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct Id {
     pub daddr: Address,
     pub spi: u32, // big-endian

src/lifetime.rs

@@ -1,12 +1,16 @@
 // SPDX-License-Identifier: MIT
 
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
+
 use crate::XFRM_INF;
 
 use netlink_packet_utils::{buffer, traits::*, DecodeError};
 
 // Lifetime config
 
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct LifetimeConfig {
     pub soft_byte_limit: u64,
     pub hard_byte_limit: u64,
@@ -82,6 +86,7 @@ impl Emitable for LifetimeConfig {
 // Lifetime curent
 
 #[derive(Debug, Clone, Copy, Eq, PartialEq, Default)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct Lifetime {
     pub bytes: u64,
     pub packets: u64,

src/message.rs

@@ -1,5 +1,8 @@
 // SPDX-License-Identifier: MIT
 
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
+
 use crate::{
     constants::*,
     monitor::{
@@ -26,6 +29,7 @@ use netlink_packet_core::{
 use netlink_packet_utils::{traits::*, DecodeError};
 
 #[derive(Debug, PartialEq, Eq, Clone)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub enum XfrmMessage {
     AddPolicy(PolicyModifyMessage),
     DeletePolicy(PolicyDelGetMessage),

src/monitor/acquire/message.rs

@@ -1,12 +1,15 @@
 // SPDX-License-Identifier: MIT
 
 use anyhow::Context;
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
 
 use crate::{AcquireMessageBuffer, UserAcquire, UserAcquireBuffer, XfrmAttrs};
 
 use netlink_packet_utils::{traits::*, DecodeError};
 
 #[derive(Debug, PartialEq, Eq, Clone, Default)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct AcquireMessage {
     pub acquire: UserAcquire,
     pub nlas: Vec<XfrmAttrs>,

src/monitor/expire/message.rs

@@ -1,12 +1,15 @@
 // SPDX-License-Identifier: MIT
 
 use anyhow::Context;
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
 
 use crate::{ExpireMessageBuffer, UserExpire, UserExpireBuffer};
 
 use netlink_packet_utils::{traits::*, DecodeError};
 
 #[derive(Debug, PartialEq, Eq, Clone, Default)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct ExpireMessage {
     pub expire: UserExpire,
 }

src/monitor/get_async_event/message.rs

@@ -1,12 +1,15 @@
 // SPDX-License-Identifier: MIT
 
 use anyhow::Context;
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
 
 use crate::{AsyncEventId, AsyncEventIdBuffer, GetAsyncEventMessageBuffer};
 
 use netlink_packet_utils::{traits::*, DecodeError};
 
 #[derive(Debug, PartialEq, Eq, Clone, Default)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct GetAsyncEventMessage {
     pub id: AsyncEventId,
 }

src/monitor/mapping/message.rs

@@ -1,12 +1,15 @@
 // SPDX-License-Identifier: MIT
 
 use anyhow::Context;
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
 
 use crate::{MappingMessageBuffer, UserMapping, UserMappingBuffer};
 
 use netlink_packet_utils::{traits::*, DecodeError};
 
 #[derive(Debug, PartialEq, Eq, Clone, Default)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct MappingMessage {
     pub map: UserMapping,
 }

src/monitor/migrate/message.rs

@@ -1,6 +1,8 @@
 // SPDX-License-Identifier: MIT
 
 use anyhow::Context;
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
 
 use crate::{
     MigrateMessageBuffer, UserPolicyId, UserPolicyIdBuffer, XfrmAttrs,
@@ -9,6 +11,7 @@ use crate::{
 use netlink_packet_utils::{traits::*, DecodeError};
 
 #[derive(Debug, PartialEq, Eq, Clone, Default)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct MigrateMessage {
     pub user_policy_id: UserPolicyId,
     pub nlas: Vec<XfrmAttrs>,

src/monitor/new_async_event/message.rs

@@ -1,6 +1,8 @@
 // SPDX-License-Identifier: MIT
 
 use anyhow::Context;
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
 
 use crate::{
     AsyncEventId, AsyncEventIdBuffer, NewAsyncEventMessageBuffer, XfrmAttrs,
@@ -9,6 +11,7 @@ use crate::{
 use netlink_packet_utils::{traits::*, DecodeError};
 
 #[derive(Debug, PartialEq, Eq, Clone, Default)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct NewAsyncEventMessage {
     pub id: AsyncEventId,
     pub nlas: Vec<XfrmAttrs>,

src/monitor/polexpire/message.rs

@@ -1,6 +1,8 @@
 // SPDX-License-Identifier: MIT
 
 use anyhow::Context;
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
 
 use crate::{
     PolicyExpireMessageBuffer, UserPolicyExpire, UserPolicyExpireBuffer,
@@ -10,6 +12,7 @@ use crate::{
 use netlink_packet_utils::{traits::*, DecodeError};
 
 #[derive(Debug, PartialEq, Eq, Clone, Default)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct PolicyExpireMessage {
     pub expire: UserPolicyExpire,
     pub nlas: Vec<XfrmAttrs>,

src/monitor/report/message.rs

@@ -1,12 +1,15 @@
 // SPDX-License-Identifier: MIT
 
 use anyhow::Context;
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
 
 use crate::{ReportMessageBuffer, UserReport, UserReportBuffer, XfrmAttrs};
 
 use netlink_packet_utils::{traits::*, DecodeError};
 
 #[derive(Debug, PartialEq, Eq, Clone, Default)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct ReportMessage {
     pub report: UserReport,
     pub nlas: Vec<XfrmAttrs>,

src/nlas/address_filter.rs

@@ -1,6 +1,8 @@
 // SPDX-License-Identifier: MIT
 
 use anyhow::Context;
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
 
 use core::ops::Range;
 use std::net::IpAddr;
@@ -14,6 +16,7 @@ use crate::{
 use netlink_packet_utils::{buffer, traits::*, DecodeError};
 
 #[derive(Debug, Clone, Copy, Eq, PartialEq, Default)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct AddressFilter {
     pub saddr: Address,
     pub daddr: Address,

src/nlas/alg.rs

@@ -1,13 +1,21 @@
 // SPDX-License-Identifier: MIT
 
+#[cfg(feature = "serde")]
+use {
+    serde::{Deserialize, Serialize},
+    serde_big_array::BigArray,
+};
+
 use core::ops::Range;
 
 use netlink_packet_utils::{buffer, traits::*, DecodeError};
 
 pub const XFRM_ALG_NAME_LEN: usize = 64;
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct Alg {
+    #[cfg_attr(feature = "serde", serde(with = "BigArray"))]
     pub alg_name: [u8; XFRM_ALG_NAME_LEN],
     pub alg_key_len: u32,
     pub alg_key: Vec<u8>,

src/nlas/alg_aead.rs

@@ -1,13 +1,21 @@
 // SPDX-License-Identifier: MIT
 
+#[cfg(feature = "serde")]
+use {
+    serde::{Deserialize, Serialize},
+    serde_big_array::BigArray,
+};
+
 use core::ops::Range;
 
 use netlink_packet_utils::{buffer, traits::*, DecodeError};
 
 pub const XFRM_ALG_AEAD_NAME_LEN: usize = 64;
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct AlgAead {
+    #[cfg_attr(feature = "serde", serde(with = "BigArray"))]
     pub alg_name: [u8; XFRM_ALG_AEAD_NAME_LEN],
     pub alg_key_len: u32,
     pub alg_icv_len: u32,

src/nlas/alg_auth.rs

@@ -1,13 +1,21 @@
 // SPDX-License-Identifier: MIT
 
+#[cfg(feature = "serde")]
+use {
+    serde::{Deserialize, Serialize},
+    serde_big_array::BigArray,
+};
+
 use core::ops::Range;
 
 use netlink_packet_utils::{buffer, traits::*, DecodeError};
 
 pub const XFRM_ALG_AUTH_NAME_LEN: usize = 64;
 
 #[derive(Debug, Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct AlgAuth {
+    #[cfg_attr(feature = "serde", serde(with = "BigArray"))]
     pub alg_name: [u8; XFRM_ALG_AUTH_NAME_LEN],
     pub alg_key_len: u32,
     pub alg_trunc_len: u32,

src/nlas/encap_tmpl.rs

@@ -1,6 +1,8 @@
 // SPDX-License-Identifier: MIT
 
 use anyhow::Context;
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
 
 use core::ops::Range;
 
@@ -9,6 +11,7 @@ use crate::{Address, AddressBuffer, XFRM_ADDRESS_LEN};
 use netlink_packet_utils::{buffer, traits::*, DecodeError};
 
 #[derive(Debug, Clone, Copy, Eq, PartialEq, Default)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct EncapTmpl {
     pub encap_type: u16,
     pub encap_sport: u16, // big-endian

src/nlas/mark.rs

@@ -1,8 +1,12 @@
 // SPDX-License-Identifier: MIT
 
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
+
 use netlink_packet_utils::{buffer, traits::*, DecodeError};
 
 #[derive(Debug, Clone, Copy, Eq, PartialEq, Default)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct Mark {
     pub value: u32,
     pub mask: u32,

src/nlas/mod.rs

@@ -42,6 +42,8 @@ pub use user_template::*;
 
 use anyhow::Context;
 use byteorder::{ByteOrder, NativeEndian};
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
 use std::mem::size_of;
 
 use crate::{
@@ -58,6 +60,7 @@ use netlink_packet_utils::{
 };
 
 #[derive(Debug, PartialEq, Eq, Clone)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub enum XfrmAttrs {
     AddressFilter(address_filter::AddressFilter),
     AuthenticationAlg(Alg),

src/nlas/replay.rs

@@ -1,8 +1,12 @@
 // SPDX-License-Identifier: MIT
 
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
+
 use netlink_packet_utils::{buffer, traits::*, DecodeError};
 
 #[derive(Debug, Clone, Copy, Eq, PartialEq, Default)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct Replay {
     pub oseq: u32,
     pub seq: u32,

src/nlas/replay_esn.rs

@@ -1,12 +1,15 @@
 // SPDX-License-Identifier: MIT
 
 use byteorder::{ByteOrder, NativeEndian};
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
 
 use netlink_packet_utils::{buffer, traits::*, DecodeError};
 
 pub const XFRM_REPLAY_ESN_LEN: usize = 24;
 
 #[derive(Debug, Clone, Eq, PartialEq, Default)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct ReplayEsn {
     pub bmp_len: u32,
     pub oseq: u32,