Release request commit created with Cranko.

+++ cranko-rc-info-v1
[[projects]]
qnames = ["tectonic", "cargo"]
bump_spec = "micro bump"

+++

Author: cranko

CHANGELOG.md

@@ -1,5 +1,12 @@
 # rc: micro bump
 
+- When testing whether the engine needs rerunning, compare the new file to the
+  entire old file, not just the part that was read by the engine. Should fix
+  unnecessary reruns in some less-common cases. (#679, #681, @pkgw)
+
+
+# tectonic 0.3.2 (2020-11-14)
+
 - Slightly alter how some filenames are looked up. Before, if the TeX code
   requested a file whose name contained an extension, e.g. `foo.bar`, if no such
   file was available in the bundle we gave up immediately. Now we also check for

src/engines/mod.rs

@@ -469,12 +469,20 @@ impl<'a> ExecutionState<'a> {
             let p: *const InputHandle = &*self.input_handles[i];
 
             if p == handle {
-                let ih = self.input_handles.swap_remove(i);
+                let mut ih = self.input_handles.swap_remove(i);
+                let mut rv = false;
+
+                if let Err(e) = ih.scan_remainder() {
+                    tt_warning!(self.status, "error closing out input {}", ih.name().to_string_lossy(); e);
+                    rv = true;
+                }
+
                 let (name, digest_opt) = ih.into_name_digest();
                 self.events.input_closed(name, digest_opt);
-                return false;
+                return rv;
             }
         }
+
         // TODO: Handle the error better. This indicates a bug in the engine.
         tt_error!(
             self.status,

src/io/mod.rs

@@ -141,6 +141,37 @@ impl InputHandle {
         self.inner
     }
 
+    /// Read any remaining data in the file and incorporate them into the
+    /// digest. This helps the rerun detection logic work correctly in
+    /// the somewhat-unusual case that a file is read then written, but
+    /// only part of the file is read, not the entire thing. This seems
+    /// to happen with biblatex XML state files.
+    pub fn scan_remainder(&mut self) -> Result<()> {
+        const BUFSIZE: usize = 1024;
+        let mut buf: [u8; BUFSIZE] = [0; BUFSIZE];
+
+        loop {
+            let n = match self.inner.read(&mut buf[..]) {
+                Ok(n) => n,
+
+                // There are times when the engine tries to open and read
+                // directories. When closing out such a handle, we'll get this
+                // error, but we should ignore it.
+                Err(ref ioe) if ioe.raw_os_error() == Some(libc::EISDIR) => return Ok(()),
+
+                Err(e) => return Err(e.into()),
+            };
+
+            if n == 0 {
+                break;
+            }
+
+            self.digest.update(&buf[..n]);
+        }
+
+        Ok(())
+    }
+
     /// Consumes the object and returns the SHA256 sum of the content that was
     /// read. No digest is returned if there was ever a seek on the input
     /// stream, since in that case the results will not be reliable. We also