salvo_core 0.95.2

use crate::http::ParseError;

/// A normalized, satisfiable byte range from an HTTP `Range` header.
///
/// The range covers `start..start + length`: `start` is zero-based and
/// `length` is the number of bytes in the range. Open-ended and suffix ranges
/// are resolved against the representation size by [`HttpRange::parse`].
#[derive(Clone, Debug, Copy)]
#[non_exhaustive]
pub struct HttpRange {
    /// Zero-based offset of the first byte in the range.
    pub start: u64,
    /// Number of bytes in the range.
    pub length: u64,
}

static PREFIX: &str = "bytes=";

impl HttpRange {
    /// Parses and normalizes the value of an HTTP byte `Range` header.
    ///
    /// `header` must use the `bytes` range unit, for example `bytes=0-9`.
    /// `size` is the complete representation length. Values above
    /// [`i64::MAX`] are treated as `i64::MAX`. Explicit end positions beyond
    /// the effective size are clamped, and suffix ranges are converted to
    /// absolute offsets.
    ///
    /// An empty header, or one containing only empty comma-separated members,
    /// produces an empty vector. A malformed non-empty range, or a header whose
    /// non-empty ranges do not overlap the representation, returns
    /// [`ParseError::InvalidRange`]. If at least one range is satisfiable, other
    /// non-overlapping ranges are ignored.
    ///
    /// # Example
    ///
    /// ```
    /// use salvo_core::http::HttpRange;
    ///
    /// let ranges = HttpRange::parse("bytes=2-5,-2", 10)?;
    /// assert_eq!(ranges[0].start, 2);
    /// assert_eq!(ranges[0].length, 4);
    /// assert_eq!(ranges[1].start, 8);
    /// assert_eq!(ranges[1].length, 2);
    /// # Ok::<(), salvo_core::http::ParseError>(())
    /// ```
    pub fn parse(header: &str, size: u64) -> Result<Vec<Self>, ParseError> {
        if header.is_empty() {
            return Ok(Vec::new());
        }
        let Some(ranges_header) = header.strip_prefix(PREFIX) else {
            return Err(ParseError::InvalidRange);
        };

        // Clamp to `i64::MAX`: the signed arithmetic below would otherwise wrap a
        // `size` above `i64::MAX` into a negative value and corrupt every bound.
        // Files larger than 8 EiB are not addressable here and do not occur in
        // practice.
        let size_sig = size.min(i64::MAX as u64) as i64;
        let mut no_overlap = false;

        let all_ranges: Vec<Option<Self>> = ranges_header
            .split(',')
            .map(|x| x.trim())
            .filter(|x| !x.is_empty())
            .map(|ra| {
                let mut start_end_iter = ra.split('-');

                let start_str = start_end_iter.next().ok_or(())?.trim();
                let end_str = start_end_iter.next().ok_or(())?.trim();
                if start_end_iter.next().is_some() {
                    return Err(());
                }

                if start_str.is_empty() {
                    // If no start is specified, end specifies the
                    // range start relative to the end of the file.
                    let mut length: i64 = end_str.parse().map_err(|_| ())?;

                    // A suffix length of zero (e.g. `bytes=-0`) selects no bytes
                    // and is unsatisfiable per RFC 7233; treat it like a range
                    // that does not overlap the representation.
                    if length <= 0 {
                        no_overlap = true;
                        return Ok(None);
                    }

                    if size_sig == 0 {
                        no_overlap = true;
                        return Ok(None);
                    }

                    if length > size_sig {
                        length = size_sig;
                    }

                    Ok(Some(Self {
                        start: (size_sig - length) as u64,
                        length: length as u64,
                    }))
                } else {
                    let start: i64 = start_str.parse().map_err(|_| ())?;

                    if start < 0 {
                        return Err(());
                    }
                    if start >= size_sig {
                        no_overlap = true;
                        return Ok(None);
                    }

                    let length = if end_str.is_empty() {
                        // If no end is specified, range extends to end of the file.
                        size_sig - start
                    } else {
                        let mut end: i64 = end_str.parse().map_err(|_| ())?;

                        if start > end {
                            return Err(());
                        }

                        if end >= size_sig {
                            end = size_sig - 1;
                        }

                        end - start + 1
                    };

                    Ok(Some(Self {
                        start: start as u64,
                        length: length as u64,
                    }))
                }
            })
            .collect::<Result<_, _>>()
            .map_err(|_| ParseError::InvalidRange)?;

        let ranges: Vec<Self> = all_ranges.into_iter().flatten().collect();

        if no_overlap && ranges.is_empty() {
            return Err(ParseError::InvalidRange);
        }

        Ok(ranges)
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    struct T(&'static str, u64, Vec<HttpRange>);

    #[test]
    fn test_parse() {
        let tests = vec![
            T("", 0, vec![]),
            T("", 1000, vec![]),
            T("foo", 0, vec![]),
            T("bytes=", 0, vec![]),
            T("bytes=7", 10, vec![]),
            T("bytes= 7 ", 10, vec![]),
            T("bytes=1-", 0, vec![]),
            T("bytes=-0", 10, vec![]),
            T("bytes=5-4", 10, vec![]),
            T("bytes=0-2,5-4", 10, vec![]),
            T("bytes=2-5,4-3", 10, vec![]),
            T("bytes=--5,4--3", 10, vec![]),
            T("bytes=A-", 10, vec![]),
            T("bytes=A- ", 10, vec![]),
            T("bytes=A-Z", 10, vec![]),
            T("bytes= -Z", 10, vec![]),
            T("bytes=5-Z", 10, vec![]),
            T("bytes=Ran-dom, garbage", 10, vec![]),
            T("bytes=0x01-0x02", 10, vec![]),
            T("bytes=         ", 10, vec![]),
            T("bytes= , , ,   ", 10, vec![]),
            T(
                "bytes=0-9",
                10,
                vec![HttpRange {
                    start: 0,
                    length: 10,
                }],
            ),
            T(
                "bytes=0-",
                10,
                vec![HttpRange {
                    start: 0,
                    length: 10,
                }],
            ),
            T(
                "bytes=5-",
                10,
                vec![HttpRange {
                    start: 5,
                    length: 5,
                }],
            ),
            T(
                "bytes=0-20",
                10,
                vec![HttpRange {
                    start: 0,
                    length: 10,
                }],
            ),
            T(
                "bytes=15-,0-5",
                10,
                vec![HttpRange {
                    start: 0,
                    length: 6,
                }],
            ),
            T(
                "bytes=1-2,5-",
                10,
                vec![
                    HttpRange {
                        start: 1,
                        length: 2,
                    },
                    HttpRange {
                        start: 5,
                        length: 5,
                    },
                ],
            ),
            T(
                "bytes=-2 , 7-",
                11,
                vec![
                    HttpRange {
                        start: 9,
                        length: 2,
                    },
                    HttpRange {
                        start: 7,
                        length: 4,
                    },
                ],
            ),
            T(
                "bytes=0-0 ,2-2, 7-",
                11,
                vec![
                    HttpRange {
                        start: 0,
                        length: 1,
                    },
                    HttpRange {
                        start: 2,
                        length: 1,
                    },
                    HttpRange {
                        start: 7,
                        length: 4,
                    },
                ],
            ),
            T(
                "bytes=-5",
                10,
                vec![HttpRange {
                    start: 5,
                    length: 5,
                }],
            ),
            T(
                "bytes=-15",
                10,
                vec![HttpRange {
                    start: 0,
                    length: 10,
                }],
            ),
            T(
                "bytes=0-499",
                10000,
                vec![HttpRange {
                    start: 0,
                    length: 500,
                }],
            ),
            T(
                "bytes=500-999",
                10000,
                vec![HttpRange {
                    start: 500,
                    length: 500,
                }],
            ),
            T(
                "bytes=-500",
                10000,
                vec![HttpRange {
                    start: 9500,
                    length: 500,
                }],
            ),
            T(
                "bytes=9500-",
                10000,
                vec![HttpRange {
                    start: 9500,
                    length: 500,
                }],
            ),
            T(
                "bytes=0-0,-1",
                10000,
                vec![
                    HttpRange {
                        start: 0,
                        length: 1,
                    },
                    HttpRange {
                        start: 9999,
                        length: 1,
                    },
                ],
            ),
            T(
                "bytes=500-600,601-999",
                10000,
                vec![
                    HttpRange {
                        start: 500,
                        length: 101,
                    },
                    HttpRange {
                        start: 601,
                        length: 399,
                    },
                ],
            ),
            T(
                "bytes=500-700,601-999",
                10000,
                vec![
                    HttpRange {
                        start: 500,
                        length: 201,
                    },
                    HttpRange {
                        start: 601,
                        length: 399,
                    },
                ],
            ),
            // Match Apache laxity:
            T(
                "bytes=   1 -2   ,  4- 5, 7 - 8 , ,,",
                11,
                vec![
                    HttpRange {
                        start: 1,
                        length: 2,
                    },
                    HttpRange {
                        start: 4,
                        length: 2,
                    },
                    HttpRange {
                        start: 7,
                        length: 2,
                    },
                ],
            ),
        ];

        for t in tests {
            let header = t.0;
            let size = t.1;
            let expected = t.2;

            let res = HttpRange::parse(header, size);

            let got = match res {
                Err(e) => {
                    if expected.is_empty() {
                        continue;
                    } else {
                        panic!("parse({header}, {size}) returned error {e:?}");
                    }
                }
                Ok(v) => v,
            };

            if got.len() != expected.len() {
                panic!(
                    "len(parseRange({}, {})) = {}, want {}",
                    header,
                    size,
                    got.len(),
                    expected.len()
                );
            }

            for i in 0..expected.len() {
                if got[i].start != expected[i].start {
                    panic!(
                        "parseRange({}, {})[{}].start = {}, want {}",
                        header, size, i, got[i].start, expected[i].start
                    )
                }
                if got[i].length != expected[i].length {
                    panic!(
                        "parseRange({}, {})[{}].length = {}, want {}",
                        header, size, i, got[i].length, expected[i].length
                    )
                }
            }
        }
    }

    #[test]
    fn parse_rejects_ranges_with_extra_hyphens() {
        for header in ["bytes=0-1-2", "bytes=0--1", "bytes=--1"] {
            assert!(
                matches!(HttpRange::parse(header, 10), Err(ParseError::InvalidRange)),
                "{header} should be rejected as malformed"
            );
        }
    }

    #[test]
    fn parse_rejects_suffix_range_for_empty_representation() {
        assert!(matches!(
            HttpRange::parse("bytes=-1", 0),
            Err(ParseError::InvalidRange)
        ));
    }
}