use std::fmt;
use std::str::FromStr;
use http::header::HeaderValue;
use thiserror::Error;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ByteRange {
Bounded(u64, u64),
From(u64),
Last(u64),
}
impl ByteRange {
pub fn to_header_value(&self) -> HeaderValue {
let s = match self {
ByteRange::Bounded(a, b) => format!("bytes={a}-{b}"),
ByteRange::From(n) => format!("bytes={n}-"),
ByteRange::Last(n) => format!("bytes=-{n}"),
};
HeaderValue::from_str(&s).expect("always a valid header value")
}
pub fn resolve(self, total: u64) -> Option<ContentRange> {
if total == 0 {
return None;
}
let (start, end) = match self {
ByteRange::Bounded(start, end) => {
if start >= total {
return None;
}
(start, end.min(total - 1)) }
ByteRange::From(start) => {
if start >= total {
return None;
}
(start, total - 1)
}
ByteRange::Last(negative_start) => {
let start = total.saturating_sub(negative_start);
(start, total - 1)
}
};
Some(ContentRange { start, end, total })
}
}
#[derive(Debug, Clone, PartialEq, Eq, Error)]
pub enum RangeError {
#[error("invalid byte range")]
Invalid,
#[error("expected single byte range, found multipart range")]
MultiRange,
#[error("invalid range unit: {0}, expected: bytes")]
InvalidUnit(String),
}
impl FromStr for ByteRange {
type Err = RangeError;
fn from_str(value: &str) -> Result<Self, Self::Err> {
let lower = value.to_ascii_lowercase();
let Some(spec) = lower.strip_prefix("bytes=") else {
let unit = lower.split_once('=').map_or(&*lower, |(u, _)| u);
return Err(RangeError::InvalidUnit(unit.to_owned()));
};
if spec.contains(',') {
return Err(RangeError::MultiRange);
}
let (start, end) = spec.split_once('-').ok_or(RangeError::Invalid)?;
if end.is_empty() {
let start: u64 = start.parse().map_err(|_| RangeError::Invalid)?;
Ok(ByteRange::From(start))
} else if start.is_empty() {
let last: u64 = end.parse().map_err(|_| RangeError::Invalid)?;
if last == 0 {
return Err(RangeError::Invalid);
}
Ok(ByteRange::Last(last))
} else {
let start: u64 = start.parse().map_err(|_| RangeError::Invalid)?;
let end: u64 = end.parse().map_err(|_| RangeError::Invalid)?;
if start > end {
return Err(RangeError::Invalid);
}
Ok(ByteRange::Bounded(start, end))
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct ContentRange {
pub start: u64,
pub end: u64,
pub total: u64,
}
impl FromStr for ContentRange {
type Err = RangeError;
fn from_str(s: &str) -> Result<Self, Self::Err> {
let parse = || {
let rest = s.strip_prefix("bytes ")?;
let (range_part, total_str) = rest.split_once('/')?;
let total: u64 = total_str.parse().ok()?;
let (start_str, end_str) = range_part.split_once('-')?;
let start: u64 = start_str.parse().ok()?;
let end: u64 = end_str.parse().ok()?;
if start > end || end >= total {
return None;
}
Some(Self { start, end, total })
};
parse().ok_or(RangeError::Invalid)
}
}
#[expect(
clippy::len_without_is_empty,
reason = "A valid ContentRange is never empty"
)]
impl ContentRange {
pub fn len(&self) -> u64 {
self.end - self.start + 1
}
pub fn to_header_value(&self) -> HeaderValue {
HeaderValue::from_str(&self.to_string()).expect("always a valid header value")
}
pub fn len_to_header_value(&self) -> HeaderValue {
HeaderValue::from(self.len())
}
pub fn parse_unsatisfiable_total(header: &str) -> Option<u64> {
let rest = header.strip_prefix("bytes */")?;
rest.parse().ok()
}
pub fn unsatisfiable_total_to_header_value(total: u64) -> HeaderValue {
HeaderValue::from_str(format!("bytes */{total}").as_str())
.expect("always a valid header value")
}
}
impl fmt::Display for ContentRange {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "bytes {}-{}/{}", self.start, self.end, self.total)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn parse_valid_ranges() {
assert_eq!(
"bytes=0-499".parse::<ByteRange>(),
Ok(ByteRange::Bounded(0, 499))
);
assert_eq!("bytes=500-".parse::<ByteRange>(), Ok(ByteRange::From(500)));
assert_eq!("bytes=-100".parse::<ByteRange>(), Ok(ByteRange::Last(100)));
assert_eq!(
"Bytes=0-499".parse::<ByteRange>(),
Ok(ByteRange::Bounded(0, 499))
);
assert_eq!("BYTES=100-".parse::<ByteRange>(), Ok(ByteRange::From(100)));
}
#[test]
fn parse_invalid_ranges() {
assert_eq!(
"bytes=0-10, 20-30".parse::<ByteRange>(),
Err(RangeError::MultiRange)
);
assert_eq!(
"items=0-10".parse::<ByteRange>(),
Err(RangeError::InvalidUnit("items".into()))
);
assert_eq!(
"bytes=500-100".parse::<ByteRange>(),
Err(RangeError::Invalid)
);
assert_eq!("bytes=-0".parse::<ByteRange>(), Err(RangeError::Invalid));
}
#[test]
fn resolve_satisfiable() {
let cr = |start, end, total| Some(ContentRange { start, end, total });
assert_eq!(ByteRange::Bounded(0, 499).resolve(1000), cr(0, 499, 1000));
assert_eq!(ByteRange::Bounded(0, 9999).resolve(500), cr(0, 499, 500));
assert_eq!(ByteRange::From(500).resolve(1000), cr(500, 999, 1000));
assert_eq!(ByteRange::Last(100).resolve(1000), cr(900, 999, 1000));
assert_eq!(ByteRange::Last(2000).resolve(1000), cr(0, 999, 1000));
}
#[test]
fn resolve_unsatisfiable() {
assert_eq!(ByteRange::Bounded(1000, 2000).resolve(500), None);
assert_eq!(ByteRange::From(500).resolve(500), None);
assert_eq!(ByteRange::Bounded(0, 0).resolve(0), None);
}
#[test]
fn content_range_len() {
let full = ContentRange {
start: 0,
end: 999,
total: 1000,
};
assert_eq!(full.len(), 1000);
let partial = ContentRange {
start: 0,
end: 499,
total: 1000,
};
assert_eq!(partial.len(), 500);
}
#[test]
fn parse_unsatisfiable_total() {
assert_eq!(
ContentRange::parse_unsatisfiable_total("bytes */1234"),
Some(1234)
);
assert_eq!(
ContentRange::parse_unsatisfiable_total("bytes 0-499/1234"),
None
);
assert_eq!(ContentRange::parse_unsatisfiable_total("invalid"), None);
}
#[test]
fn header_value_roundtrips() {
assert_eq!(ByteRange::Bounded(0, 499).to_header_value(), "bytes=0-499");
assert_eq!(ByteRange::From(500).to_header_value(), "bytes=500-");
assert_eq!(ByteRange::Last(100).to_header_value(), "bytes=-100");
let cr = ContentRange {
start: 0,
end: 499,
total: 1234,
};
assert_eq!(cr.to_header_value(), "bytes 0-499/1234");
assert_eq!("bytes 0-499/1234".parse::<ContentRange>(), Ok(cr));
assert!("bytes */1234".parse::<ContentRange>().is_err());
assert!("invalid".parse::<ContentRange>().is_err());
assert!("bytes 499-0/1234".parse::<ContentRange>().is_err());
assert!("bytes 0-1234/1234".parse::<ContentRange>().is_err());
assert_eq!(
ContentRange::unsatisfiable_total_to_header_value(1234),
"bytes */1234"
);
}
}