s3-endpoint 0.1.1

S3-compatible endpoint for upload and object-access workflows.
Documentation
pub mod delete_object;
pub mod get_object;
pub mod head_bucket;
pub mod head_object;
pub mod health;
pub mod multipart;
pub mod put_object;
pub mod request;
pub mod s3;
pub mod upload_metadata;

use axum::http::{HeaderMap, header};

use crate::{body::upload::is_aws_chunked_request, error::S3Error, s3::types::ContentLength};

/// Validates request body framing for operations that require upload bytes.
///
/// Plain uploads must provide `Content-Length`; aws-chunked uploads may combine
/// `Transfer-Encoding: chunked` with aws-chunked content encoding.
pub(crate) fn validate_supported_request_body_length(headers: &HeaderMap) -> Result<(), S3Error> {
    let content_length = validate_content_length(headers)?;
    let transfer_encoding = validate_transfer_encoding(headers)?;

    if transfer_encoding.has_chunked {
        if content_length.is_some() && !is_aws_chunked_request(headers) {
            return Err(S3Error::invalid_request(
                "Content-Length must not be used with Transfer-Encoding for non aws-chunked uploads",
            ));
        }
        return Ok(());
    }

    if content_length.is_some() {
        Ok(())
    } else {
        Err(S3Error::missing_content_length())
    }
}

/// Validates that an operation expecting no body has no transfer encoding and no nonzero length.
pub(crate) fn validate_empty_request_body_headers(
    headers: &HeaderMap,
    operation: &str,
) -> Result<(), S3Error> {
    let content_length = validate_content_length(headers)?;
    let transfer_encoding = validate_transfer_encoding(headers)?;

    if transfer_encoding.has_any {
        return Err(S3Error::invalid_request(format!(
            "{operation} does not support Transfer-Encoding"
        )));
    }
    if content_length.is_some_and(|content_length| content_length.get() != 0) {
        return Err(S3Error::invalid_request(format!(
            "{operation} requires Content-Length: 0"
        )));
    }
    Ok(())
}

fn validate_content_length(headers: &HeaderMap) -> Result<Option<ContentLength>, S3Error> {
    let values = headers
        .get_all(header::CONTENT_LENGTH)
        .iter()
        .collect::<Vec<_>>();
    if values.len() > 1 {
        return Err(S3Error::invalid_request(
            "Content-Length must not appear more than once",
        ));
    }
    let Some(content_length) = values.first() else {
        return Ok(None);
    };
    let content_length = content_length
        .to_str()
        .map_err(|_| S3Error::invalid_request("Content-Length must be valid ASCII"))?;
    content_length
        .parse::<ContentLength>()
        .map(Some)
        .map_err(|_| S3Error::invalid_request("Content-Length must be an integer"))
}

#[derive(Debug, Default)]
struct TransferEncodingValidation {
    has_any: bool,
    has_chunked: bool,
}

fn validate_transfer_encoding(headers: &HeaderMap) -> Result<TransferEncodingValidation, S3Error> {
    let values = headers
        .get_all(header::TRANSFER_ENCODING)
        .iter()
        .collect::<Vec<_>>();
    if values.is_empty() {
        return Ok(TransferEncodingValidation::default());
    }

    let mut has_chunked = false;
    let mut has_any = false;
    for value in values {
        let value = value
            .to_str()
            .map_err(|_| S3Error::invalid_request("Transfer-Encoding must be valid ASCII"))?;
        for encoding in value.split(',').map(str::trim) {
            if encoding.is_empty() {
                return Err(S3Error::invalid_request(
                    "Transfer-Encoding must not contain empty values",
                ));
            }
            has_any = true;
            if !encoding.eq_ignore_ascii_case("chunked") {
                return Err(S3Error::invalid_request(
                    "Unsupported Transfer-Encoding; only chunked is supported",
                ));
            }
            has_chunked = true;
        }
    }

    Ok(TransferEncodingValidation {
        has_any,
        has_chunked,
    })
}

#[cfg(test)]
mod tests {
    use axum::http::HeaderValue;

    use super::*;

    #[test]
    fn empty_request_body_headers_accept_absent_or_zero_content_length() {
        let headers = HeaderMap::new();
        validate_empty_request_body_headers(&headers, "ListParts").expect("no body headers");

        let mut headers = HeaderMap::new();
        headers.insert(header::CONTENT_LENGTH, HeaderValue::from_static("0"));
        validate_empty_request_body_headers(&headers, "ListParts").expect("zero length");
    }

    #[test]
    fn empty_request_body_headers_reject_non_zero_content_length() {
        let mut headers = HeaderMap::new();
        headers.insert(header::CONTENT_LENGTH, HeaderValue::from_static("4"));

        let error = validate_empty_request_body_headers(&headers, "ListParts")
            .expect_err("non-empty body should fail");

        assert!(format!("{error:?}").contains("ListParts requires Content-Length: 0"));
    }

    #[test]
    fn empty_request_body_headers_reject_transfer_encoding() {
        let mut headers = HeaderMap::new();
        headers.insert(
            header::TRANSFER_ENCODING,
            HeaderValue::from_static("chunked"),
        );

        let error = validate_empty_request_body_headers(&headers, "ListParts")
            .expect_err("transfer encoding should fail");

        assert!(format!("{error:?}").contains("ListParts does not support Transfer-Encoding"));
    }
}