use crate::http::header_processor::HttpResponseHead;
pub fn validate_response_range(
req_start: u64,
req_end: u64,
resp_start: u64,
resp_end: u64,
) -> std::result::Result<(), String> {
if req_start != resp_start {
return Err(format!(
"Range start mismatch: requested={}, server={}",
req_start, resp_start
));
}
if req_end == 0 {
return Ok(());
}
if resp_end != req_end {
return Err(format!(
"Range end mismatch: requested={}, server={}",
req_end, resp_end
));
}
Ok(())
}
pub(crate) fn parse_content_range(response_head: &HttpResponseHead) -> Option<(u64, u64, u64)> {
let value = response_head.header("content-range")?;
parse_content_range_value(value)
}
pub(crate) fn parse_content_range_value(value: &str) -> Option<(u64, u64, u64)> {
let value = value.trim();
let range = value
.strip_prefix("bytes")
.map(|rest| rest.trim_start_matches([' ', '\t', '=']))
.unwrap_or(value);
let (range, total) = range.split_once('/')?;
if range.trim() == "*" || total.trim() == "*" {
return None;
}
let (start, end) = range.trim().split_once('-')?;
let start = start.trim().parse().ok()?;
let end = end.trim().parse().ok()?;
let total = total.trim().parse().ok()?;
Some((start, end, total))
}
pub(crate) fn compute_entity_length(response_head: &HttpResponseHead) -> u64 {
if let Some(range) = parse_content_range(response_head) {
return range.2;
}
response_head.content_length().unwrap_or(0)
}
pub(crate) fn is_chunked_transfer_encoding(response_head: &HttpResponseHead) -> bool {
match response_head.header("transfer-encoding") {
Some(te) => te.to_lowercase().contains("chunked"),
None => false,
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::http::header_processor::HttpHeaderProcessor;
fn parse_head(raw: &[u8]) -> HttpResponseHead {
let mut proc = HttpHeaderProcessor::new();
proc.feed(raw);
proc.get_result().unwrap()
}
#[test]
fn test_parse_content_range() {
assert_eq!(
parse_content_range_value("bytes 0-499/1000"),
Some((0, 499, 1000))
);
assert_eq!(
parse_content_range_value("bytes 500-999/1000"),
Some((500, 999, 1000))
);
assert_eq!(parse_content_range_value("bytes */1000"), None);
assert_eq!(
parse_content_range_value("bytes=0-499/1000"),
Some((0, 499, 1000))
);
assert_eq!(
parse_content_range_value("0-499/1000"),
Some((0, 499, 1000))
);
assert_eq!(parse_content_range_value("bytes 0-0/1"), Some((0, 0, 1)));
}
#[test]
fn test_parse_content_range_invalid() {
assert_eq!(parse_content_range_value("not-bytes 0-499/1000"), None);
assert_eq!(parse_content_range_value("bytes invalid"), None);
assert_eq!(parse_content_range_value(""), None);
}
#[test]
fn test_validate_response_range_match() {
assert!(validate_response_range(0, 499, 0, 499).is_ok());
assert!(validate_response_range(500, 999, 500, 999).is_ok());
assert!(validate_response_range(0, 499, 0, 999).is_err());
assert!(validate_response_range(0, 499, 0, 499).is_ok());
assert!(validate_response_range(0, 0, 0, 999).is_ok());
}
#[test]
fn test_validate_response_range_start_mismatch() {
let result = validate_response_range(0, 499, 100, 499);
assert!(result.is_err());
assert!(result.unwrap_err().contains("start mismatch"));
}
#[test]
fn test_validate_response_range_end_mismatch() {
let result = validate_response_range(0, 999, 0, 499);
assert_eq!(
result.unwrap_err(),
"Range end mismatch: requested=999, server=499"
);
}
#[test]
fn test_validate_response_range_no_end_requested() {
assert!(validate_response_range(100, 0, 100, 200).is_ok());
assert!(validate_response_range(100, 0, 100, 0).is_ok());
}
#[test]
fn test_chunked_transfer_encoding() {
let head = parse_head(b"HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\n\r\n");
assert!(is_chunked_transfer_encoding(&head));
let head = parse_head(b"HTTP/1.1 200 OK\r\nContent-Length: 100\r\n\r\n");
assert!(!is_chunked_transfer_encoding(&head));
}
#[test]
fn test_entity_length_from_content_range() {
let head = parse_head(
b"HTTP/1.1 206 Partial Content\r\nContent-Range: bytes 0-99/5000\r\nContent-Length: 100\r\n\r\n",
);
assert_eq!(compute_entity_length(&head), 5000);
}
#[test]
fn test_entity_length_from_content_length() {
let head = parse_head(b"HTTP/1.1 200 OK\r\nContent-Length: 2048\r\n\r\n");
assert_eq!(compute_entity_length(&head), 2048);
}
#[test]
fn test_entity_length_unknown() {
let head = parse_head(b"HTTP/1.1 200 OK\r\n\r\n");
assert_eq!(compute_entity_length(&head), 0);
}
}