Avoid panicking on short BIFF12 records

src/extension/writer.rs

@@ -3,15 +3,16 @@
 use crate::database::column::Column;
 use crate::database::column::ColumnType;
 use crate::error::RustySheetError;
+use crate::spreadsheet::SpreadsheetError;
 use crate::spreadsheet::cell::Cell;
 use crate::spreadsheet::cell::CellType;
+use crate::spreadsheet::resolve_loaded_shared_string;
+use crate::spreadsheet::sheet::Sheet;
 use duckdb::core::FlatVector;
 use duckdb::core::Inserter;
 use libduckdb_sys::duckdb_date;
 use libduckdb_sys::duckdb_time;
 use libduckdb_sys::duckdb_timestamp;
-use crate::spreadsheet::sheet::Sheet;
-use crate::spreadsheet::SpreadsheetError;
 
 /// Writes a cell value to a DuckDB vector based on column type.
 /// Handles type conversion and error mapping for different data types.
@@ -25,8 +26,9 @@ pub(super) fn write_to_vector(sheet: &Sheet, column: &Column, cell: &Cell, vecto
         )
     };
     let cell = if cell.kind == CellType::SharedString {
-        let index = cell.value.parse::<usize>()?;
-        if let Some(shared_string) = &shared_strings[index] {
+        if let Some(shared_string) =
+            resolve_loaded_shared_string(shared_strings, &sheet.file_name, &sheet.name, cell)?
+        {
             &Cell {
                 row: cell.row,
                 col: cell.col,
@@ -41,7 +43,7 @@ pub(super) fn write_to_vector(sheet: &Sheet, column: &Column, cell: &Cell, vecto
         cell
     };
     match column.kind {
-        ColumnType::Varchar => vector.insert(row, &cell.to_string()),
+        ColumnType::Varchar => vector.insert(row, &cell.to_display_string().map_err(mapper)?),
         ColumnType::Boolean => write_primitive(vector, row, cell.to_boolean()),
         ColumnType::BigInt => write_primitive(vector, row, cell.to_bigint().map_err(mapper)?),
         ColumnType::Double => write_primitive(vector, row, cell.to_double().map_err(mapper)?),

src/helpers/biff12.rs

@@ -42,15 +42,14 @@ impl<R: BufRead> Biff12Reader<R> {
         &'_ self,
         at: usize,
     ) -> Result<(Cow<'_, str>, usize), RustySheetError> {
-        let lower_bound = at + 4usize;
-        let size = to_usize(&self.buffer[at..at + lower_bound]);
-        let upper_bound = lower_bound + size * 2;
-        if self.buffer.len() >= upper_bound {
-            let (value, _, _) = UTF_16LE.decode(&self.buffer[lower_bound..upper_bound]);
-            Ok((value, upper_bound))
-        } else {
-            Err(Biff12Error::NoEnoughData(upper_bound, self.buffer.len()))?
-        }
+        let size = self.get_usize(at)?;
+        let lower_bound = checked_offset(at, 4, self.buffer.len())?;
+        let byte_length = size
+            .checked_mul(2)
+            .ok_or(Biff12Error::NoEnoughData(usize::MAX, self.buffer.len()))?;
+        let upper_bound = checked_offset(lower_bound, byte_length, self.buffer.len())?;
+        let (value, _, _) = UTF_16LE.decode(self.slice(lower_bound, byte_length)?);
+        Ok((value, upper_bound))
     }
 
     /// Reads a UTF-16 string from the specified position
@@ -60,33 +59,39 @@ impl<R: BufRead> Biff12Reader<R> {
     }
 
     /// Reads a usize value from the specified position
-    pub(crate) fn get_usize(&'_ self, at: usize) -> usize {
-        to_usize(&self.buffer[at..at + 4])
+    pub(crate) fn get_usize(&'_ self, at: usize) -> Result<usize, RustySheetError> {
+        Ok(to_usize(self.slice(at, 4)?))
     }
 
     /// Reads a u16 value from the specified position
-    pub(crate) fn get_u16(&'_ self, at: usize) -> u16 {
-        to_u16(&self.buffer[at..at + 2])
+    pub(crate) fn get_u16(&'_ self, at: usize) -> Result<u16, RustySheetError> {
+        Ok(to_u16(self.slice(at, 2)?))
     }
 
     /// Reads a u32 value from the specified position
-    pub(crate) fn get_u32(&'_ self, at: usize) -> u32 {
-        to_u32(&self.buffer[at..at + 4])
+    pub(crate) fn get_u32(&'_ self, at: usize) -> Result<u32, RustySheetError> {
+        Ok(to_u32(self.slice(at, 4)?))
     }
 
     /// Reads an i32 value from the specified position
-    pub(crate) fn get_i32(&'_ self, at: usize) -> i32 {
-        to_i32(&self.buffer[at..at + 4])
+    pub(crate) fn get_i32(&'_ self, at: usize) -> Result<i32, RustySheetError> {
+        Ok(to_i32(self.slice(at, 4)?))
     }
 
     /// Reads an f64 value from the specified position
-    pub(crate) fn get_f64(&'_ self, at: usize) -> f64 {
-        to_f64(&self.buffer[at..at + 8])
+    pub(crate) fn get_f64(&'_ self, at: usize) -> Result<f64, RustySheetError> {
+        Ok(to_f64(self.slice(at, 8)?))
     }
 
     /// Reads a style index from the specified position (3 bytes, padded to 4)
-    pub(crate) fn get_style(&'_ self, at: usize) -> usize {
-        to_usize(&[self.buffer[at], self.buffer[at + 1], self.buffer[at + 2], 0])
+    pub(crate) fn get_style(&'_ self, at: usize) -> Result<usize, RustySheetError> {
+        let bytes = self.slice(at, 3)?;
+        Ok(to_usize(&[bytes[0], bytes[1], bytes[2], 0]))
+    }
+
+    /// Reads a byte from the specified position
+    pub(crate) fn get_u8(&'_ self, at: usize) -> Result<u8, RustySheetError> {
+        Ok(self.slice(at, 1)?[0])
     }
 
     /// Reads a 7-bit continuation integer with the specified byte limit
@@ -150,6 +155,46 @@ impl<R: BufRead> Biff12Reader<R> {
     pub(crate) fn find(&mut self, target: u16) -> Result<usize, RustySheetError> {
         self.find_with(target, &[])
     }
+
+    fn slice(&self, at: usize, length: usize) -> Result<&[u8], RustySheetError> {
+        let upper_bound = checked_offset(at, length, self.buffer.len())?;
+        Ok(&self.buffer[at..upper_bound])
+    }
+}
+
+fn checked_offset(at: usize, length: usize, actual: usize) -> Result<usize, Biff12Error> {
+    let upper_bound = at
+        .checked_add(length)
+        .ok_or(Biff12Error::NoEnoughData(usize::MAX, actual))?;
+    if upper_bound <= actual {
+        Ok(upper_bound)
+    } else {
+        Err(Biff12Error::NoEnoughData(upper_bound, actual))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::io::Cursor;
+
+    #[test]
+    fn fixed_width_reads_return_errors_for_short_records() {
+        let mut reader = Biff12Reader::new(Cursor::new(Vec::new()));
+        reader.buffer = vec![0; 8];
+
+        assert!(reader.get_f64(1).unwrap_err().to_string().contains("No enough data"));
+        assert!(reader.get_style(6).unwrap_err().to_string().contains("No enough data"));
+    }
+
+    #[test]
+    fn string_reads_return_errors_for_short_records() {
+        let mut reader = Biff12Reader::new(Cursor::new(Vec::new()));
+        reader.buffer = vec![2, 0, 0, 0, b'a'];
+
+        assert!(reader.get_str(0).unwrap_err().to_string().contains("No enough data"));
+        assert!(reader.get_str(3).unwrap_err().to_string().contains("No enough data"));
+    }
 }
 
 #[macro_export]

src/spreadsheet/cell.rs

@@ -243,76 +243,36 @@ impl Cell {
             _ => Err(format!("parse '{}' to datetime failed", self.value))?,
         }
     }
-}
 
-impl Display for Cell {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let value = match self.kind {
-            CellType::Boolean => if self.value == "1" { "true" } else { "false" }.to_owned(),
-            CellType::NumberDateTime1900 => {
-                if let Ok(value) = to_datetime_string(&self.value, false) {
-                    value
-                } else {
-                    panic!(
-                        "Parse cell value '{}' at {} to DateTime(1900) failed",
-                        self.value,
-                        self.reference()
-                    );
-                }
-            }
-            CellType::NumberDate1900 => {
-                if let Ok(value) = to_date_string(&self.value, false) {
-                    value
-                } else {
-                    panic!(
-                        "Parse cell value '{}' at {} to Date(1900) failed",
-                        self.value,
-                        self.reference()
-                    );
-                }
-            }
-            CellType::NumberDateTime1904 => {
-                if let Ok(value) = to_datetime_string(&self.value, true) {
-                    value
-                } else {
-                    panic!(
-                        "Parse cell value '{}' at {} to DateTime(1904) failed",
-                        self.value,
-                        self.reference()
-                    );
-                }
-            }
-            CellType::NumberDate1904 => {
-                if let Ok(value) = to_date_string(&self.value, true) {
-                    value
-                } else {
-                    panic!(
-                        "Parse cell value '{}' at {} to Date(1904) failed",
-                        self.value,
-                        self.reference()
-                    );
-                }
-            }
-            CellType::NumberTime1900 | CellType::NumberTime1904 => {
-                if let Ok(value) = to_time_string(&self.value) {
-                    value
-                } else {
-                    panic!(
-                        "Parse cell value '{}' at {} to Time failed",
-                        self.value,
-                        self.reference()
-                    );
-                }
-            }
-            CellType::IsoDateTime => self.value.replace("T", " "),
-            CellType::IsoDuration => self
+    /// Converts the cell to the user-visible string representation.
+    pub(crate) fn to_display_string(&self) -> Result<String, String> {
+        match self.kind {
+            CellType::Boolean => Ok(if self.value == "1" { "true" } else { "false" }.to_owned()),
+            CellType::NumberDateTime1900 => to_datetime_string(&self.value, false)
+                .map_err(|_| format!("parse '{}' to DateTime(1900) failed", self.value)),
+            CellType::NumberDate1900 => to_date_string(&self.value, false)
+                .map_err(|_| format!("parse '{}' to Date(1900) failed", self.value)),
+            CellType::NumberDateTime1904 => to_datetime_string(&self.value, true)
+                .map_err(|_| format!("parse '{}' to DateTime(1904) failed", self.value)),
+            CellType::NumberDate1904 => to_date_string(&self.value, true)
+                .map_err(|_| format!("parse '{}' to Date(1904) failed", self.value)),
+            CellType::NumberTime1900 | CellType::NumberTime1904 => to_time_string(&self.value)
+                .map_err(|_| format!("parse '{}' to Time failed", self.value)),
+            CellType::IsoDateTime => Ok(self.value.replace("T", " ")),
+            CellType::IsoDuration => Ok(self
                 .value
                 .replace("PT", "")
                 .replace("H", ":")
                 .replace("M", ":")
-                .replace("S", ""),
-            _ => self.value.to_owned(),
-        };
+                .replace("S", "")),
+            _ => Ok(self.value.to_owned()),
+        }
+    }
+}
+
+impl Display for Cell {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let value = self.to_display_string().unwrap_or_else(|_| self.value.to_owned());
         write!(f, "{}", value)
     }
 }