http_type/request/
impl.rs

1use crate::*;
2
3/// Implements the `std::error::Error` trait for `RequestError`.
4impl std::error::Error for RequestError {}
5
6/// Implements the `Display` trait for `RequestError`, allowing it to be formatted as a string.
7impl Display for RequestError {
8    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
9        match self {
10            Self::HttpRead(status) => write!(f, "Http read error [{}]", status.code()),
11            Self::GetTcpStream(status) => write!(f, "Failed to get tcp stream [{}]", status.code()),
12            Self::GetTlsStream(status) => write!(f, "Failed to get tls stream [{}]", status.code()),
13            Self::ReadConnection(status) => write!(f, "Connection read error [{}]", status.code()),
14            Self::RequestAborted(status) => write!(f, "Request aborted [{}]", status.code()),
15            Self::TlsStreamConnect(status) => {
16                write!(f, "Tls stream connection error [{}]", status.code())
17            }
18            Self::NeedOpenRedirect(status) => {
19                write!(f, "Open redirect required [{}]", status.code())
20            }
21            Self::MaxRedirectTimes(status) => {
22                write!(f, "Exceeded maximum redirect attempts [{}]", status.code())
23            }
24            Self::MethodsNotSupport(status) => {
25                write!(f, "Http method not supported [{}]", status.code())
26            }
27            Self::RedirectInvalidUrl(status) => {
28                write!(f, "Invalid redirect url [{}]", status.code())
29            }
30            Self::ClientDisconnected(status) => {
31                write!(f, "Client disconnected [{}]", status.code())
32            }
33            Self::RedirectUrlDeadLoop(status) => {
34                write!(f, "Redirect url dead loop detected [{}]", status.code())
35            }
36            Self::ClientClosedConnection(status) => {
37                write!(f, "Client closed connection [{}]", status.code())
38            }
39            Self::IncompleteWebSocketFrame(status) => write!(
40                f,
41                "WebSocket connection closed before a complete frame was received [{}]",
42                status.code()
43            ),
44            Self::RequestTooLong(status) => write!(f, "Request line too long [{}]", status.code()),
45            Self::PathTooLong(status) => write!(f, "Path too long [{}]", status.code()),
46            Self::QueryTooLong(status) => write!(f, "Query string too long [{}]", status.code()),
47            Self::HeaderLineTooLong(status) => {
48                write!(f, "Header line too long [{}]", status.code())
49            }
50            Self::TooManyHeaders(status) => write!(f, "Too many headers [{}]", status.code()),
51            Self::HeaderKeyTooLong(status) => write!(f, "Header key too long [{}]", status.code()),
52            Self::HeaderValueTooLong(status) => {
53                write!(f, "Header value too long [{}]", status.code())
54            }
55            Self::ContentLengthTooLarge(status) => {
56                write!(f, "Content length too large [{}]", status.code())
57            }
58            Self::InvalidContentLength(status) => {
59                write!(f, "Invalid content length [{}]", status.code())
60            }
61            Self::Unknown(status) => write!(f, "Unknown error occurred [{}]", status.code()),
62            Self::InvalidUrlScheme(status) => write!(f, "Invalid URL scheme [{}]", status.code()),
63            Self::InvalidUrlHost(status) => write!(f, "Invalid URL host [{}]", status.code()),
64            Self::InvalidUrlPort(status) => write!(f, "Invalid URL port [{}]", status.code()),
65            Self::InvalidUrlPath(status) => write!(f, "Invalid URL path [{}]", status.code()),
66            Self::InvalidUrlQuery(status) => write!(f, "Invalid URL query [{}]", status.code()),
67            Self::InvalidUrlFragment(status) => {
68                write!(f, "Invalid URL fragment [{}]", status.code())
69            }
70            Self::ReadTimeoutNotSet(status) => {
71                write!(f, "Failed to set read timeout [{}]", status.code())
72            }
73            Self::WriteTimeoutNotSet(status) => {
74                write!(f, "Failed to set write timeout [{}]", status.code())
75            }
76            Self::TcpConnectionFailed(status) => {
77                write!(f, "Tcp connection failed [{}]", status.code())
78            }
79            Self::TlsHandshakeFailed(status) => {
80                write!(f, "Tls handshake failed [{}]", status.code())
81            }
82            Self::TlsCertificateInvalid(status) => {
83                write!(f, "Tls certificate invalid [{}]", status.code())
84            }
85            Self::WebSocketFrameTooLarge(status) => {
86                write!(f, "WebSocket frame too large [{}]", status.code())
87            }
88            Self::WebSocketOpcodeUnsupported(status) => {
89                write!(f, "WebSocket opcode unsupported [{}]", status.code())
90            }
91            Self::WebSocketMaskMissing(status) => {
92                write!(f, "WebSocket mask missing [{}]", status.code())
93            }
94            Self::WebSocketPayloadCorrupted(status) => {
95                write!(f, "WebSocket payload corrupted [{}]", status.code())
96            }
97            Self::WebSocketInvalidUtf8(status) => {
98                write!(f, "WebSocket invalid UTF-8 [{}]", status.code())
99            }
100            Self::WebSocketInvalidCloseCode(status) => {
101                write!(f, "WebSocket invalid close code [{}]", status.code())
102            }
103            Self::WebSocketInvalidExtension(status) => {
104                write!(f, "WebSocket invalid extension [{}]", status.code())
105            }
106            Self::HttpRequestPartsInsufficient(status) => {
107                write!(f, "HTTP request parts insufficient [{}]", status.code())
108            }
109        }
110    }
111}
112
113impl RequestError {
114    /// Gets the HTTP status associated with this error.
115    ///
116    /// Returns the HttpStatus enum variant that corresponds to this error.
117    ///
118    /// # Arguments
119    ///
120    /// - `&self` - The RequestError instance.
121    ///
122    /// # Returns
123    ///
124    /// - `HttpStatus` - The HTTP status associated with this error.
125    #[inline(always)]
126    pub fn get_http_status(&self) -> HttpStatus {
127        match self {
128            Self::HttpRead(status) => *status,
129            Self::GetTcpStream(status) => *status,
130            Self::GetTlsStream(status) => *status,
131            Self::ReadConnection(status) => *status,
132            Self::RequestAborted(status) => *status,
133            Self::TlsStreamConnect(status) => *status,
134            Self::NeedOpenRedirect(status) => *status,
135            Self::MaxRedirectTimes(status) => *status,
136            Self::MethodsNotSupport(status) => *status,
137            Self::RedirectInvalidUrl(status) => *status,
138            Self::ClientDisconnected(status) => *status,
139            Self::RedirectUrlDeadLoop(status) => *status,
140            Self::ClientClosedConnection(status) => *status,
141            Self::IncompleteWebSocketFrame(status) => *status,
142            Self::RequestTooLong(status) => *status,
143            Self::PathTooLong(status) => *status,
144            Self::QueryTooLong(status) => *status,
145            Self::HeaderLineTooLong(status) => *status,
146            Self::TooManyHeaders(status) => *status,
147            Self::HeaderKeyTooLong(status) => *status,
148            Self::HeaderValueTooLong(status) => *status,
149            Self::ContentLengthTooLarge(status) => *status,
150            Self::InvalidContentLength(status) => *status,
151            Self::Unknown(status) => *status,
152            Self::InvalidUrlScheme(status) => *status,
153            Self::InvalidUrlHost(status) => *status,
154            Self::InvalidUrlPort(status) => *status,
155            Self::InvalidUrlPath(status) => *status,
156            Self::InvalidUrlQuery(status) => *status,
157            Self::InvalidUrlFragment(status) => *status,
158            Self::ReadTimeoutNotSet(status) => *status,
159            Self::WriteTimeoutNotSet(status) => *status,
160            Self::TcpConnectionFailed(status) => *status,
161            Self::TlsHandshakeFailed(status) => *status,
162            Self::TlsCertificateInvalid(status) => *status,
163            Self::WebSocketFrameTooLarge(status) => *status,
164            Self::WebSocketOpcodeUnsupported(status) => *status,
165            Self::WebSocketMaskMissing(status) => *status,
166            Self::WebSocketPayloadCorrupted(status) => *status,
167            Self::WebSocketInvalidUtf8(status) => *status,
168            Self::WebSocketInvalidCloseCode(status) => *status,
169            Self::WebSocketInvalidExtension(status) => *status,
170            Self::HttpRequestPartsInsufficient(status) => *status,
171        }
172    }
173
174    /// Gets the numeric HTTP status code associated with this error.
175    ///
176    /// Returns the numeric status code (e.g., 400, 404, 500) that corresponds to this error.
177    ///
178    /// # Arguments
179    ///
180    /// - `&self` - The RequestError instance.
181    ///
182    /// # Returns
183    ///
184    /// - `ResponseStatusCode` - The numeric HTTP status code.
185    pub fn get_http_status_code(&self) -> ResponseStatusCode {
186        self.get_http_status().code()
187    }
188}
189
190impl Default for RequestConfig {
191    /// Creates a `RequestConfig` with secure default values.
192    ///
193    /// # Returns
194    ///
195    /// - `RequestConfig` - A new config instance with secure defaults.
196    #[inline(always)]
197    fn default() -> Self {
198        Self {
199            buffer_size: DEFAULT_BUFFER_SIZE,
200            max_request_line_length: DEFAULT_MAX_REQUEST_LINE_LENGTH,
201            max_path_length: DEFAULT_MAX_PATH_LENGTH,
202            max_query_length: DEFAULT_MAX_QUERY_LENGTH,
203            max_header_line_length: DEFAULT_MAX_HEADER_LINE_LENGTH,
204            max_header_count: DEFAULT_MAX_HEADER_COUNT,
205            max_header_key_length: DEFAULT_MAX_HEADER_KEY_LENGTH,
206            max_header_value_length: DEFAULT_MAX_HEADER_VALUE_LENGTH,
207            max_body_size: DEFAULT_MAX_BODY_SIZE,
208            max_ws_frame_size: DEFAULT_MAX_WS_FRAME_SIZE,
209            max_ws_frames: DEFAULT_MAX_WS_FRAMES,
210            http_read_timeout_ms: DEFAULT_HTTP_READ_TIMEOUT_MS,
211            ws_read_timeout_ms: DEFAULT_WS_READ_TIMEOUT_MS,
212        }
213    }
214}
215
216impl RequestConfig {
217    /// Creates a new `RequestConfig` with default values.
218    ///
219    /// # Returns
220    ///
221    /// - `RequestConfig` - A new config instance with default values.
222    #[inline(always)]
223    pub fn new() -> Self {
224        Self::default()
225    }
226
227    /// Creates a config optimized for high-security environments.
228    ///
229    /// This configuration uses more restrictive limits to provide
230    /// maximum protection against various attacks.
231    ///
232    /// # Returns
233    ///
234    /// - `RequestConfig` - A new config with high-security settings.
235    #[inline(always)]
236    pub fn high_security() -> Self {
237        Self {
238            buffer_size: DEFAULT_HIGH_SECURITY_BUFFER_SIZE,
239            max_request_line_length: DEFAULT_HIGH_SECURITY_MAX_REQUEST_LINE_LENGTH,
240            max_path_length: DEFAULT_HIGH_SECURITY_MAX_PATH_LENGTH,
241            max_query_length: DEFAULT_HIGH_SECURITY_MAX_QUERY_LENGTH,
242            max_header_line_length: DEFAULT_HIGH_SECURITY_MAX_HEADER_LINE_LENGTH,
243            max_header_count: DEFAULT_HIGH_SECURITY_MAX_HEADER_COUNT,
244            max_header_key_length: DEFAULT_HIGH_SECURITY_MAX_HEADER_KEY_LENGTH,
245            max_header_value_length: DEFAULT_HIGH_SECURITY_MAX_HEADER_VALUE_LENGTH,
246            max_body_size: DEFAULT_HIGH_SECURITY_MAX_BODY_SIZE,
247            max_ws_frame_size: DEFAULT_HIGH_SECURITY_MAX_WS_FRAME_SIZE,
248            max_ws_frames: DEFAULT_HIGH_SECURITY_MAX_WS_FRAMES,
249            http_read_timeout_ms: DEFAULT_HIGH_SECURITY_HTTP_READ_TIMEOUT_MS,
250            ws_read_timeout_ms: DEFAULT_HIGH_SECURITY_WS_READ_TIMEOUT_MS,
251        }
252    }
253}
254
255/// Provides a default value for `Request`.
256///
257/// Returns a new `Request` instance with all fields initialized to their default values.
258impl Default for Request {
259    #[inline(always)]
260    fn default() -> Self {
261        Self {
262            method: Method::default(),
263            host: String::new(),
264            version: HttpVersion::default(),
265            path: String::new(),
266            querys: hash_map_xx_hash3_64(),
267            headers: hash_map_xx_hash3_64(),
268            body: Vec::new(),
269        }
270    }
271}
272
273impl Request {
274    /// Creates a new instance of `Request`.
275    ///
276    /// # Returns
277    ///
278    /// - `Request` - A new request instance with default values.
279    #[inline(always)]
280    pub fn new() -> Self {
281        Self::default()
282    }
283
284    /// Parses an HTTP request from a buffered TCP stream reader.
285    ///
286    /// Reads request line, headers and body from the stream and constructs a Request object.
287    ///
288    /// # Arguments
289    ///
290    /// - `&mut BufReader<&mut TcpStream>` - The buffered TCP stream reader.
291    /// - `&RequestConfig` - Configuration for security limits and buffer settings.
292    ///
293    /// # Returns
294    ///
295    /// - `Result<Request, RequestError>` - The parsed request or an error.
296    pub async fn http_from_reader(
297        reader: &mut BufReader<&mut TcpStream>,
298        config: &RequestConfig,
299    ) -> Result<Request, RequestError> {
300        let buffer_size: usize = *config.get_buffer_size();
301        let mut request_line: String = String::with_capacity(buffer_size);
302        let timeout_duration: Duration = Duration::from_millis(config.http_read_timeout_ms);
303        let bytes_read: usize = timeout(
304            timeout_duration,
305            AsyncBufReadExt::read_line(reader, &mut request_line),
306        )
307        .await
308        .map_err(|_| RequestError::ReadTimeoutNotSet(HttpStatus::RequestTimeout))?
309        .map_err(|_| RequestError::HttpRead(HttpStatus::BadRequest))?;
310        if bytes_read > config.max_request_line_length {
311            return Err(RequestError::RequestTooLong(HttpStatus::BadRequest));
312        }
313        let parts: Vec<&str> = request_line.split_whitespace().collect();
314        let parts_len: usize = parts.len();
315        if parts_len < 3 {
316            return Err(RequestError::HttpRequestPartsInsufficient(
317                HttpStatus::BadRequest,
318            ));
319        }
320        let full_path: &str = parts[1];
321        if full_path.len() > config.max_path_length {
322            return Err(RequestError::PathTooLong(HttpStatus::URITooLong));
323        }
324        let method: RequestMethod = parts[0]
325            .parse::<RequestMethod>()
326            .unwrap_or(Method::Unknown(parts[0].to_string()));
327        let full_path: RequestPath = full_path.to_string();
328        let version: RequestVersion = parts[2]
329            .parse::<RequestVersion>()
330            .unwrap_or(RequestVersion::Unknown(parts[2].to_string()));
331        let hash_index: Option<usize> = full_path.find(HASH);
332        let query_index: Option<usize> = full_path.find(QUERY);
333        let query_string: String = query_index.map_or_else(String::new, |i| {
334            let temp: &str = &full_path[i + 1..];
335            if hash_index.is_none() || hash_index.unwrap() <= i {
336                return temp.to_owned();
337            }
338            temp.split(HASH).next().unwrap_or_default().to_owned()
339        });
340        if query_string.len() > config.max_query_length {
341            return Err(RequestError::QueryTooLong(HttpStatus::URITooLong));
342        }
343        let querys: RequestQuerys = Self::parse_querys(&query_string);
344        let path: RequestPath = if let Some(i) = query_index.or(hash_index) {
345            full_path[..i].to_owned()
346        } else {
347            full_path.to_owned()
348        };
349        let mut headers: RequestHeaders = hash_map_xx_hash3_64();
350        let mut host: RequestHost = String::new();
351        let mut content_length: usize = 0;
352        let mut header_count: usize = 0;
353        loop {
354            let mut header_line: String = String::with_capacity(buffer_size);
355            let timeout_duration: Duration = Duration::from_millis(config.http_read_timeout_ms);
356            let bytes_read: usize = timeout(
357                timeout_duration,
358                AsyncBufReadExt::read_line(reader, &mut header_line),
359            )
360            .await
361            .map_err(|_| RequestError::ReadTimeoutNotSet(HttpStatus::RequestTimeout))?
362            .map_err(|_| RequestError::HttpRead(HttpStatus::BadRequest))?;
363            if bytes_read > config.max_header_line_length {
364                return Err(RequestError::HeaderLineTooLong(
365                    HttpStatus::RequestHeaderFieldsTooLarge,
366                ));
367            }
368            let header_line: &str = header_line.trim();
369            if header_line.is_empty() {
370                break;
371            }
372            header_count += 1;
373            if header_count > config.max_header_count {
374                return Err(RequestError::TooManyHeaders(
375                    HttpStatus::RequestHeaderFieldsTooLarge,
376                ));
377            }
378            if let Some((key_part, value_part)) = header_line.split_once(COLON) {
379                let key: String = key_part.trim().to_ascii_lowercase();
380                if key.is_empty() {
381                    continue;
382                }
383                if key.len() > config.max_header_key_length {
384                    return Err(RequestError::HeaderKeyTooLong(
385                        HttpStatus::RequestHeaderFieldsTooLarge,
386                    ));
387                }
388                let value: String = value_part.trim().to_string();
389                if value.len() > config.max_header_value_length {
390                    return Err(RequestError::HeaderValueTooLong(
391                        HttpStatus::RequestHeaderFieldsTooLarge,
392                    ));
393                }
394                if key == HOST {
395                    host = value.clone();
396                } else if key == CONTENT_LENGTH {
397                    match value.parse::<usize>() {
398                        Ok(length) => {
399                            if length > config.max_body_size {
400                                return Err(RequestError::ContentLengthTooLarge(
401                                    HttpStatus::PayloadTooLarge,
402                                ));
403                            }
404                            content_length = length;
405                        }
406                        Err(_) => {
407                            return Err(RequestError::InvalidContentLength(HttpStatus::BadRequest));
408                        }
409                    }
410                }
411                headers.entry(key).or_default().push_back(value);
412            }
413        }
414        let mut body: RequestBody = Vec::with_capacity(content_length);
415        if content_length > 0 {
416            body.resize(content_length, 0);
417            let timeout_duration: Duration = Duration::from_millis(config.http_read_timeout_ms);
418            timeout(
419                timeout_duration,
420                AsyncReadExt::read_exact(reader, &mut body),
421            )
422            .await
423            .map_err(|_| RequestError::ReadTimeoutNotSet(HttpStatus::RequestTimeout))?
424            .map_err(|_| RequestError::ReadConnection(HttpStatus::BadRequest))?;
425        }
426        Ok(Request {
427            method,
428            host,
429            version,
430            path,
431            querys,
432            headers,
433            body,
434        })
435    }
436
437    /// Parses an HTTP request from a TCP stream.
438    ///
439    /// Wraps the stream in a buffered reader and delegates to `http_from_reader`.
440    ///
441    /// # Arguments
442    ///
443    /// - `&ArcRwLock<TcpStream>` - The TCP stream to read from.
444    /// - `&RequestConfig` - Configuration for security limits and buffer settings.
445    ///
446    /// # Returns
447    ///
448    /// - `Result<Request, RequestError>` - The parsed request or an error.
449    pub async fn http_from_stream(
450        stream: &ArcRwLockStream,
451        config: &RequestConfig,
452    ) -> Result<Request, RequestError> {
453        let mut buf_stream: RwLockWriteGuard<'_, TcpStream> = stream.write().await;
454        let mut reader: BufReader<&mut TcpStream> = BufReader::new(&mut buf_stream);
455        Self::http_from_reader(&mut reader, config).await
456    }
457
458    /// Parses a WebSocket request from a TCP stream.
459    ///
460    /// Wraps the stream in a buffered reader and delegates to `ws_from_reader`.
461    ///
462    /// # Arguments
463    ///
464    /// - `&ArcRwLock<TcpStream>` - The TCP stream to read from.
465    /// - `&RequestConfig` - Configuration for security limits and buffer settings.
466    ///
467    /// # Returns
468    ///
469    /// - `Result<Request, RequestError>` - The parsed WebSocket request or an error.
470    pub async fn ws_from_stream(
471        &mut self,
472        stream: &ArcRwLockStream,
473        config: &RequestConfig,
474    ) -> Result<Request, RequestError> {
475        let buffer_size: usize = *config.get_buffer_size();
476        let mut dynamic_buffer: Vec<u8> = Vec::with_capacity(buffer_size);
477        let temp_buffer_size: usize = buffer_size;
478        let mut temp_buffer: Vec<u8> = vec![0; temp_buffer_size];
479        let mut full_frame: Vec<u8> = Vec::with_capacity(config.max_ws_frame_size);
480        let mut frame_count: usize = 0;
481        let mut is_client_response: bool = false;
482        loop {
483            let timeout_duration: Duration = Duration::from_millis(config.ws_read_timeout_ms);
484            let len: usize = match timeout(
485                timeout_duration,
486                stream.write().await.read(&mut temp_buffer),
487            )
488            .await
489            {
490                Ok(result) => match result {
491                    Ok(len) => len,
492                    Err(err) => {
493                        if err.kind() == ErrorKind::ConnectionReset
494                            || err.kind() == ErrorKind::ConnectionAborted
495                        {
496                            return Err(RequestError::ClientDisconnected(HttpStatus::BadRequest));
497                        }
498                        return Err(RequestError::Unknown(HttpStatus::InternalServerError));
499                    }
500                },
501                Err(_) => {
502                    if !is_client_response {
503                        return Err(RequestError::ReadTimeoutNotSet(HttpStatus::RequestTimeout));
504                    }
505                    is_client_response = false;
506                    let ping_frame: Vec<u8> = WebSocketFrame::create_ping_frame();
507                    stream.send_body(&ping_frame).await.map_err(|_| {
508                        RequestError::WriteTimeoutNotSet(HttpStatus::InternalServerError)
509                    })?;
510                    stream.flush().await;
511                    continue;
512                }
513            };
514            if len == 0 {
515                return Err(RequestError::IncompleteWebSocketFrame(
516                    HttpStatus::BadRequest,
517                ));
518            }
519            dynamic_buffer.extend_from_slice(&temp_buffer[..len]);
520            while let Some((frame, consumed)) = WebSocketFrame::decode_ws_frame(&dynamic_buffer) {
521                is_client_response = true;
522                dynamic_buffer.drain(0..consumed);
523                frame_count += 1;
524                if frame_count > config.max_ws_frames {
525                    return Err(RequestError::TooManyHeaders(
526                        HttpStatus::RequestHeaderFieldsTooLarge,
527                    ));
528                }
529                match frame.get_opcode() {
530                    WebSocketOpcode::Close => {
531                        return Err(RequestError::ClientClosedConnection(HttpStatus::BadRequest));
532                    }
533                    WebSocketOpcode::Ping | WebSocketOpcode::Pong => {
534                        continue;
535                    }
536                    WebSocketOpcode::Text | WebSocketOpcode::Binary => {
537                        let payload_data: &[u8] = frame.get_payload_data();
538                        if payload_data.len() > config.max_ws_frame_size {
539                            return Err(RequestError::WebSocketFrameTooLarge(
540                                HttpStatus::PayloadTooLarge,
541                            ));
542                        }
543                        if full_frame.len() + payload_data.len() > config.max_ws_frame_size {
544                            return Err(RequestError::WebSocketFrameTooLarge(
545                                HttpStatus::PayloadTooLarge,
546                            ));
547                        }
548                        full_frame.extend_from_slice(payload_data);
549                        if *frame.get_fin() {
550                            let mut request: Request = self.clone();
551                            request.body = full_frame;
552                            return Ok(request);
553                        }
554                    }
555                    _ => {
556                        return Err(RequestError::WebSocketOpcodeUnsupported(
557                            HttpStatus::NotImplemented,
558                        ));
559                    }
560                }
561            }
562        }
563    }
564
565    /// Parses a query string as_ref key-value pairs.
566    ///
567    /// Expects format "key1=value1&key2=value2". Empty values are allowed.
568    ///
569    /// # Arguments
570    ///
571    /// - `&str` - The query string to parse.
572    ///
573    /// # Returns
574    ///
575    /// - `HashMap<String, String>` - The parsed query parameters.
576    fn parse_querys<Q>(query: Q) -> RequestQuerys
577    where
578        Q: AsRef<str>,
579    {
580        let mut query_map: RequestQuerys = hash_map_xx_hash3_64();
581        for pair in query.as_ref().split(AND) {
582            if let Some((key, value)) = pair.split_once(EQUAL) {
583                if !key.is_empty() {
584                    query_map.insert(key.to_string(), value.to_string());
585                }
586            } else if !pair.is_empty() {
587                query_map.insert(pair.to_string(), String::new());
588            }
589        }
590        query_map
591    }
592
593    /// Tries to get a query parameter value by key.
594    ///
595    /// The key type must implement AsRef<str> conversion.
596    ///
597    /// # Arguments
598    ///
599    /// - `AsRef<str>` - The query parameter key (implements AsRef<str>).
600    ///
601    /// # Returns
602    ///
603    /// - `Option<RequestQuerysValue>` - The parameter value if exists.
604    #[inline(always)]
605    pub fn try_get_query<K>(&self, key: K) -> Option<RequestQuerysValue>
606    where
607        K: AsRef<str>,
608    {
609        self.querys.get(key.as_ref()).cloned()
610    }
611
612    /// Gets a query parameter value by key.
613    ///
614    /// The key type must implement AsRef<str> conversion.
615    ///
616    /// # Arguments
617    ///
618    /// - `AsRef<str>` - The query parameter key (implements AsRef<str>).
619    ///
620    /// # Returns
621    ///
622    /// - `RequestQuerysValue` - The parameter value if exists.
623    ///
624    /// # Panics
625    ///
626    /// This function will panic if the query parameter key is not found.
627    #[inline(always)]
628    pub fn get_query<K>(&self, key: K) -> RequestQuerysValue
629    where
630        K: AsRef<str>,
631    {
632        self.try_get_query(key).unwrap()
633    }
634
635    /// Tries to retrieve the value of a request header by its key.
636    ///
637    /// # Arguments
638    ///
639    /// - `AsRef<str>` - The header's key (must implement AsRef<str>).
640    ///
641    /// # Returns
642    ///
643    /// - `Option<RequestHeadersValue>` - The optional header values.
644    #[inline(always)]
645    pub fn try_get_header<K>(&self, key: K) -> Option<RequestHeadersValue>
646    where
647        K: AsRef<str>,
648    {
649        self.headers.get(key.as_ref()).cloned()
650    }
651
652    /// Retrieves the value of a request header by its key.
653    ///
654    /// # Arguments
655    ///
656    /// - `AsRef<str>` - The header's key (must implement AsRef<str>).
657    ///
658    /// # Returns
659    ///
660    /// - `RequestHeadersValue` - The optional header values.
661    ///
662    /// # Panics
663    ///
664    /// This function will panic if the header key is not found.
665    #[inline(always)]
666    pub fn get_header<K>(&self, key: K) -> RequestHeadersValue
667    where
668        K: AsRef<str>,
669    {
670        self.try_get_header(key).unwrap()
671    }
672
673    /// Tries to retrieve the first value of a request header by its key.
674    ///
675    /// # Arguments
676    ///
677    /// - `AsRef<str>` - The header's key (must implement AsRef<str>).
678    ///
679    /// # Returns
680    ///
681    /// - `Option<RequestHeadersValueItem>` - The first header value if exists.
682    #[inline(always)]
683    pub fn try_get_header_front<K>(&self, key: K) -> Option<RequestHeadersValueItem>
684    where
685        K: AsRef<str>,
686    {
687        self.headers
688            .get(key.as_ref())
689            .and_then(|values| values.front().cloned())
690    }
691
692    /// Retrieves the first value of a request header by its key.
693    ///
694    /// # Arguments
695    ///
696    /// - `AsRef<str>` - The header's key (must implement AsRef<str>).
697    ///
698    /// # Returns
699    ///
700    /// - `RequestHeadersValueItem` - The first header value if exists.
701    ///
702    /// # Panics
703    ///
704    /// This function will panic if the header key is not found.
705    #[inline(always)]
706    pub fn get_header_front<K>(&self, key: K) -> RequestHeadersValueItem
707    where
708        K: AsRef<str>,
709    {
710        self.try_get_header_front(key).unwrap()
711    }
712
713    /// Tries to retrieve the last value of a request header by its key.
714    ///
715    /// # Arguments
716    ///
717    /// - `AsRef<str>` - The header's key (must implement AsRef<str>).
718    ///
719    /// # Returns
720    ///
721    /// - `Option<RequestHeadersValueItem>` - The last header value if exists.
722    #[inline(always)]
723    pub fn try_get_header_back<K>(&self, key: K) -> Option<RequestHeadersValueItem>
724    where
725        K: AsRef<str>,
726    {
727        self.headers
728            .get(key.as_ref())
729            .and_then(|values| values.back().cloned())
730    }
731
732    /// Retrieves the last value of a request header by its key.
733    ///
734    /// # Arguments
735    ///
736    /// - `AsRef<str>` - The header's key (must implement AsRef<str>).
737    ///
738    /// # Returns
739    ///
740    /// - `RequestHeadersValueItem` - The last header value if exists.
741    ///
742    /// # Panics
743    ///
744    /// This function will panic if the header key is not found.
745    #[inline(always)]
746    pub fn get_header_back<K>(&self, key: K) -> RequestHeadersValueItem
747    where
748        K: AsRef<str>,
749    {
750        self.try_get_header_back(key).unwrap()
751    }
752
753    /// Tries to retrieve the number of values for a specific header.
754    ///
755    /// # Arguments
756    ///
757    /// - `AsRef<str>` - The header's key (must implement AsRef<str>).
758    ///
759    /// # Returns
760    ///
761    /// - `Option<usize>` - The count of values for the header if exists.
762    #[inline(always)]
763    pub fn try_get_header_length<K>(&self, key: K) -> Option<usize>
764    where
765        K: AsRef<str>,
766    {
767        self.headers.get(key.as_ref()).map(|values| values.len())
768    }
769
770    /// Retrieves the number of values for a specific header.
771    ///
772    /// # Arguments
773    ///
774    /// - `AsRef<str>` - The header's key (must implement AsRef<str>).
775    ///
776    /// # Returns
777    ///
778    /// - `usize` - The count of values for the header.
779    ///
780    /// # Panics
781    ///
782    /// This function will panic if the header key is not found.
783    #[inline(always)]
784    pub fn get_header_length<K>(&self, key: K) -> usize
785    where
786        K: AsRef<str>,
787    {
788        self.try_get_header_length(key).unwrap()
789    }
790
791    /// Retrieves the total number of header values across all headers.
792    ///
793    /// # Returns
794    ///
795    /// - `usize` - The total count of all header values.
796    #[inline(always)]
797    pub fn get_headers_values_length(&self) -> usize {
798        self.headers.values().map(|values| values.len()).sum()
799    }
800
801    /// Retrieves the number of unique headers.
802    ///
803    /// # Returns
804    ///
805    /// - `usize` - The count of unique header keys.
806    #[inline(always)]
807    pub fn get_headers_length(&self) -> usize {
808        self.headers.len()
809    }
810
811    /// Checks if a specific header exists.
812    ///
813    /// # Arguments
814    ///
815    /// - `AsRef<str>` - The header key to check (must implement AsRef<str>).
816    ///
817    /// # Returns
818    ///
819    /// - `bool` - Whether the header exists.
820    #[inline(always)]
821    pub fn has_header<K>(&self, key: K) -> bool
822    where
823        K: AsRef<str>,
824    {
825        self.headers.contains_key(key.as_ref())
826    }
827
828    /// Checks if a header contains a specific value.
829    ///
830    /// # Arguments
831    ///
832    /// - `AsRef<str>` - The header key to check (must implement AsRef<str>).
833    /// - `AsRef<str>` - The value to search for (must implement AsRef<str>).
834    ///
835    /// # Returns
836    ///
837    /// - `bool` - Whether the header contains the value.
838    #[inline(always)]
839    pub fn has_header_value<K, V>(&self, key: K, value: V) -> bool
840    where
841        K: AsRef<str>,
842        V: AsRef<str>,
843    {
844        if let Some(values) = self.headers.get(key.as_ref()) {
845            values.contains(&value.as_ref().to_owned())
846        } else {
847            false
848        }
849    }
850
851    /// Retrieves the body content of the request as a UTF-8 encoded string.
852    ///
853    /// This method uses `String::from_utf8_lossy` to convert the byte slice returned by `self.get_body()` as_ref a string.
854    /// If the byte slice contains invalid UTF-8 sequences, they will be replaced with the Unicode replacement character ().
855    ///
856    /// # Returns
857    ///
858    /// - `String` - The body content as a string.
859    #[inline(always)]
860    pub fn get_body_string(&self) -> String {
861        String::from_utf8_lossy(self.get_body()).into_owned()
862    }
863
864    /// Deserializes the body content of the request as_ref a specified type `T`.
865    ///
866    /// This method first retrieves the body content as a byte slice using `self.get_body()`.
867    /// It then attempts to deserialize the byte slice as_ref the specified type `T` using `json_from_slice`.
868    ///
869    /// # Arguments
870    ///
871    /// - `DeserializeOwned` - The target type to deserialize as_ref (must implement DeserializeOwned).
872    ///
873    /// # Returns
874    ///
875    /// - `Result<T, serde_json::Error>` - The deserialization result.
876    pub fn try_get_body_json<T>(&self) -> Result<T, serde_json::Error>
877    where
878        T: DeserializeOwned,
879    {
880        serde_json::from_slice(self.get_body())
881    }
882
883    /// Deserializes the body content of the request as_ref a specified type `T`.
884    ///
885    /// This method first retrieves the body content as a byte slice using `self.get_body()`.
886    /// It then attempts to deserialize the byte slice as_ref the specified type `T` using `json_from_slice`.
887    ///
888    /// # Arguments
889    ///
890    /// - `DeserializeOwned` - The target type to deserialize as_ref (must implement DeserializeOwned).
891    ///
892    /// # Returns
893    ///
894    /// - `T` - The deserialized body content.
895    ///
896    /// # Panics
897    ///
898    /// This function will panic if the deserialization fails.
899    pub fn get_body_json<T>(&self) -> T
900    where
901        T: DeserializeOwned,
902    {
903        self.try_get_body_json().unwrap()
904    }
905
906    /// Converts the request to a formatted string representation.
907    ///
908    /// This method provides a human-readable summary of the request, including its method,
909    /// host, version, path, query parameters, headers, and body information.
910    ///
911    /// # Returns
912    ///
913    /// - `String` - The formatted request details.
914    #[inline(always)]
915    pub fn get_string(&self) -> String {
916        let body: &Vec<u8> = self.get_body();
917        let body_type: &'static str = if std::str::from_utf8(body).is_ok() {
918            PLAIN
919        } else {
920            BINARY
921        };
922        format!(
923            "[Request] => [method]: {}; [host]: {}; [version]: {}; [path]: {}; [querys]: {:?}; [headers]: {:?}; [body]: {} bytes {};",
924            self.get_method(),
925            self.get_host(),
926            self.get_version(),
927            self.get_path(),
928            self.get_querys(),
929            self.get_headers(),
930            body.len(),
931            body_type
932        )
933    }
934
935    /// Retrieves the upgrade type from the request headers.
936    ///
937    /// This method looks for the `UPGRADE` header and attempts to parse its value
938    /// as_ref an `UpgradeType`. If the header is missing or the value is invalid,
939    /// it returns the default `UpgradeType`.
940    ///
941    /// # Returns
942    ///
943    /// - `UpgradeType` - The parsed upgrade type.
944    #[inline(always)]
945    pub fn get_upgrade_type(&self) -> UpgradeType {
946        let upgrade_type: UpgradeType = self
947            .try_get_header_back(UPGRADE)
948            .and_then(|data| data.parse::<UpgradeType>().ok())
949            .unwrap_or_default();
950        upgrade_type
951    }
952
953    /// Checks whether the WebSocket upgrade is enabled for this request.
954    ///
955    /// This method determines if the `UPGRADE` header indicates a WebSocket connection.
956    ///
957    /// # Returns
958    ///
959    /// - `bool` - Whether WebSocket upgrade is enabled.
960    #[inline(always)]
961    pub fn is_ws(&self) -> bool {
962        self.get_upgrade_type().is_ws()
963    }
964
965    /// Checks if the current upgrade type is HTTP/2 cleartext (h2c).
966    ///
967    /// # Returns
968    ///
969    /// - `bool` - Whether the upgrade type is h2c.
970    #[inline(always)]
971    pub fn is_h2c(&self) -> bool {
972        self.get_upgrade_type().is_h2c()
973    }
974
975    /// Checks if the current upgrade type is TLS (any version).
976    ///
977    /// # Returns
978    ///
979    /// - `bool` - Whether the upgrade type is TLS.
980    #[inline(always)]
981    pub fn is_tls(&self) -> bool {
982        self.get_upgrade_type().is_tls()
983    }
984
985    /// Checks whether the upgrade type is unknown.
986    ///
987    /// # Returns
988    ///
989    /// - `bool` - Whether the upgrade type is unknown.
990    #[inline(always)]
991    pub fn is_unknown_upgrade(&self) -> bool {
992        self.get_upgrade_type().is_unknown()
993    }
994
995    /// Checks if the HTTP version is HTTP/1.1 or higher.
996    ///
997    /// # Returns
998    ///
999    /// - `bool` - Whether the version is HTTP/1.1 or higher.
1000    #[inline(always)]
1001    pub fn is_http1_1_or_higher(&self) -> bool {
1002        self.get_version().is_http1_1_or_higher()
1003    }
1004
1005    /// Checks whether the HTTP version is HTTP/0.9.
1006    ///
1007    /// # Returns
1008    ///
1009    /// - `bool` - Whether the version is HTTP/0.9.
1010    #[inline(always)]
1011    pub fn is_http0_9(&self) -> bool {
1012        self.get_version().is_http0_9()
1013    }
1014
1015    /// Checks whether the HTTP version is HTTP/1.0.
1016    ///
1017    /// # Returns
1018    ///
1019    /// - `bool` - Whether the version is HTTP/1.0.
1020    #[inline(always)]
1021    pub fn is_http1_0(&self) -> bool {
1022        self.get_version().is_http1_0()
1023    }
1024
1025    /// Checks whether the HTTP version is HTTP/1.1.
1026    ///
1027    /// # Returns
1028    ///
1029    /// - `bool` - Whether the version is HTTP/1.1.
1030    #[inline(always)]
1031    pub fn is_http1_1(&self) -> bool {
1032        self.get_version().is_http1_1()
1033    }
1034
1035    /// Checks whether the HTTP version is HTTP/2.
1036    ///
1037    /// # Returns
1038    ///
1039    /// - `bool` - Whether the version is HTTP/2.
1040    #[inline(always)]
1041    pub fn is_http2(&self) -> bool {
1042        self.get_version().is_http2()
1043    }
1044
1045    /// Checks whether the HTTP version is HTTP/3.
1046    ///
1047    /// # Returns
1048    ///
1049    /// - `bool` - Whether the version is HTTP/3.
1050    #[inline(always)]
1051    pub fn is_http3(&self) -> bool {
1052        self.get_version().is_http3()
1053    }
1054
1055    /// Checks whether the HTTP version is unknown.
1056    ///
1057    /// # Returns
1058    ///
1059    /// - `bool` - Whether the version is unknown.
1060    #[inline(always)]
1061    pub fn is_unknown_version(&self) -> bool {
1062        self.get_version().is_unknown()
1063    }
1064
1065    /// Checks whether the version belongs to the HTTP family.
1066    ///
1067    /// # Returns
1068    ///
1069    /// - `bool` - Whether the version is HTTP.
1070    #[inline(always)]
1071    pub fn is_http(&self) -> bool {
1072        self.get_version().is_http()
1073    }
1074
1075    /// Checks whether the request method is GET.
1076    ///
1077    /// # Returns
1078    ///
1079    /// - `bool` - Whether the method is GET.
1080    #[inline(always)]
1081    pub fn is_get(&self) -> bool {
1082        self.get_method().is_get()
1083    }
1084
1085    /// Checks whether the request method is POST.
1086    ///
1087    /// # Returns
1088    ///
1089    /// - `bool` - Whether the method is POST.
1090    #[inline(always)]
1091    pub fn is_post(&self) -> bool {
1092        self.get_method().is_post()
1093    }
1094
1095    /// Checks whether the request method is PUT.
1096    ///
1097    /// # Returns
1098    ///
1099    /// - `bool` - Whether the method is PUT.
1100    #[inline(always)]
1101    pub fn is_put(&self) -> bool {
1102        self.get_method().is_put()
1103    }
1104
1105    /// Checks whether the request method is DELETE.
1106    ///
1107    /// # Returns
1108    ///
1109    /// - `bool` - Whether the method is DELETE.
1110    #[inline(always)]
1111    pub fn is_delete(&self) -> bool {
1112        self.get_method().is_delete()
1113    }
1114
1115    /// Checks whether the request method is PATCH.
1116    ///
1117    /// # Returns
1118    ///
1119    /// - `bool` - Whether the method is PATCH.
1120    #[inline(always)]
1121    pub fn is_patch(&self) -> bool {
1122        self.get_method().is_patch()
1123    }
1124
1125    /// Checks whether the request method is HEAD.
1126    ///
1127    /// # Returns
1128    ///
1129    /// - `bool` - Whether the method is HEAD.
1130    #[inline(always)]
1131    pub fn is_head(&self) -> bool {
1132        self.get_method().is_head()
1133    }
1134
1135    /// Checks whether the request method is OPTIONS.
1136    ///
1137    /// # Returns
1138    ///
1139    /// - `bool` - Whether the method is OPTIONS.
1140    #[inline(always)]
1141    pub fn is_options(&self) -> bool {
1142        self.get_method().is_options()
1143    }
1144
1145    /// Checks whether the request method is CONNECT.
1146    ///
1147    /// # Returns
1148    ///
1149    /// - `bool` - Whether the method is CONNECT.
1150    #[inline(always)]
1151    pub fn is_connect(&self) -> bool {
1152        self.get_method().is_connect()
1153    }
1154
1155    /// Checks whether the request method is TRACE.
1156    ///
1157    /// # Returns
1158    ///
1159    /// - `bool` - Whether the method is TRACE.
1160    #[inline(always)]
1161    pub fn is_trace(&self) -> bool {
1162        self.get_method().is_trace()
1163    }
1164
1165    /// Checks whether the request method is UNKNOWN.
1166    ///
1167    /// # Returns
1168    ///
1169    /// - `bool` - Whether the method is UNKNOWN.
1170    #[inline(always)]
1171    pub fn is_unknown_method(&self) -> bool {
1172        self.get_method().is_unknown()
1173    }
1174
1175    /// Determines if a keep-alive connection should be enabled for this request.
1176    ///
1177    /// This function checks the `Connection` header and the HTTP version to determine
1178    /// if keep-alive should be enabled. The logic is as follows:
1179    ///
1180    /// 1. If the `Connection` header exists:
1181    ///    - Returns `true` if the header value is "keep-alive" (case-insensitive).
1182    ///    - Returns `false` if the header value is "close" (case-insensitive).
1183    /// 2. If no `Connection` header is present:
1184    ///    - Returns `true` if the HTTP version is 1.1 or higher.
1185    ///    - Returns `false` otherwise.
1186    ///
1187    /// # Returns
1188    ///
1189    /// - `bool` - Whether keep-alive should be enabled.
1190    #[inline(always)]
1191    pub fn is_enable_keep_alive(&self) -> bool {
1192        if let Some(connection_value) = self.try_get_header_back(CONNECTION) {
1193            if connection_value.eq_ignore_ascii_case(KEEP_ALIVE) {
1194                return true;
1195            } else if connection_value.eq_ignore_ascii_case(CLOSE) {
1196                return self.is_ws();
1197            }
1198        }
1199        self.is_http1_1_or_higher() || self.is_ws()
1200    }
1201
1202    /// Determines if keep-alive should be disabled for this request.
1203    ///
1204    /// # Returns
1205    ///
1206    /// - `bool` - Whether keep-alive should be disabled.
1207    #[inline(always)]
1208    pub fn is_disable_keep_alive(&self) -> bool {
1209        !self.is_enable_keep_alive()
1210    }
1211}
http_type/request/impl.rs

http_type/request/
impl.rs
