mod common; use arrow_array::ffi::{FFI_ArrowArray, FFI_ArrowSchema}; use pheon::{ basic::ErrType, last_error_message, library::{read_library, read_selected_library, scan_library}, read_bytes, read_cells_bytes, record::RecordHeader, records, scan_bytes, }; use std::ffi::CStr; fn fixture() -> (Vec, (u64, u64)) { let mut bytes = common::library_header(); let start = bytes.len() as u64; common::record(&mut bytes, records::RTAG_BGNSTR, &[0; 24]); common::record(&mut bytes, records::RTAG_STRNAME, "töp".as_bytes()); common::record(&mut bytes, records::RTAG_SREF, &[]); common::record(&mut bytes, records::RTAG_SNAME, "töp".as_bytes()); common::record(&mut bytes, records::RTAG_XY, &[0; 8]); common::record(&mut bytes, records::RTAG_PROPATTR, &1_i16.to_be_bytes()); common::record(&mut bytes, records::RTAG_PROPVALUE, b"value\0"); common::record(&mut bytes, records::RTAG_ENDEL, &[]); common::record(&mut bytes, records::RTAG_TEXT, &[]); common::record(&mut bytes, records::RTAG_LAYER, &[0; 2]); common::record(&mut bytes, records::RTAG_TEXTTYPE, &[0; 2]); common::record(&mut bytes, records::RTAG_XY, &[0; 8]); common::record(&mut bytes, records::RTAG_STRING, b"label\0"); common::record(&mut bytes, records::RTAG_ENDEL, &[]); common::record(&mut bytes, records::RTAG_ENDSTR, &[]); let end = bytes.len() as u64; common::record(&mut bytes, records::RTAG_ENDLIB, &[]); (bytes, (start, end)) } fn payload_range(bytes: &[u8], tag: u16) -> std::ops::Range { let mut offset = 0; loop { let (_, header) = RecordHeader::read(&bytes[offset..]).unwrap(); let start = offset + 4; let end = start + usize::from(header.data_size); if header.tag == tag { return start..end; } offset = end; } } fn check_ffi_error( expected: &str, call: impl FnOnce(&mut FFI_ArrowArray, &mut FFI_ArrowSchema) -> i32, ) { let mut array = FFI_ArrowArray::empty(); let mut schema = FFI_ArrowSchema::empty(); assert_eq!(call(&mut array, &mut schema), -1); let pointer = last_error_message(); assert!(!pointer.is_null()); let error = unsafe { CStr::from_ptr(pointer) }.to_str().unwrap(); assert!(error.contains(expected), "{error}"); assert!( error.len() < 256, "error should not dump the input: {error}" ); assert!(array.is_released()); } fn check_read_errors(bytes: &[u8], range: (u64, u64), offset: usize, message: &str, scan: bool) { let ranges = [range]; let mut results = vec![read_library(bytes), read_selected_library(bytes, &ranges)]; if scan { results.push(scan_library(bytes)); } else { // Hierarchy scans deliberately skip text geometry and its string payloads. assert!(scan_library(bytes).is_ok()); } for result in results { let (remaining, error) = result.unwrap_err(); assert_eq!(remaining.as_ptr(), bytes[offset..].as_ptr()); assert!(matches!(error, ErrType::Failed(reason) if reason.starts_with(message))); } let expected = format!("at byte {offset}: {message}"); check_ffi_error(&expected, |a, s| unsafe { read_bytes(bytes.as_ptr(), bytes.len(), a, s) }); let offsets = [range.0, range.1]; check_ffi_error(&expected, |a, s| unsafe { read_cells_bytes(bytes.as_ptr(), bytes.len(), offsets.as_ptr(), 1, a, s) }); if scan { check_ffi_error(&expected, |a, s| unsafe { scan_bytes(bytes.as_ptr(), bytes.len(), a, s) }); } } #[test] fn invalid_utf8_returns_located_parse_errors_in_each_reader() { let (bytes, range) = fixture(); assert!(read_library(&bytes).is_ok()); assert!(read_selected_library(&bytes, &[range]).is_ok()); assert!(scan_library(&bytes).is_ok()); for tag in [ records::RTAG_LIBNAME, records::RTAG_STRNAME, records::RTAG_SNAME, records::RTAG_STRING, records::RTAG_PROPVALUE, ] { let mut malformed = bytes.clone(); let payload = payload_range(&malformed, tag); malformed[payload.start] = 0xff; // UTF-8 is checked at the current parser cursor, after the record/header. let offset = if tag == records::RTAG_LIBNAME { payload_range(&malformed, records::RTAG_UNITS).end } else { payload.end }; check_read_errors( &malformed, range, offset, "Invalid UTF-8 string:", tag != records::RTAG_STRING, ); } } #[test] fn large_invalid_utf8_strings_do_not_dump_their_contents() { let (mut bytes, range) = fixture(); let payload = payload_range(&bytes, records::RTAG_PROPVALUE); let mut replacement = Vec::new(); let mut value = vec![b'a'; 60_000]; value[30_000] = 0xff; common::record(&mut replacement, records::RTAG_PROPVALUE, &value); let added = replacement.len() - (payload.end - payload.start + 4); bytes.splice(payload.start - 4..payload.end, replacement); let range = (range.0, range.1 + added as u64); let offset = payload_range(&bytes, records::RTAG_PROPVALUE).end; check_read_errors(&bytes, range, offset, "Invalid UTF-8 string:", true); } #[test] fn overflowing_library_and_cell_years_return_the_same_error_in_each_reader() { for tag in [records::RTAG_BGNLIB, records::RTAG_BGNSTR] { for timestamp in [0, 1] { let (mut bytes, range) = fixture(); let payload = payload_range(&bytes, tag); let offset = payload.start + timestamp * 12; bytes[offset..offset + 2].copy_from_slice(&i16::MAX.to_be_bytes()); check_read_errors(&bytes, range, offset, "Timestamp year", true); } } }