rpdfium_parser/

header.rs

// Derived from PDFium's cpdf_parser.cpp (CPDF_Parser::StartParse / ParseHeader)
// Original: Copyright 2014 The PDFium Authors
// Licensed under BSD-3-Clause / Apache-2.0
// See pdfium-upstream/LICENSE for the original license.

//! PDF header parsing — detects `%PDF-X.Y` and returns the version.

use rpdfium_core::ParsingMode;
use rpdfium_core::error::PdfError;

/// PDF file version extracted from the header.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct PdfVersion {
    pub major: u8,
    pub minor: u8,
}

impl PdfVersion {
    pub fn new(major: u8, minor: u8) -> Self {
        Self { major, minor }
    }
}

impl std::fmt::Display for PdfVersion {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}.{}", self.major, self.minor)
    }
}

/// Maximum number of bytes to search for the `%PDF-` header marker.
/// PDFium searches up to 1024 bytes.
const MAX_HEADER_SEARCH: usize = 1024;

/// Parse the PDF header from the beginning of the source data.
///
/// Returns the detected version and the byte offset immediately after
/// the header line (after the trailing newline, if present).
///
/// In lenient mode, allows garbage bytes before the header and extra whitespace.
/// In strict mode, the header must appear at byte 0.
pub fn parse_header(source: &[u8], mode: ParsingMode) -> Result<(PdfVersion, u64), PdfError> {
    if source.len() < 8 {
        return Err(PdfError::InvalidHeader);
    }

    let header_pos = find_header(source, mode)?;
    let remaining = &source[header_pos..];

    // Expect: %PDF-X.Y
    if remaining.len() < 8 {
        return Err(PdfError::InvalidHeader);
    }

    // Parse major version digit
    let major = match remaining[5] {
        b @ b'0'..=b'9' => b - b'0',
        _ => return Err(PdfError::InvalidHeader),
    };

    // Expect '.'
    if remaining[6] != b'.' {
        return Err(PdfError::InvalidHeader);
    }

    // Parse minor version digit
    let minor = match remaining[7] {
        b @ b'0'..=b'9' => b - b'0',
        _ => return Err(PdfError::InvalidHeader),
    };

    // Skip past the header line
    let mut pos = header_pos + 8;

    // Skip any remaining characters on the header line (e.g. extra digits, though unusual)
    while pos < source.len() && source[pos] != b'\r' && source[pos] != b'\n' {
        pos += 1;
    }

    // Skip the line ending
    if pos < source.len() && source[pos] == b'\r' {
        pos += 1;
    }
    if pos < source.len() && source[pos] == b'\n' {
        pos += 1;
    }

    Ok((PdfVersion::new(major, minor), pos as u64))
}

/// Locate the `%PDF-` marker within the source.
fn find_header(source: &[u8], mode: ParsingMode) -> Result<usize, PdfError> {
    let marker = b"%PDF-";
    let search_limit = source.len().min(MAX_HEADER_SEARCH);

    match mode {
        ParsingMode::Strict => {
            if source.starts_with(marker) {
                Ok(0)
            } else {
                Err(PdfError::InvalidHeader)
            }
        }
        ParsingMode::Lenient => {
            // Search for %PDF- within the first MAX_HEADER_SEARCH bytes
            for i in 0..search_limit.saturating_sub(marker.len()) {
                if source[i..].starts_with(marker) {
                    if i > 0 {
                        tracing::warn!(
                            offset = i,
                            "PDF header not at byte 0; found garbage before %PDF-"
                        );
                    }
                    return Ok(i);
                }
            }
            Err(PdfError::InvalidHeader)
        }
    }
}

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

    #[test]
    fn test_parse_valid_header_1_7() {
        let source = b"%PDF-1.7\n";
        let (version, offset) = parse_header(source, ParsingMode::Strict).unwrap();
        assert_eq!(version, PdfVersion::new(1, 7));
        assert_eq!(offset, 9);
    }

    #[test]
    fn test_parse_valid_header_2_0() {
        let source = b"%PDF-2.0\r\n";
        let (version, offset) = parse_header(source, ParsingMode::Strict).unwrap();
        assert_eq!(version, PdfVersion::new(2, 0));
        assert_eq!(offset, 10);
    }

    #[test]
    fn test_parse_header_1_4() {
        let source = b"%PDF-1.4\n%\xe2\xe3\xcf\xd3\n";
        let (version, offset) = parse_header(source, ParsingMode::Strict).unwrap();
        assert_eq!(version, PdfVersion::new(1, 4));
        assert_eq!(offset, 9);
    }

    #[test]
    fn test_parse_header_with_cr() {
        let source = b"%PDF-1.5\r";
        let (version, offset) = parse_header(source, ParsingMode::Strict).unwrap();
        assert_eq!(version, PdfVersion::new(1, 5));
        assert_eq!(offset, 9);
    }

    #[test]
    fn test_parse_header_no_newline() {
        let source = b"%PDF-1.6 rest of file";
        let (version, _) = parse_header(source, ParsingMode::Strict).unwrap();
        assert_eq!(version, PdfVersion::new(1, 6));
    }

    #[test]
    fn test_strict_rejects_garbage_before_header() {
        let source = b"garbage%PDF-1.7\n";
        let result = parse_header(source, ParsingMode::Strict);
        assert!(result.is_err());
    }

    #[test]
    fn test_lenient_accepts_garbage_before_header() {
        let source = b"\0\0\0%PDF-1.7\n";
        let (version, _) = parse_header(source, ParsingMode::Lenient).unwrap();
        assert_eq!(version, PdfVersion::new(1, 7));
    }

    #[test]
    fn test_too_short() {
        let source = b"%PDF-1";
        let result = parse_header(source, ParsingMode::Strict);
        assert!(result.is_err());
    }

    #[test]
    fn test_invalid_version_char() {
        let source = b"%PDF-X.Y\n";
        let result = parse_header(source, ParsingMode::Strict);
        assert!(result.is_err());
    }

    #[test]
    fn test_version_display() {
        let v = PdfVersion::new(1, 7);
        assert_eq!(format!("{}", v), "1.7");
    }

    #[test]
    fn test_empty_source() {
        let result = parse_header(b"", ParsingMode::Lenient);
        assert!(result.is_err());
    }
}