dope-tls 0.19.0

TCP TLS streams for dope runtime, shin-backed
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

use std::{error, fmt, io};

use shin::client::{config, workspace};
use shin::connection;
use shin::wire::{alert, record};

#[derive(Debug)]
#[non_exhaustive]
pub enum Error {
    InvalidConfig(config::Error),
    InvalidWorkspace(workspace::Mismatch),
    Handshake(connection::Error),
    Record(record::Error),
    RecordKey(record::KeyError),
    UnexpectedRecord,
    NotEstablished,
    Io(io::Error),
    PeerAlert(alert::Description),
    MalformedAlert,
    Truncated,
    ReceiveOverflow,
    SendOverflow,
    BufferUnavailable,
    InvalidBufferProgress,
    EarlyDataUnsupported,
}

impl From<record::Error> for Error {
    fn from(error: record::Error) -> Self {
        Self::Record(error)
    }
}

impl From<record::KeyError> for Error {
    fn from(error: record::KeyError) -> Self {
        Self::RecordKey(error)
    }
}

impl From<io::Error> for Error {
    fn from(error: io::Error) -> Self {
        Self::Io(error)
    }
}

impl PartialEq for Error {
    fn eq(&self, other: &Self) -> bool {
        match (self, other) {
            (Self::UnexpectedRecord, Self::UnexpectedRecord)
            | (Self::NotEstablished, Self::NotEstablished)
            | (Self::ReceiveOverflow, Self::ReceiveOverflow)
            | (Self::SendOverflow, Self::SendOverflow)
            | (Self::BufferUnavailable, Self::BufferUnavailable)
            | (Self::InvalidBufferProgress, Self::InvalidBufferProgress)
            | (Self::EarlyDataUnsupported, Self::EarlyDataUnsupported)
            | (Self::MalformedAlert, Self::MalformedAlert)
            | (Self::Truncated, Self::Truncated) => true,
            (Self::InvalidConfig(a), Self::InvalidConfig(b)) => a == b,
            (Self::InvalidWorkspace(a), Self::InvalidWorkspace(b)) => a == b,
            (Self::Handshake(a), Self::Handshake(b)) => a == b,
            (Self::Record(a), Self::Record(b)) => a == b,
            (Self::RecordKey(a), Self::RecordKey(b)) => a == b,
            (Self::Io(a), Self::Io(b)) => a.kind() == b.kind(),
            (Self::PeerAlert(a), Self::PeerAlert(b)) => a == b,
            _ => false,
        }
    }
}

impl fmt::Display for Error {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::InvalidConfig(error) => write!(formatter, "invalid TLS client config: {error}"),
            Self::InvalidWorkspace(error) => write!(formatter, "invalid TLS workspace: {error}"),
            Self::Handshake(error) => write!(formatter, "TLS handshake failed: {error:?}"),
            Self::Record(error) => write!(formatter, "TLS record failed: {error:?}"),
            Self::RecordKey(error) => write!(formatter, "TLS record key failed: {error:?}"),
            Self::UnexpectedRecord => formatter.write_str("unexpected TLS record"),
            Self::NotEstablished => formatter.write_str("TLS connection is not established"),
            Self::Io(error) => error.fmt(formatter),
            Self::PeerAlert(alert) => write!(formatter, "peer sent fatal TLS alert: {alert:?}"),
            Self::MalformedAlert => formatter.write_str("malformed TLS alert"),
            Self::Truncated => formatter.write_str("TLS connection closed without close_notify"),
            Self::ReceiveOverflow => formatter.write_str("TLS receive buffer overflow"),
            Self::SendOverflow => formatter.write_str("TLS send buffer overflow"),
            Self::BufferUnavailable => formatter.write_str("TLS buffer unavailable"),
            Self::InvalidBufferProgress => formatter.write_str("invalid TLS buffer progress"),
            Self::EarlyDataUnsupported => formatter.write_str("TLS early data is unsupported"),
        }
    }
}

impl error::Error for Error {
    fn source(&self) -> Option<&(dyn error::Error + 'static)> {
        match self {
            Self::InvalidConfig(error) => Some(error),
            Self::InvalidWorkspace(error) => Some(error),
            Self::Io(error) => Some(error),
            _ => None,
        }
    }
}

impl From<workspace::Mismatch> for Error {
    fn from(error: workspace::Mismatch) -> Self {
        Self::InvalidWorkspace(error)
    }
}