use super::*;
#[cold]
pub(crate) fn h1_error_response_version(
stream: &Stream,
error: &RequestError,
) -> Option<HttpVersion> {
let line: &str = stream.get_line_buffer();
if line.is_empty()
&& matches!(
error,
RequestError::HttpRequestPartsInsufficient(_) | RequestError::ReadTimeout(_)
)
{
return None;
}
if line.split_ascii_whitespace().nth(2) == Some(HTTP_VERSION_1_0) {
Some(HttpVersion::Http1_0)
} else {
Some(HttpVersion::Http1_1)
}
}
#[cold]
pub(crate) async fn reply_to_request_error(
server: &Server,
stream: &mut Stream,
ctx: &mut Context,
error: &RequestError,
version: Option<HttpVersion>,
) {
if !server.get_request_error().is_empty() {
server.handle_request_error(stream, ctx, error).await;
return;
}
let Some(version) = version else { return };
if matches!(
error,
RequestError::ClientDisconnected(_)
| RequestError::ClientClosedConnection(_)
| RequestError::ServerClosedConnection(_)
) {
return;
}
let h1: bool = version.is_http1_0() || version.is_http1_1();
let mut response: Response = Response::default();
response
.set_version(version)
.set_status_code(error.get_http_status_code());
if h1 {
response.set_header(CONNECTION, CLOSE);
}
let data: ResponseData = response.build();
if stream.try_send(data).await.is_ok() && h1 {
let _: Result<(), ResponseError> = stream.try_flush().await;
}
}
#[cold]
pub(crate) fn continue_response() -> ProtocolResponse<()> {
let mut response: ProtocolResponse<()> = ProtocolResponse::new(());
*response.status_mut() = StatusCode::CONTINUE;
response
}
pub fn find_head_end(buffer: &[u8]) -> Option<usize> {
let mut index: usize = 0;
while index < buffer.len() {
let rest: &[u8] = &buffer[index..];
let line_len: usize = find_line_end(rest)?;
let is_blank: bool = rest[..line_len]
.iter()
.all(|byte: &u8| *byte == CR_U8 || *byte == LF_U8);
if is_blank {
return Some(index + line_len);
}
index += line_len;
}
None
}
pub fn find_line_end(bytes: &[u8]) -> Option<usize> {
bytes
.iter()
.position(|byte: &u8| *byte == LF_U8)
.map(|index: usize| index + 1)
}
pub(crate) fn parse_protocol_response_head(
head: &[u8],
is_head: bool,
) -> Result<ParsedProtocolHead, ResponseError> {
let text: &str =
from_utf8(head).map_err(|error: Utf8Error| ResponseError::Send(error.to_string()))?;
let mut lines: SplitLines<'_> = text.split(CRLF);
let status_line: &str = lines.next().unwrap_or(EMPTY_STR);
let mut fields: SplitWhitespace<'_> = status_line.split_whitespace();
let version: &str = fields.next().unwrap_or(EMPTY_STR);
if !version.starts_with(HTTP_VERSION_PREFIX) {
return Err(ResponseError::Send(MISSING_RESPONSE_VERSION.to_owned()));
}
let status_text: &str = fields.next().unwrap_or(EMPTY_STR);
if status_text.is_empty() {
return Err(ResponseError::Send(MISSING_RESPONSE_STATUS.to_owned()));
}
let status_code: usize = status_text
.parse::<usize>()
.map_err(|error: ParseIntError| ResponseError::Send(error.to_string()))?;
validate_status_code(status_code)?;
let status: StatusCode = StatusCode::from_u16(status_code as u16)
.map_err(|error: InvalidStatusCode| ResponseError::Send(error.to_string()))?;
let mut response: ProtocolResponse<()> = ProtocolResponse::new(());
*response.status_mut() = status;
let headers: &mut ProtocolHeaders = response.headers_mut();
let suppress_body: bool = is_bodyless_status(status_code, is_head);
let hide_length: bool = hides_entity_length(status_code, is_head);
let mut announced_len: Option<usize> = None;
let mut nominated: Option<Vec<&str>> = None;
for line in lines {
let line: &str = line.trim_end_matches(LF_CHAR);
if line.is_empty() {
continue;
}
let Some((name, value)) = line.split_once(COLON) else {
return Err(ResponseError::Send(MALFORMED_RESPONSE_HEADER.to_owned()));
};
let name: &str = name.trim();
if name.is_empty() {
return Err(ResponseError::Send(MALFORMED_RESPONSE_HEADER.to_owned()));
}
let trimmed_value: &str = value.trim();
if name.eq_ignore_ascii_case(CONNECTION) {
if HeaderValue::from_bytes(trimmed_value.as_bytes()).is_err() {
return Err(ResponseError::Send(MALFORMED_RESPONSE_HEADER.to_owned()));
}
for token in trimmed_value.split(COMMA_STR) {
let token: &str = token.trim();
if !token.is_empty()
&& !token.eq_ignore_ascii_case(KEEP_ALIVE)
&& !token.eq_ignore_ascii_case(CLOSE)
{
nominated.get_or_insert_with(Vec::new).push(token);
}
}
continue;
}
if name.eq_ignore_ascii_case(TRANSFER_ENCODING) {
return Err(ResponseError::Send(
UNSUPPORTED_TRANSFER_ENCODING.to_owned(),
));
}
if name.eq_ignore_ascii_case(CONTENT_TYPE) {
let header_value: HeaderValue = match trimmed_value {
STATIC_CT_HTML_UTF8 => HeaderValue::from_static(STATIC_CT_HTML_UTF8),
STATIC_CT_PLAIN => HeaderValue::from_static(STATIC_CT_PLAIN),
STATIC_CT_PLAIN_UTF8 => HeaderValue::from_static(STATIC_CT_PLAIN_UTF8),
STATIC_CT_JSON => HeaderValue::from_static(STATIC_CT_JSON),
_ => match HeaderValue::from_bytes(trimmed_value.as_bytes()) {
Ok(v) => v,
Err(_) => {
return Err(ResponseError::Send(MALFORMED_RESPONSE_HEADER.to_owned()));
}
},
};
headers.append(HeaderName::from_static(CONTENT_TYPE), header_value);
continue;
}
if name.eq_ignore_ascii_case(CONTENT_LENGTH) {
let length: usize = parse_ascii_length(trimmed_value)
.map_err(|error: RequestError| ResponseError::Send(error.to_string()))?;
match announced_len {
Some(previous) if previous != length => {
return Err(ResponseError::Send(OVERFLOWING_RESPONSE_BODY.to_owned()));
}
_ => announced_len = Some(length),
}
if hide_length {
continue;
}
let Ok(header_value) = HeaderValue::from_bytes(trimmed_value.as_bytes()) else {
return Err(ResponseError::Send(MALFORMED_RESPONSE_HEADER.to_owned()));
};
headers.append(HeaderName::from_static(CONTENT_LENGTH), header_value);
continue;
}
let Ok(header_name) = HeaderName::from_bytes(name.as_bytes()) else {
return Err(ResponseError::Send(MALFORMED_RESPONSE_HEADER.to_owned()));
};
let Ok(header_value) = HeaderValue::from_bytes(trimmed_value.as_bytes()) else {
return Err(ResponseError::Send(MALFORMED_RESPONSE_HEADER.to_owned()));
};
let key: &str = header_name.as_str();
if key.starts_with(PSEUDO_HEADER_PREFIX) || is_hop_by_hop(key) {
continue;
}
headers.append(header_name, header_value);
}
if let Some(tokens) = nominated {
for token in tokens {
if let Ok(name) = HeaderName::from_bytes(token.as_bytes()) {
headers.remove(name);
}
}
}
Ok(ParsedProtocolHead {
response,
announced_len,
suppress_body,
})
}
#[cfg(test)]
pub fn parse_response_head(head: &[u8]) -> Result<(usize, ProtocolHeaders), ResponseError> {
let text: &str =
from_utf8(head).map_err(|error: Utf8Error| ResponseError::Send(error.to_string()))?;
let mut lines: SplitLines<'_> = text.split(CRLF);
let status_line: &str = lines.next().unwrap_or(EMPTY_STR);
let mut fields: SplitWhitespace<'_> = status_line.split_whitespace();
let version: &str = fields.next().unwrap_or(EMPTY_STR);
if !version.starts_with(HTTP_VERSION_PREFIX) {
return Err(ResponseError::Send(MISSING_RESPONSE_VERSION.to_owned()));
}
let status_text: &str = fields.next().unwrap_or(EMPTY_STR);
if status_text.is_empty() {
return Err(ResponseError::Send(MISSING_RESPONSE_STATUS.to_owned()));
}
let status_code: usize = status_text
.parse::<usize>()
.map_err(|error: ParseIntError| ResponseError::Send(error.to_string()))?;
let mut headers: ProtocolHeaders = HeaderMap::new();
for line in lines {
let line: &str = line.trim_end_matches(LF_CHAR);
if line.is_empty() {
continue;
}
let Some((name, value)) = line.split_once(COLON) else {
return Err(ResponseError::Send(MALFORMED_RESPONSE_HEADER.to_owned()));
};
let name: &str = name.trim();
if name.is_empty() {
return Err(ResponseError::Send(MALFORMED_RESPONSE_HEADER.to_owned()));
}
let Ok(header_name) = HeaderName::from_bytes(name.as_bytes()) else {
return Err(ResponseError::Send(MALFORMED_RESPONSE_HEADER.to_owned()));
};
let Ok(header_value) = HeaderValue::from_bytes(value.trim().as_bytes()) else {
return Err(ResponseError::Send(MALFORMED_RESPONSE_HEADER.to_owned()));
};
headers.append(header_name, header_value);
}
Ok((status_code, headers))
}
#[cfg(test)]
pub fn has_transfer_encoding(headers: &ProtocolHeaders) -> bool {
headers.contains_key(TRANSFER_ENCODING)
}
#[cfg(test)]
pub fn parse_content_length(headers: &ProtocolHeaders) -> Result<Option<usize>, ResponseError> {
let mut announced: Option<usize> = None;
for value in headers.get_all(CONTENT_LENGTH).iter() {
let Ok(value) = value.to_str() else {
return Err(ResponseError::Send(MALFORMED_RESPONSE_HEADER.to_owned()));
};
let length: usize = parse_ascii_length(value)
.map_err(|error: RequestError| ResponseError::Send(error.to_string()))?;
match announced {
Some(previous) if previous != length => {
return Err(ResponseError::Send(OVERFLOWING_RESPONSE_BODY.to_owned()));
}
_ => announced = Some(length),
}
}
Ok(announced)
}
#[cfg(test)]
pub fn connection_nominates(headers: &ProtocolHeaders, name: &str) -> bool {
if name.eq_ignore_ascii_case(CONNECTION) {
return true;
}
for value in headers.get_all(CONNECTION).iter() {
let Ok(value) = value.to_str() else {
continue;
};
for token in value.split(COMMA_STR) {
if token.trim().eq_ignore_ascii_case(name) {
return true;
}
}
}
false
}