1
use super::{CodecExtra, Depacketizer, PacketError, Packetizer};
2
 
3
#[derive(Debug)]
4
pub struct ComfortNoisePacketizer;
5
 
6
#[derive(Debug)]
7
pub struct ComfortNoiseDepacketizer;
8
 
9
impl Packetizer for ComfortNoisePacketizer {
10
    fn packetize(&mut self, mtu: usize, payload: &[u8]) -> Result<Vec<Vec<u8>>, PacketError> {
11
        if payload.is_empty() {
12
            return Ok(vec![]);
13
        }
14
 
15
        if payload.len() > mtu {
16
            return Err(PacketError::ErrPayloadTooLarge);
17
        }
18
 
19
        Ok(vec![payload.to_vec()])
20
    }
21
 
22
    fn is_marker(&mut self, _data: &[u8], _previous: Option<&[u8]>, _last: bool) -> bool {
23
        false
24
    }
25
}
26
 
27
impl Depacketizer for ComfortNoiseDepacketizer {
28
    fn out_size_hint(&self, packets_size: usize) -> Option<usize> {
29
        Some(packets_size)
30
    }
31
 
32
    fn depacketize(
33
        &mut self,
34
        packet: &[u8],
35
        out: &mut Vec<u8>,
36
        _codec_extra: &mut CodecExtra,
37
    ) -> Result<(), PacketError> {
38
        if packet.is_empty() {
39
            return Err(PacketError::ErrShortPacket);
40
        }
41
 
42
        out.extend_from_slice(packet);
43
        Ok(())
44
    }
45
 
46
    fn is_partition_head(&self, _packet: &[u8]) -> bool {
47
        true
48
    }
49
 
50
    fn is_partition_tail(&self, _marker: bool, _packet: &[u8]) -> bool {
51
        true
52
    }
53
}
54
 
55
#[cfg(test)]
56
mod test {
57
    use super::*;
58
 
59
    #[test]
60
    fn packetizer_rejects_payload_larger_than_mtu() {
61
        let mut packetizer = ComfortNoisePacketizer;
62
 
63
        let result = packetizer.packetize(8, &[0; 9]);
64
 
65
        assert!(
66
            result.is_err(),
67
            "a CN payload cannot be fragmented and must not exceed the MTU"
68
        );
69
    }
70
 
71
    #[test]
72
    fn packetizer_does_not_emit_empty_cn_payload() {
73
        let mut packetizer = ComfortNoisePacketizer;
74
 
75
        let packets = packetizer.packetize(1200, &[]).unwrap();
76
 
77
        assert!(packets.is_empty(), "an empty input is not a CN payload");
78
    }
79
 
80
    #[test]
81
    fn depacketizer_rejects_empty_cn_payload() {
82
        let mut depacketizer = ComfortNoiseDepacketizer;
83
        let mut output = Vec::new();
84
 
85
        let result = depacketizer.depacketize(&[], &mut output, &mut CodecExtra::None);
86
 
87
        assert_eq!(result, Err(PacketError::ErrShortPacket));
88
    }
89
}