Skip to content

A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.

TypeScript fluxerfluxerapp
5.2 KB
Raw Blame
// SPDX-License-Identifier: AGPL-3.0-or-later

use crate::range;
use axum::http::HeaderValue;

#[derive(Clone, Copy)]
pub(super) enum ExternalRangeSelection<'a> {
    Bounded { start: usize, end: usize },
    From { start: usize },
    Suffix { length: usize },
    Verbatim { spec: &'a str },
}

impl ExternalRangeSelection<'_> {
    pub(super) fn header_value(self) -> HeaderValue {
        let value = match self {
            Self::Bounded { start, end } => format!("bytes={start}-{end}"),
            Self::From { start } => format!("bytes={start}-"),
            Self::Suffix { length } => format!("bytes=-{length}"),
            Self::Verbatim { spec } => format!("bytes={spec}"),
        };
        HeaderValue::from_str(&value).expect("a parsed external byte range is a valid header")
    }

    fn matches(self, actual: range::ContentRange, actual_length: usize) -> bool {
        match (self, actual.size) {
            (Self::Verbatim { .. }, _) => true,
            (Self::Bounded { start, end }, Some(size)) => {
                start < size && actual.start == start && actual.end <= end.min(size - 1)
            }
            (Self::Bounded { start, end }, None) => actual.start == start && actual.end <= end,
            (Self::From { start }, Some(size)) => {
                start < size && actual.start == start && actual.end < size
            }
            (Self::From { start }, None) => actual.start == start,
            (Self::Suffix { length }, Some(size)) => {
                actual.start == size.saturating_sub(length) && actual.end == size - 1
            }
            (Self::Suffix { length }, None) => {
                actual_length == length || (actual.start == 0 && actual_length < length)
            }
        }
    }
}

#[derive(Clone)]
pub(super) enum ExternalPartial {
    Validated {
        content_range: range::ContentRange,
        content_length: u64,
    },
    Forwarded {
        content_range: Option<HeaderValue>,
    },
}

impl ExternalPartial {
    pub(super) fn content_length(&self) -> Option<u64> {
        match self {
            Self::Validated { content_length, .. } => Some(*content_length),
            Self::Forwarded { .. } => None,
        }
    }

    pub(super) fn header_value(&self) -> Option<HeaderValue> {
        match self {
            Self::Validated { content_range, .. } => {
                let value = match content_range.size {
                    Some(size) => {
                        format!("bytes {}-{}/{size}", content_range.start, content_range.end)
                    }
                    None => format!("bytes {}-{}/*", content_range.start, content_range.end),
                };
                Some(
                    HeaderValue::from_str(&value)
                        .expect("a validated external content range is a valid header"),
                )
            }
            Self::Forwarded { content_range } => content_range.clone(),
        }
    }
}

pub(super) fn parse_external_requested_range(header: &str) -> Option<ExternalRangeSelection<'_>> {
    let header = header.trim_matches([' ', '\t']);
    let (unit, spec) = header.split_once('=')?;
    if !unit.eq_ignore_ascii_case("bytes") {
        return None;
    }
    parse_external_range_spec(spec).or_else(|| forwardable_external_range_spec(spec))
}

fn parse_external_range_spec(spec: &str) -> Option<ExternalRangeSelection<'_>> {
    if spec.is_empty() || spec.contains(',') {
        return None;
    }
    let (start, end) = spec.split_once('-')?;
    match (
        range::parse_decimal_usize(start),
        range::parse_decimal_usize(end),
    ) {
        (Some(start), Some(end)) if end >= start => {
            Some(ExternalRangeSelection::Bounded { start, end })
        }
        (Some(start), None) if end.is_empty() => Some(ExternalRangeSelection::From { start }),
        (None, Some(length)) if start.is_empty() && length > 0 => {
            Some(ExternalRangeSelection::Suffix { length })
        }
        _ => None,
    }
}

fn forwardable_external_range_spec(spec: &str) -> Option<ExternalRangeSelection<'_>> {
    if spec.is_empty() || !spec.bytes().all(|byte| byte.is_ascii_graphic()) {
        return None;
    }
    Some(ExternalRangeSelection::Verbatim { spec })
}

pub(super) fn validate_external_partial(
    requested_range: Option<ExternalRangeSelection<'_>>,
    content_range: Option<&str>,
    content_length: Option<u64>,
    max_media_proxy_bytes: usize,
) -> Option<ExternalPartial> {
    let requested = requested_range?;
    if let ExternalRangeSelection::Verbatim { .. } = requested {
        return Some(ExternalPartial::Forwarded {
            content_range: content_range.and_then(|raw| HeaderValue::from_str(raw).ok()),
        });
    }
    let actual = range::parse_content_range(content_range)?;
    let actual_length = actual
        .end
        .checked_sub(actual.start)
        .and_then(|length| length.checked_add(1))?;
    if actual_length > max_media_proxy_bytes
        || content_length.is_some_and(|length| length != actual_length as u64)
        || !requested.matches(actual, actual_length)
    {
        return None;
    }
    Some(ExternalPartial::Validated {
        content_range: actual,
        content_length: u64::try_from(actual_length).ok()?,
    })
}