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

use std::fmt::{Display, Formatter};

#[derive(Debug, PartialEq, Eq)]
pub enum HandshakeError {
    // http error
    HttpVersion,

    HttpMethod,

    HttpSatusCode,

    HttpHost,

    // websocket error
    Upgrade,

    Connection,

    SecWebSocketKey,

    SecWebSocketAccept,

    SecWebSocketVersion,

    // other error

    // read
    NotEnoughData,

    // write
    NotEnoughCapacity,

    Httparse(httparse::Error),

    Manual(&'static str),
}

impl Display for HandshakeError {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        use HandshakeError::*;
        match self {
            // http error
            HttpVersion => write!(f, "Illegal http version"),

            HttpMethod => write!(f, "Illegal http method"),

            HttpSatusCode => write!(f, "Illegal http status code"),

            HttpHost => write!(f, "Missing http host header"),

            // websocket error
            Upgrade => write!(f, "Missing or illegal upgrade header"),

            Connection => write!(f, "Missing or illegal connection header"),

            SecWebSocketKey => {
                write!(f, "Missing sec-websocket-key header")
            }

            SecWebSocketAccept => {
                write!(f, "Missing or illegal sec-websocket-accept header")
            }

            SecWebSocketVersion => {
                write!(f, "Missing or illegal sec-websocket-version")
            }

            // other error
            NotEnoughData => write!(f, "Not enough data to parse"),

            NotEnoughCapacity => write!(f, "Not enough space to write to"),

            Httparse(e) => write!(f, "Http parse error: {}", e),

            Manual(s) => write!(f, "Manual error: {}", s),
        }
    }
}

impl From<httparse::Error> for HandshakeError {
    fn from(e: httparse::Error) -> Self { HandshakeError::Httparse(e) }
}

impl std::error::Error for HandshakeError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        if let HandshakeError::Httparse(e) = self {
            Some(e)
        } else {
            None
        }
    }
}