specters 2.1.2

HTTP client with full TLS, HTTP/2, and HTTP/3 fingerprint control
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
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

//! Error types for specter crate.

use std::io;

/// Result type alias using our Error type.
pub type Result<T> = std::result::Result<T, Error>;

/// Errors that can occur during HTTP operations.
#[derive(Debug, thiserror::Error)]
pub enum Error {
    /// HTTP protocol error.
    #[error("HTTP protocol error: {0}")]
    HttpProtocol(String),

    /// Invalid HTTP status code.
    #[error("HTTP {status}: {message}")]
    HttpStatus { status: u16, message: String },

    /// Redirect limit exceeded.
    #[error("Redirect limit exceeded ({count} redirects)")]
    RedirectLimit { count: u32 },

    /// Invalid redirect URL.
    #[error("Invalid redirect URL: {0}")]
    InvalidRedirectUrl(String),

    /// Cookie parsing error.
    #[error("Cookie parse error: {0}")]
    CookieParse(String),

    /// Decompression error.
    #[error("Decompression error: {0}")]
    Decompression(String),

    /// URL parsing error.
    #[error("URL parse error: {0}")]
    UrlParse(#[from] url::ParseError),

    /// JSON serialization/deserialization error.
    #[error("JSON error: {0}")]
    Json(#[from] serde_json::Error),

    /// URL encoding error.
    #[error("URL encoding error: {0}")]
    UrlEncode(#[from] serde_urlencoded::ser::Error),

    /// IO error.
    #[error("IO error: {0}")]
    Io(#[from] io::Error),

    /// Missing required field or data.
    #[error("Missing required: {0}")]
    Missing(String),

    /// Generic timeout error.
    #[error("Operation timed out: {0}")]
    Timeout(String),

    /// Connect timeout (TCP + TLS handshake).
    #[error("Connect timeout after {0:?}")]
    ConnectTimeout(std::time::Duration),

    /// TTFB (time-to-first-byte) timeout.
    #[error("TTFB timeout after {0:?} - server did not respond with headers")]
    TtfbTimeout(std::time::Duration),

    /// Read idle timeout (no data received within duration).
    #[error("Read idle timeout after {0:?} - stream may be hung")]
    ReadIdleTimeout(std::time::Duration),

    /// Write idle timeout (could not send data within duration).
    #[error("Write idle timeout after {0:?}")]
    WriteIdleTimeout(std::time::Duration),

    /// Total request deadline exceeded.
    #[error("Total request deadline exceeded after {0:?}")]
    TotalTimeout(std::time::Duration),

    /// Pool acquire timeout (no connection available).
    #[error("Pool acquire timeout after {0:?} - no connections available")]
    PoolAcquireTimeout(std::time::Duration),

    /// Connection error.
    #[error("Connection error: {0}")]
    Connection(String),

    /// TLS/SSL error.
    #[error("TLS error: {0}")]
    Tls(String),

    /// QUIC/HTTP3 error.
    #[error("QUIC error: {0}")]
    Quic(String),

    /// HTTP/2 SETTINGS_TIMEOUT error (RFC 9113 Section 7).
    #[error("SETTINGS_TIMEOUT (0x04): No SETTINGS frame received within {0:?}")]
    SettingsTimeout(std::time::Duration),
}

impl Error {
    /// Create an HTTP status error.
    pub fn http_status(status: u16, message: impl Into<String>) -> Self {
        Self::HttpStatus {
            status,
            message: message.into(),
        }
    }

    /// Create a missing field error.
    pub fn missing(field: impl Into<String>) -> Self {
        Self::Missing(field.into())
    }

    /// Create an IO error with custom message.
    pub fn io(message: impl Into<String>) -> Self {
        Self::Io(io::Error::other(message.into()))
    }

    /// Create an HTTP protocol error.
    pub fn http_protocol(message: impl Into<String>) -> Self {
        Self::HttpProtocol(message.into())
    }

    /// Create a connection error.
    pub fn connection(message: impl Into<String>) -> Self {
        Self::Connection(message.into())
    }

    /// Create a timeout error.
    pub fn timeout(message: impl Into<String>) -> Self {
        Self::Timeout(message.into())
    }

    /// Create a TLS error.
    pub fn tls(message: impl Into<String>) -> Self {
        Self::Tls(message.into())
    }

    /// Create a QUIC error.
    pub fn quic(message: impl Into<String>) -> Self {
        Self::Quic(message.into())
    }
}