shoes 0.3.2

A multi-protocol proxy server.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

use std::{
    mem,
    ops::{Deref, DerefMut, Range},
    sync::{LazyLock, Mutex},
};

const BUFFER_POOL_MAX_SIZE: usize = 64;
const BUFFER_POOL_MAX_CAPACITY: usize = 65_539;
static BUFFER_POOL: LazyLock<Mutex<Vec<Vec<u8>>>> = LazyLock::new(|| Mutex::new(Vec::new()));

/// Owns packet storage independently of the visible IP packet or UDP payload range.
#[derive(Debug)]
pub struct PacketBuffer {
    storage: Vec<u8>,
    range: Range<usize>,
    pooled: bool,
}

impl PacketBuffer {
    pub fn with_capacity(capacity: usize) -> Self {
        let mut storage = BUFFER_POOL
            .lock()
            .ok()
            .and_then(|mut pool| pool.pop())
            .unwrap_or_default();
        storage.reserve(capacity);
        Self {
            storage,
            range: 0..0,
            pooled: true,
        }
    }

    pub fn copy_from_slice(data: &[u8]) -> Self {
        Self {
            storage: data.to_vec(),
            range: 0..data.len(),
            pooled: false,
        }
    }

    pub fn resize(&mut self, length: usize) {
        assert_eq!(self.range.start, 0);
        self.storage.resize(length, 0);
        self.range.end = length;
    }

    pub fn truncate(&mut self, length: usize) {
        self.range.end = self.range.start + self.len().min(length);
    }

    pub fn retain_range(&mut self, range: Range<usize>) {
        assert!(range.start <= range.end && range.end <= self.len());
        self.range = self.range.start + range.start..self.range.start + range.end;
    }

    pub fn into_payload(self, compact: bool) -> Self {
        let capacity = self.storage.capacity();
        let payload_len = self.len();
        // Tiny datagrams must not pin jumbo/MTU storage in per-flow queues.
        if (compact && capacity != payload_len) || capacity > payload_len.saturating_mul(2) {
            Self::copy_from_slice(&self)
        } else {
            self
        }
    }
}

impl Deref for PacketBuffer {
    type Target = [u8];

    fn deref(&self) -> &Self::Target {
        &self.storage[self.range.clone()]
    }
}

impl DerefMut for PacketBuffer {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.storage[self.range.clone()]
    }
}

impl Drop for PacketBuffer {
    fn drop(&mut self) {
        if self.pooled
            && self.storage.capacity() <= BUFFER_POOL_MAX_CAPACITY
            && let Ok(mut pool) = BUFFER_POOL.lock()
            && pool.len() < BUFFER_POOL_MAX_SIZE
        {
            let mut storage = mem::take(&mut self.storage);
            storage.clear();
            pool.push(storage);
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn payload_view_preserves_the_original_allocation() {
        let mut packet = PacketBuffer::copy_from_slice(&[7; 1504]);
        let pointer = packet.as_ptr();
        packet.retain_range(4..1504);
        packet.retain_range(28..1500);
        let payload = packet.into_payload(false);
        assert_eq!(payload.as_ptr(), pointer.wrapping_add(32));
        assert_eq!(payload.len(), 1472);
        assert_eq!(payload.storage.capacity(), 1504);
        assert_eq!(&*payload, &[7; 1472]);
    }

    #[test]
    fn tiny_payload_does_not_retain_oversized_storage() {
        let mut packet = PacketBuffer::copy_from_slice(&[9; 65539]);
        packet.retain_range(32..96);
        let payload = packet.into_payload(false);
        assert_eq!(payload.storage.capacity(), 64);
        assert_eq!(&*payload, &[9; 64]);
        assert!(!payload.pooled);
    }

    #[test]
    fn explicit_payload_allowance_uses_compact_storage_even_for_large_packets() {
        let mut packet = PacketBuffer::copy_from_slice(&[5; 1504]);
        packet.retain_range(32..1504);
        let payload = packet.into_payload(true);
        assert_eq!(payload.storage.capacity(), 1472);
        assert_eq!(payload.len(), 1472);
    }

    #[test]
    fn empty_payload_releases_its_backing_storage() {
        let mut packet = PacketBuffer::copy_from_slice(&[0; 1504]);
        packet.retain_range(32..32);
        let payload = packet.into_payload(false);
        assert_eq!(payload.len(), 0);
        assert_eq!(payload.storage.capacity(), 0);
    }
}