stub ttbc_get_abspath and ttbc_input_get_mtime for reproducibility

Author: Mrmaxmeier

crates/bridge_core/src/lib.rs

@@ -219,6 +219,7 @@ pub struct CoreBridgeLauncher<'a> {
     hooks: &'a mut dyn DriverHooks,
     status: &'a mut dyn StatusBackend,
     security: SecuritySettings,
+    filesystem_emulation_settings: FsEmulationSettings,
 }
 
 impl<'a> CoreBridgeLauncher<'a> {
@@ -242,8 +243,18 @@ impl<'a> CoreBridgeLauncher<'a> {
             hooks,
             status,
             security,
+            filesystem_emulation_settings: FsEmulationSettings::default(),
         }
     }
+
+    /// Configure filesystem emulation settings. These default to an "accurate"
+    /// view of the provided IO subsystem, but can be restricted to provide
+    /// reproducible file modified timestamps or hide absolute paths.
+    pub fn with_fs_emulation_settings(&mut self, settings: FsEmulationSettings) -> &mut Self {
+        self.filesystem_emulation_settings = settings;
+        self
+    }
+
     /// Invoke a function to launch a bridged FFI engine with a global mutex
     /// held.
     ///
@@ -262,7 +273,12 @@ impl<'a> CoreBridgeLauncher<'a> {
         F: FnOnce(&mut CoreBridgeState<'_>) -> Result<T>,
     {
         let _guard = ENGINE_LOCK.lock().unwrap();
-        let mut state = CoreBridgeState::new(self.security.clone(), self.hooks, self.status);
+        let mut state = CoreBridgeState::new(
+            self.security.clone(),
+            self.hooks,
+            self.status,
+            self.filesystem_emulation_settings.clone(),
+        );
         let result = callback(&mut state);
 
         if let Err(ref e) = result {
@@ -285,6 +301,9 @@ pub struct CoreBridgeState<'a> {
     /// The security settings for this invocation
     security: SecuritySettings,
 
+    /// The filesystem emulation settings for this invocation.
+    fs_emulation_settings: FsEmulationSettings,
+
     /// The driver hooks associated with this engine invocation.
     hooks: &'a mut dyn DriverHooks,
 
@@ -312,6 +331,7 @@ impl<'a> CoreBridgeState<'a> {
         security: SecuritySettings,
         hooks: &'a mut dyn DriverHooks,
         status: &'a mut dyn StatusBackend,
+        fs_emulation_settings: FsEmulationSettings,
     ) -> CoreBridgeState<'a> {
         CoreBridgeState {
             security,
@@ -320,6 +340,7 @@ impl<'a> CoreBridgeState<'a> {
             output_handles: Vec::new(),
             input_handles: Vec::new(),
             latest_input_path: None,
+            fs_emulation_settings,
         }
     }
 
@@ -592,6 +613,9 @@ impl<'a> CoreBridgeState<'a> {
     }
 
     fn input_get_mtime(&mut self, handle: *mut InputHandle) -> i64 {
+        if let Some(mtime) = self.fs_emulation_settings.mtime_override {
+            return mtime;
+        }
         let rhandle: &mut InputHandle = unsafe { &mut *handle };
 
         let maybe_time = match rhandle.get_unix_mtime() {
@@ -773,6 +797,32 @@ impl Default for SecuritySettings {
     }
 }
 
+/// A type that stores configuration knobs related to filesystem emulation.
+/// These options are not security-critical, but are relevant for
+/// reproducible document builds. We default to an "accurate" view of the
+/// underlying IO subsystem and have options that stub the respective IO
+/// functions with fake / stable values.
+#[derive(Clone, Debug)]
+pub struct FsEmulationSettings {
+    /// While absolute paths are useful (for SyncTeX and external tools that
+    /// resolve paths to TeX sources), we can disable them for reproducibility.
+    pub expose_absolute_paths: bool,
+
+    /// Ditto for file modification timestamps. In reproducible mode, we return
+    /// the configured build time (i.e. `SOURCE_DATE_EPOCH`) instead of the
+    /// modification timestamp reported by the IO subsystem.
+    pub mtime_override: Option<i64>,
+}
+
+impl Default for FsEmulationSettings {
+    fn default() -> Self {
+        Self {
+            expose_absolute_paths: true,
+            mtime_override: None,
+        }
+    }
+}
+
 // The entry points.
 
 /// Issue a warning.
@@ -968,6 +1018,9 @@ pub unsafe extern "C" fn ttbc_get_last_input_abspath(
     buffer: *mut u8,
     len: libc::size_t,
 ) -> libc::ssize_t {
+    if !es.fs_emulation_settings.expose_absolute_paths {
+        return 0;
+    }
     match es.latest_input_path {
         None => 0,
 

src/driver.rs

@@ -28,7 +28,9 @@ use std::{
     str::FromStr,
     time::SystemTime,
 };
-use tectonic_bridge_core::{CoreBridgeLauncher, DriverHooks, SecuritySettings, SystemRequestError};
+use tectonic_bridge_core::{
+    CoreBridgeLauncher, DriverHooks, FsEmulationSettings, SecuritySettings, SystemRequestError,
+};
 use tectonic_bundles::Bundle;
 use tectonic_engine_spx2html::AssetSpecification;
 use tectonic_io_base::{
@@ -1829,6 +1831,18 @@ impl ProcessingSession {
 
             let mut launcher =
                 CoreBridgeLauncher::new_with_security(&mut self.bs, status, self.security.clone());
+            launcher.with_fs_emulation_settings(FsEmulationSettings {
+                // We enable absolute paths if synctex was requested or other
+                // external tools are involved.
+                expose_absolute_paths: self.synctex_enabled || self.security.allow_shell_escape(),
+                // Note: We always return "dummy" modification times. Should
+                // there be a configuration knob to return the real mtime?
+                mtime_override: self
+                    .build_date
+                    .duration_since(SystemTime::UNIX_EPOCH)
+                    .map(|x| x.as_secs() as i64)
+                    .ok(),
+            });
 
             TexEngine::default()
                 .halt_on_error_mode(!self.unstables.continue_on_errors)