use std::time::SystemTime;
use hyper::header::{self, HeaderMap};
#[derive(Debug, PartialEq, Eq)]
pub enum Resolved {
Full,
Partial {
start: u64,
end: u64,
},
Unsatisfiable,
}
pub fn resolve(
headers: &HeaderMap,
len: u64,
etag: &str,
modified: Option<SystemTime>,
) -> Resolved {
let Some(range) = headers.get(header::RANGE).and_then(|v| v.to_str().ok()) else {
return Resolved::Full;
};
if !if_range_matches(headers, etag, modified) {
return Resolved::Full;
}
parse(range, len)
}
pub fn if_range_matches(headers: &HeaderMap, etag: &str, modified: Option<SystemTime>) -> bool {
let Some(value) = headers.get(header::IF_RANGE).and_then(|v| v.to_str().ok()) else {
return true;
};
let value = value.trim();
if value.starts_with('"') || value.starts_with("W/") {
return value == etag;
}
match (httpdate::parse_http_date(value).ok(), modified) {
(Some(since), Some(modified)) => secs(modified) == secs(since),
_ => false,
}
}
fn secs(t: SystemTime) -> u64 {
t.duration_since(SystemTime::UNIX_EPOCH)
.map_or(0, |d| d.as_secs())
}
pub fn parse(value: &str, len: u64) -> Resolved {
let Some(spec) = value.trim().strip_prefix("bytes=") else {
return Resolved::Full;
};
let mut parts = spec.split(',');
let (Some(first), None) = (parts.next(), parts.next()) else {
return Resolved::Full;
};
let Some((start, end)) = first.trim().split_once('-') else {
return Resolved::Full;
};
let (start, end) = (start.trim(), end.trim());
if len == 0 {
return Resolved::Unsatisfiable;
}
let last = len - 1;
match (start.is_empty(), end.is_empty()) {
(true, false) => match end.parse::<u64>() {
Ok(0) => Resolved::Unsatisfiable,
Ok(suffix) => Resolved::Partial {
start: len.saturating_sub(suffix),
end: last,
},
Err(_) => Resolved::Full,
},
(false, true) => match start.parse::<u64>() {
Ok(start) if start <= last => Resolved::Partial { start, end: last },
Ok(_) => Resolved::Unsatisfiable,
Err(_) => Resolved::Full,
},
(false, false) => match (start.parse::<u64>(), end.parse::<u64>()) {
(Ok(start), Ok(end)) if start <= end && start <= last => Resolved::Partial {
start,
end: end.min(last),
},
(Ok(_), Ok(_)) => Resolved::Unsatisfiable,
_ => Resolved::Full,
},
(true, true) => Resolved::Full,
}
}
#[cfg(test)]
mod tests {
use super::*;
fn headers(pairs: &[(&'static str, &str)]) -> HeaderMap {
let mut map = HeaderMap::new();
for (name, value) in pairs {
map.insert(*name, value.parse().expect("header value"));
}
map
}
fn partial(start: u64, end: u64) -> Resolved {
Resolved::Partial { start, end }
}
#[test]
fn parses_the_three_range_forms() {
assert_eq!(parse("bytes=0-99", 1000), partial(0, 99));
assert_eq!(parse("bytes=500-", 1000), partial(500, 999));
assert_eq!(parse("bytes=-100", 1000), partial(900, 999));
assert_eq!(parse("bytes=990-2000", 1000), partial(990, 999));
assert_eq!(parse("bytes=-5000", 1000), partial(0, 999));
}
#[test]
fn rejects_only_what_cannot_be_satisfied() {
assert_eq!(parse("bytes=1000-", 1000), Resolved::Unsatisfiable);
assert_eq!(parse("bytes=99-1", 1000), Resolved::Unsatisfiable);
assert_eq!(parse("bytes=-0", 1000), Resolved::Unsatisfiable);
assert_eq!(parse("bytes=0-0", 0), Resolved::Unsatisfiable);
}
#[test]
fn extreme_numerals_never_produce_an_out_of_bounds_range() {
const MAX: &str = "18446744073709551615";
assert_eq!(
parse(&format!("bytes={MAX}-"), 1000),
Resolved::Unsatisfiable
);
assert_eq!(parse(&format!("bytes=0-{MAX}"), 1000), partial(0, 999));
assert_eq!(parse(&format!("bytes=-{MAX}"), 1000), partial(0, 999));
assert_eq!(parse("bytes=18446744073709551616-", 1000), Resolved::Full);
let len = u64::MAX;
assert_eq!(parse("bytes=0-99", len), partial(0, 99));
assert_eq!(
parse(&format!("bytes={}-", len - 1), len),
partial(len - 1, len - 1)
);
assert_eq!(parse("bytes=-1", len), partial(len - 1, len - 1));
}
#[test]
fn ignores_what_it_does_not_understand() {
assert_eq!(parse("items=0-99", 1000), Resolved::Full);
assert_eq!(parse("bytes=abc-def", 1000), Resolved::Full);
assert_eq!(parse("bytes=0-99, 200-299", 1000), Resolved::Full);
assert_eq!(parse("bytes=-", 1000), Resolved::Full);
}
#[test]
fn a_stale_if_range_falls_back_to_the_whole_file() {
let etag = "\"abc\"";
let fresh = headers(&[("range", "bytes=0-9"), ("if-range", etag)]);
assert_eq!(resolve(&fresh, 100, etag, None), partial(0, 9));
let stale = headers(&[("range", "bytes=0-9"), ("if-range", "\"old\"")]);
assert_eq!(resolve(&stale, 100, etag, None), Resolved::Full);
}
#[test]
fn an_if_range_date_must_match_exactly() {
let modified = SystemTime::UNIX_EPOCH + std::time::Duration::from_secs(1_700_000_000);
let same = httpdate::fmt_http_date(modified);
let older = httpdate::fmt_http_date(modified - std::time::Duration::from_secs(60));
let matching = headers(&[("range", "bytes=0-9"), ("if-range", &same)]);
assert_eq!(
resolve(&matching, 100, "\"e\"", Some(modified)),
partial(0, 9)
);
let mismatched = headers(&[("range", "bytes=0-9"), ("if-range", &older)]);
assert_eq!(
resolve(&mismatched, 100, "\"e\"", Some(modified)),
Resolved::Full
);
}
fn range_header() -> impl proptest::prelude::Strategy<Value = String> {
use proptest::prelude::*;
prop_oneof![
1 => "[ -~]{0,40}".boxed(),
4 => "[0-9 ,\\-]{0,30}".prop_map(|s| format!("bytes={s}")).boxed(),
4 => ("[0-9]{1,20}", "[0-9]{0,20}")
.prop_map(|(a, b)| format!("bytes={a}-{b}"))
.boxed(),
2 => "[0-9]{1,20}".prop_map(|n| format!("bytes=-{n}")).boxed(),
]
}
proptest::proptest! {
#[test]
fn prop_parse_is_total_and_accepted_ranges_are_in_bounds(
header in range_header(),
len in proptest::prop_oneof![
0u64..100_000,
(u64::MAX - 1_000)..=u64::MAX,
],
) {
match parse(&header, len) {
Resolved::Partial { start, end } => {
proptest::prop_assert!(start <= end, "inverted {start}..={end}");
proptest::prop_assert!(end < len, "{start}..={end} beyond {len}");
}
Resolved::Full | Resolved::Unsatisfiable => {}
}
}
#[test]
fn prop_valid_single_ranges_resolve_exactly(
start in 0u64..(u64::MAX / 4),
span in 0u64..(u64::MAX / 4),
slack in 1u64..(u64::MAX / 4),
) {
let end = start + span;
let len = end + slack; let header = format!("bytes={start}-{end}");
proptest::prop_assert_eq!(
parse(&header, len),
Resolved::Partial { start, end }
);
}
#[test]
fn prop_overlong_ends_clamp_to_the_last_byte(
len in 1u64..(u64::MAX / 2),
start_frac in 0.0f64..1.0,
excess in 0u64..(u64::MAX / 2),
) {
let start = (((len - 1) as f64 * start_frac) as u64).min(len - 1);
let end = (len - 1).saturating_add(excess).saturating_add(1);
let header = format!("bytes={start}-{end}");
proptest::prop_assert_eq!(
parse(&header, len),
Resolved::Partial { start, end: len - 1 }
);
}
#[test]
fn prop_suffix_ranges_serve_the_tail(
len in 1u64..u64::MAX,
suffix in 1u64..u64::MAX,
) {
proptest::prop_assert_eq!(
parse(&format!("bytes=-{suffix}"), len),
Resolved::Partial { start: len.saturating_sub(suffix), end: len - 1 }
);
}
}
}