dimpl 0.7.3

DTLS 1.2/1.3 implementation (Sans‑IO, Sync)
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

//! Queue wrapper types with safe Debug implementations.
//!
//! These wrappers ensure that debug output only shows metadata,
//! not potentially sensitive payload data.

use std::collections::VecDeque;
use std::fmt;
use std::ops::{Deref, DerefMut};

use crate::buffer::Buf;
use crate::dtls12::incoming::Incoming;
use crate::types::ContentType;

/// Wrapper around the receive queue that provides safe Debug output.
///
/// The Debug implementation only shows metadata (counts by content type),
/// not potentially sensitive payload data.
pub(crate) struct QueueRx(VecDeque<Incoming>);

impl QueueRx {
    pub fn new() -> Self {
        Self(VecDeque::new())
    }
}

impl Deref for QueueRx {
    type Target = VecDeque<Incoming>;

    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

impl DerefMut for QueueRx {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.0
    }
}

impl fmt::Debug for QueueRx {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let mut handshake = 0;
        let mut app_data = 0;
        let mut alert = 0;
        let mut ccs = 0;
        let mut other = 0;
        let mut min_seq: Option<(u16, u64)> = None;
        let mut max_seq: Option<(u16, u64)> = None;

        for item in &self.0 {
            let record = item.first().record();
            match record.content_type {
                ContentType::Handshake => handshake += 1,
                ContentType::ApplicationData => app_data += 1,
                ContentType::Alert => alert += 1,
                ContentType::ChangeCipherSpec => ccs += 1,
                _ => other += 1,
            }

            let seq = (record.sequence.epoch, record.sequence.sequence_number);
            min_seq = Some(min_seq.map_or(seq, |m| m.min(seq)));
            max_seq = Some(max_seq.map_or(seq, |m| m.max(seq)));
        }

        let mut s = f.debug_struct("QueueRx");
        s.field("len", &self.0.len())
            .field("handshake", &handshake)
            .field("app_data", &app_data)
            .field("alert", &alert)
            .field("ccs", &ccs)
            .field("other", &other);

        if let (Some(min), Some(max)) = (min_seq, max_seq) {
            s.field(
                "seq_range",
                &format_args!("{}:{} - {}:{}", min.0, min.1, max.0, max.1),
            );
        }

        s.finish()
    }
}

/// Wrapper around the transmit queue that provides safe Debug output.
///
/// The Debug implementation only shows metadata (datagram count and total bytes),
/// not potentially sensitive payload data.
pub(crate) struct QueueTx(VecDeque<Buf>);

impl QueueTx {
    pub fn new() -> Self {
        Self(VecDeque::new())
    }
}

impl Deref for QueueTx {
    type Target = VecDeque<Buf>;

    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

impl DerefMut for QueueTx {
    fn deref_mut(&mut self) -> &mut Self::Target {
        &mut self.0
    }
}

impl fmt::Debug for QueueTx {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let total_bytes: usize = self.0.iter().map(|b| b.len()).sum();
        f.debug_struct("QueueTx")
            .field("datagrams", &self.0.len())
            .field("total_bytes", &total_bytes)
            .finish()
    }
}