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

use std::fmt;

/// HTTP/2 error codes.
///
/// Error codes are used in `RST_STREAM` and `GOAWAY` frames to convey the
/// reasons for the stream or connection error. For example,
/// [`SendStream::send_reset`] takes a `Reason` argument. Also, the `Error` type
/// may contain a `Reason`.
///
/// Error codes share a common code space. Some error codes apply only to
/// streams, others apply only to connections, and others may apply to either.
/// See [RFC 7540] for more information.
///
/// See [Error Codes in the spec][spec].
///
/// [spec]: http://httpwg.org/specs/rfc7540.html#ErrorCodes
/// [`SendStream::send_reset`]: struct.SendStream.html#method.send_reset
#[derive(PartialEq, Eq, Clone, Copy)]
pub struct Reason(u32);

impl Reason {
    /// The associated condition is not a result of an error.
    ///
    /// For example, a GOAWAY might include this code to indicate graceful
    /// shutdown of a connection.
    pub const NO_ERROR: Reason = Reason(0);
    /// The endpoint detected an unspecific protocol error.
    ///
    /// This error is for use when a more specific error code is not available.
    pub const PROTOCOL_ERROR: Reason = Reason(1);
    /// The endpoint encountered an unexpected internal error.
    pub const INTERNAL_ERROR: Reason = Reason(2);
    /// The endpoint detected that its peer violated the flow-control protocol.
    pub const FLOW_CONTROL_ERROR: Reason = Reason(3);
    /// The endpoint sent a SETTINGS frame but did not receive a response in
    /// a timely manner.
    pub const SETTINGS_TIMEOUT: Reason = Reason(4);
    /// The endpoint received a frame after a stream was half-closed.
    pub const STREAM_CLOSED: Reason = Reason(5);
    /// The endpoint received a frame with an invalid size.
    pub const FRAME_SIZE_ERROR: Reason = Reason(6);
    /// The endpoint refused the stream prior to performing any application
    /// processing.
    pub const REFUSED_STREAM: Reason = Reason(7);
    /// Used by the endpoint to indicate that the stream is no longer needed.
    pub const CANCEL: Reason = Reason(8);
    /// The endpoint is unable to maintain the header compression context for
    /// the connection.
    pub const COMPRESSION_ERROR: Reason = Reason(9);
    /// The connection established in response to a CONNECT request was reset
    /// or abnormally closed.
    pub const CONNECT_ERROR: Reason = Reason(10);
    /// The endpoint detected that its peer is exhibiting a behavior that might
    /// be generating excessive load.
    pub const ENHANCE_YOUR_CALM: Reason = Reason(11);
    /// The underlying transport has properties that do not meet minimum
    /// security requirements.
    pub const INADEQUATE_SECURITY: Reason = Reason(12);
    /// The endpoint requires that HTTP/1.1 be used instead of HTTP/2.
    pub const HTTP_1_1_REQUIRED: Reason = Reason(13);

    /// Get a string description of the error code.
    pub fn description(&self) -> &str {
        match self.0 {
            0 => "not a result of an error",
            1 => "unspecific protocol error detected",
            2 => "unexpected internal error encountered",
            3 => "flow-control protocol violated",
            4 => "settings ACK not received in timely manner",
            5 => "received frame when stream half-closed",
            6 => "frame with invalid size",
            7 => "refused stream before processing any application logic",
            8 => "stream no longer needed",
            9 => "unable to maintain the header compression context",
            10 => {
                "connection established in response to a CONNECT request was reset or abnormally \
                 closed"
            }
            11 => "detected excessive load generating behavior",
            12 => "security properties do not meet minimum requirements",
            13 => "endpoint requires HTTP/1.1",
            _ => "unknown reason",
        }
    }
}

impl From<u32> for Reason {
    fn from(src: u32) -> Reason {
        Reason(src)
    }
}

impl From<Reason> for u32 {
    fn from(src: Reason) -> u32 {
        src.0
    }
}

impl fmt::Debug for Reason {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        let name = match self.0 {
            0 => "NO_ERROR",
            1 => "PROTOCOL_ERROR",
            2 => "INTERNAL_ERROR",
            3 => "FLOW_CONTROL_ERROR",
            4 => "SETTINGS_TIMEOUT",
            5 => "STREAM_CLOSED",
            6 => "FRAME_SIZE_ERROR",
            7 => "REFUSED_STREAM",
            8 => "CANCEL",
            9 => "COMPRESSION_ERROR",
            10 => "CONNECT_ERROR",
            11 => "ENHANCE_YOUR_CALM",
            12 => "INADEQUATE_SECURITY",
            13 => "HTTP_1_1_REQUIRED",
            other => return f.debug_tuple("Reason").field(&Hex(other)).finish(),
        };
        f.write_str(name)
    }
}

struct Hex(u32);

impl fmt::Debug for Hex {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        fmt::LowerHex::fmt(&self.0, f)
    }
}

impl fmt::Display for Reason {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        write!(fmt, "{}", self.description())
    }
}