rns_core/
serde.rs

1use crate::{
2    buffer::{InputBuffer, OutputBuffer, StaticBuffer},
3    error::RnsError,
4    hash::AddressHash,
5    packet::{Header, HeaderType, Packet, PacketContext, PACKET_MDU},
6};
7
8pub trait Serialize {
9    fn serialize(&self, buffer: &mut OutputBuffer) -> Result<usize, RnsError>;
10}
11
12impl Serialize for AddressHash {
13    fn serialize(&self, buffer: &mut OutputBuffer) -> Result<usize, RnsError> {
14        buffer.write(self.as_slice())
15    }
16}
17
18impl Serialize for Header {
19    fn serialize(&self, buffer: &mut OutputBuffer) -> Result<usize, RnsError> {
20        buffer.write(&[self.to_meta(), self.hops])
21    }
22}
23impl Serialize for PacketContext {
24    fn serialize(&self, buffer: &mut OutputBuffer) -> Result<usize, RnsError> {
25        buffer.write(&[*self as u8])
26    }
27}
28
29impl Serialize for Packet {
30    fn serialize(&self, buffer: &mut OutputBuffer) -> Result<usize, RnsError> {
31        self.header.serialize(buffer)?;
32
33        if self.header.header_type == HeaderType::Type2 {
34            if let Some(transport) = &self.transport {
35                transport.serialize(buffer)?;
36            }
37        }
38
39        self.destination.serialize(buffer)?;
40
41        self.context.serialize(buffer)?;
42
43        buffer.write(self.data.as_slice())
44    }
45}
46
47impl Header {
48    pub fn deserialize(buffer: &mut InputBuffer) -> Result<Header, RnsError> {
49        let mut header = Header::from_meta(buffer.read_byte()?);
50        header.hops = buffer.read_byte()?;
51
52        Ok(header)
53    }
54}
55
56impl AddressHash {
57    pub fn deserialize(buffer: &mut InputBuffer) -> Result<AddressHash, RnsError> {
58        let mut address = AddressHash::new_empty();
59
60        buffer.read(address.as_mut_slice())?;
61
62        Ok(address)
63    }
64}
65
66impl PacketContext {
67    pub fn deserialize(buffer: &mut InputBuffer) -> Result<PacketContext, RnsError> {
68        Ok(PacketContext::from(buffer.read_byte()?))
69    }
70}
71impl Packet {
72    pub fn deserialize(buffer: &mut InputBuffer) -> Result<Packet, RnsError> {
73        let header = Header::deserialize(buffer)?;
74
75        let transport = if header.header_type == HeaderType::Type2 {
76            Some(AddressHash::deserialize(buffer)?)
77        } else {
78            None
79        };
80
81        let destination = AddressHash::deserialize(buffer)?;
82
83        let context = PacketContext::deserialize(buffer)?;
84
85        let mut packet = Packet {
86            header,
87            ifac: None,
88            destination,
89            transport,
90            context,
91            data: StaticBuffer::new(),
92        };
93
94        let remaining = buffer.bytes_left();
95        if remaining > PACKET_MDU {
96            return Err(RnsError::OutOfMemory);
97        }
98        buffer.read(packet.data.accuire_buf(remaining))?;
99
100        Ok(packet)
101    }
102}
103
104#[cfg(test)]
105mod tests {
106    use rand_core::OsRng;
107
108    use crate::{
109        buffer::{InputBuffer, OutputBuffer, StaticBuffer},
110        hash::AddressHash,
111        packet::{
112            ContextFlag, DestinationType, Header, HeaderType, IfacFlag, Packet, PacketContext,
113            PacketType, PropagationType,
114        },
115    };
116
117    use super::Serialize;
118
119    #[test]
120    fn serialize_packet() {
121        let mut output_data = [0u8; 4096];
122
123        let mut buffer = OutputBuffer::new(&mut output_data);
124
125        let packet = Packet {
126            header: Header {
127                ifac_flag: IfacFlag::Open,
128                header_type: HeaderType::Type1,
129                context_flag: ContextFlag::Unset,
130                propagation_type: PropagationType::Broadcast,
131                destination_type: DestinationType::Single,
132                packet_type: PacketType::Announce,
133                hops: 0,
134            },
135            ifac: None,
136            destination: AddressHash::new_from_rand(OsRng),
137            transport: None,
138            context: PacketContext::None,
139            data: StaticBuffer::new(),
140        };
141
142        packet.serialize(&mut buffer).expect("serialized packet");
143
144        println!("{}", buffer);
145    }
146
147    #[test]
148    fn deserialize_packet() {
149        let mut output_data = [0u8; 4096];
150
151        let mut buffer = OutputBuffer::new(&mut output_data);
152
153        let mut packet = Packet {
154            header: Header {
155                ifac_flag: IfacFlag::Open,
156                header_type: HeaderType::Type1,
157                context_flag: ContextFlag::Unset,
158                propagation_type: PropagationType::Broadcast,
159                destination_type: DestinationType::Single,
160                packet_type: PacketType::Announce,
161                hops: 0,
162            },
163            ifac: None,
164            destination: AddressHash::new_from_rand(OsRng),
165            transport: None,
166            context: PacketContext::None,
167            data: StaticBuffer::new(),
168        };
169
170        packet.data.safe_write(b"Hello, world!");
171
172        packet.serialize(&mut buffer).expect("serialized packet");
173
174        let mut input_buffer = InputBuffer::new(buffer.as_slice());
175
176        let new_packet = Packet::deserialize(&mut input_buffer).expect("deserialized packet");
177
178        assert_eq!(packet.header, new_packet.header);
179        assert_eq!(packet.destination, new_packet.destination);
180        assert_eq!(packet.transport, new_packet.transport);
181        assert_eq!(packet.context, new_packet.context);
182        assert_eq!(packet.data.as_slice(), new_packet.data.as_slice());
183    }
184}
rns_core/serde.rs

rns_core/
serde.rs
