avx-http 0.4.0

Pure Rust HTTP/1.1 + HTTP/2 implementation with ZERO dependencies - no tokio, no serde, no hyper, 100% proprietary
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

//! HTTP/2 implementation - Pure Rust, zero dependencies
//!
//! RFC 7540 compliant HTTP/2 frame parsing, HPACK compression, multiplexing

pub mod frame;
pub mod hpack;
pub mod connection;
pub mod stream;

// Re-export submodules
pub use self::frame as frames;
pub use self::connection as conn;

pub use frame::{
    Frame, FrameHeader, DataFrame, HeadersFrame, SettingsFrame, PriorityFrame,
    Setting, SETTINGS_HEADER_TABLE_SIZE, SETTINGS_ENABLE_PUSH,
    SETTINGS_MAX_CONCURRENT_STREAMS, SETTINGS_INITIAL_WINDOW_SIZE,
    SETTINGS_MAX_FRAME_SIZE, SETTINGS_MAX_HEADER_LIST_SIZE,
};
pub use hpack::{HpackEncoder, HpackDecoder};
pub use connection::Http2Connection;
pub use stream::{Stream, StreamState};

/// HTTP/2 connection preface
pub const CONNECTION_PREFACE: &[u8] = b"PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n";

/// HTTP/2 protocol error codes
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ErrorCode {
    /// No error
    NoError = 0x0,
    /// Protocol error
    ProtocolError = 0x1,
    /// Internal error
    InternalError = 0x2,
    /// Flow control error
    FlowControlError = 0x3,
    /// Settings timeout
    SettingsTimeout = 0x4,
    /// Stream closed
    StreamClosed = 0x5,
    /// Frame size error
    FrameSizeError = 0x6,
    /// Refused stream
    RefusedStream = 0x7,
    /// Cancel
    Cancel = 0x8,
    /// Compression error
    CompressionError = 0x9,
    /// Connect error
    ConnectError = 0xa,
    /// Enhance your calm
    EnhanceYourCalm = 0xb,
    /// Inadequate security
    InadequateSecurity = 0xc,
    /// HTTP/1.1 required
    Http11Required = 0xd,
}

impl ErrorCode {
    /// Convert from u32
    pub fn from_u32(code: u32) -> Option<Self> {
        match code {
            0x0 => Some(ErrorCode::NoError),
            0x1 => Some(ErrorCode::ProtocolError),
            0x2 => Some(ErrorCode::InternalError),
            0x3 => Some(ErrorCode::FlowControlError),
            0x4 => Some(ErrorCode::SettingsTimeout),
            0x5 => Some(ErrorCode::StreamClosed),
            0x6 => Some(ErrorCode::FrameSizeError),
            0x7 => Some(ErrorCode::RefusedStream),
            0x8 => Some(ErrorCode::Cancel),
            0x9 => Some(ErrorCode::CompressionError),
            0xa => Some(ErrorCode::ConnectError),
            0xb => Some(ErrorCode::EnhanceYourCalm),
            0xc => Some(ErrorCode::InadequateSecurity),
            0xd => Some(ErrorCode::Http11Required),
            _ => None,
        }
    }
}

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

    #[test]
    fn test_connection_preface() {
        assert_eq!(CONNECTION_PREFACE.len(), 24);
        assert!(CONNECTION_PREFACE.starts_with(b"PRI * HTTP/2.0"));
    }

    #[test]
    fn test_error_code() {
        assert_eq!(ErrorCode::from_u32(0), Some(ErrorCode::NoError));
        assert_eq!(ErrorCode::from_u32(1), Some(ErrorCode::ProtocolError));
        assert_eq!(ErrorCode::from_u32(999), None);
    }
}