Add IXFR out support.

crates/zonedata/src/storage/mod.rs

@@ -7,7 +7,9 @@
 
 use std::sync::Arc;
 
-use crate::{LoadedZoneRestorer, LoadedZoneReviewer, SignedZoneReviewer, ZoneViewer, data::Data};
+use crate::{
+    DiffData, LoadedZoneRestorer, LoadedZoneReviewer, SignedZoneReviewer, ZoneViewer, data::Data,
+};
 
 mod states;
 pub use states::{
@@ -135,4 +137,27 @@ impl ZoneDataStorage {
             ZoneDataStorage::Poisoned => "Poisoned",
         }
     }
+
+    /// Get the current loaded diff, if any.
+    pub fn loaded_diff(&self) -> Option<Arc<DiffData>> {
+        match self {
+            ZoneDataStorage::ReviewLoadedPending(s) => Some(s.loaded_diff.clone()),
+            ZoneDataStorage::ReviewingLoaded(s) => Some(s.loaded_diff.clone()),
+            ZoneDataStorage::PersistingLoaded(s) => Some(s.loaded_diff.clone()),
+            _ => None,
+        }
+    }
+
+    /// Get the current signed diff, if any.
+    pub fn signed_diff(&self) -> Option<Arc<DiffData>> {
+        match self {
+            ZoneDataStorage::ReviewSignedPending(s) => Some(s.signed_diff.clone()),
+            ZoneDataStorage::ReviewingSigned(s) => Some(s.signed_diff.clone()),
+            ZoneDataStorage::PersistingSigned(_) => {
+                // PersistingSigned has no diff unlike PersistingLoaded
+                None
+            }
+            _ => None,
+        }
+    }
 }

src/persistence/persist.rs

@@ -3,7 +3,7 @@
 use std::sync::Arc;
 
 use cascade_zonedata::{
-    LoadedZonePersisted, LoadedZonePersister, SignedZonePersisted, SignedZonePersister,
+    DiffData, LoadedZonePersisted, LoadedZonePersister, SignedZonePersisted, SignedZonePersister,
 };
 
 use crate::{center::Center, zone::Zone};
@@ -19,8 +19,30 @@ pub fn persist_loaded(
     center: &Arc<Center>,
     persister: LoadedZonePersister,
 ) -> LoadedZonePersisted {
-    // TODO
-    let _ = (zone, center);
+    let _ = center;
+
+    // Store the loaded diff in-memory for serving IXFR out.
+
+    let loaded_diff = persister.loaded_diff();
+
+    // Only store a diff if something has changed compared to the previous
+    // version of the loaded zone, otherwise this is not a diff to a previous
+    // version of the zone but actually a snapshot of the zone after having
+    // been loaded for the first time. If the SOA serial didn't change (which
+    // is legal for a loaded zone) don't store a diff because the IXFR protocol
+    // requires a SOA serial number change so we won't be able to serve the diff
+    // anyway.
+    if !loaded_diff.is_empty() && loaded_diff.removed_soa.is_some() {
+        // Store anything that changed when the zone was re-loaded, i.e.
+        // unsigned zone content changes. Note that the SOA SERIAL is not
+        // required to change unless using 'keep' policy and so we should not
+        // require the SOA to have been removed and a new one added.
+        let mut state = zone.state.lock().unwrap();
+
+        let loaded_only_diff = (persister.loaded_diff().clone(), DiffData::new().into());
+        state.storage.diffs.push(loaded_only_diff);
+    }
+
     persister.mark_complete()
 }
 
@@ -35,7 +57,36 @@ pub fn persist_signed(
     center: &Arc<Center>,
     persister: SignedZonePersister,
 ) -> SignedZonePersisted {
-    // TODO
-    let _ = (zone, center);
+    let _ = center;
+
+    // Store the signed diff in-memory for serving IXFR out.
+    //
+    // Only store a diff if the SOA from the previous version of the signed
+    // zone was removed and a new one added, otherwise this is not a diff to a
+    // previous version of the zone but actually a snapshot of the zone after
+    // having been signed for the first time.
+    let loaded_diff = persister.loaded_diff();
+    let signed_diff = persister.signed_diff();
+
+    if signed_diff.removed_soa.is_some() && signed_diff.removed_soa != signed_diff.added_soa {
+        let mut state = zone.state.lock().unwrap();
+
+        // Store anything that changed when the zone was re-loaded, i.e.
+        // unsigned zone content changes. Note that the SOA SERIAL is not
+        // required to change unless using 'keep' policy and so we should not
+        // require the SOA to have been removed and a new one added.
+
+        // Store anything that changed when the zone was re-signed, i.e.
+        // changes DNSSEC RRs that can be caused by unsigned content changes
+        // or changing from NSEC <-> NSEC3 or using a new key to sign with or
+        // just regenerating signatures to avoid them expiring. Signed zones
+        // MUST always have a new SOA SERIAL compared to the previous version
+        // of the signed zone.
+
+        let loaded_diff = loaded_diff.cloned().unwrap_or(DiffData::new().into());
+        let complete_diff = (loaded_diff, signed_diff.clone());
+        state.storage.diffs.push(complete_diff);
+    }
+
     persister.mark_complete()
 }

src/server/mod.rs

@@ -34,7 +34,7 @@ pub struct LoadedReviewServer {
 impl LoadedReviewServer {
     /// Construct a new [`LoadedReviewServer`].
     pub fn new() -> Self {
-        let (service, handle) = ZoneService::new();
+        let (service, handle) = ZoneService::new(service::ServiceMode::LoadedReview);
         Self { service, handle }
     }
 
@@ -123,7 +123,7 @@ pub struct SignedReviewServer {
 impl SignedReviewServer {
     /// Construct a new [`SignedReviewServer`].
     pub fn new() -> Self {
-        let (service, handle) = ZoneService::new();
+        let (service, handle) = ZoneService::new(service::ServiceMode::SignedReview);
         Self { service, handle }
     }
 
@@ -212,7 +212,7 @@ pub struct PublicationServer {
 impl PublicationServer {
     /// Construct a new [`PublicationServer`].
     pub fn new() -> Self {
-        let (service, handle) = ZoneService::new();
+        let (service, handle) = ZoneService::new(service::ServiceMode::Publication);
         Self { service, handle }
     }
 

src/server/request.rs

@@ -139,7 +139,6 @@ pub enum ZoneRequestKind {
     Axfr,
 
     /// An IXFR request.
-    #[expect(dead_code)]
     Ixfr {
         /// The SOA record known to the client.
         known_soa: Record<(), Soa<Box<Name>>>,