@push.rocks/smartnftables 4.3.1 → 4.5.0

package/rust/src/owner.rs

@@ -302,7 +302,13 @@ impl Owner {
         }
         Ok(())
     }
+    /// Whether `graph` is `prepared`'s compiled graph. LEGACY(<=4.4.x): this
+    /// includes the untyped sets of a release before typed sets; with the next
+    /// major it becomes exact agreement alone.
     fn matches(&self, graph: &Graph, prepared: &Prepared) -> Result<bool> {
+        Ok(self.agreement(graph, prepared)? != Agreement::Different)
+    }
+    fn agreement(&self, graph: &Graph, prepared: &Prepared) -> Result<Agreement> {
         let program = prepared.program(&self.identity.table_name)?;
         let expected_chains: Vec<_> = program
             .iter()
@@ -336,21 +342,8 @@ impl Owner {
             }
             result
         };
-        // Element order is the set backend's; element keys are the identity.
-        let mut expected_sets = std::collections::BTreeMap::<String, (Vec<u8>, Vec<Vec<u8>>)>::new();
-        for (kind, attrs) in &program {
-            match kind {
-                9 => {
-                    expected_sets.insert(wire::text(attrs, 2)?, (set_identity(attrs)?, Vec::new()));
-                }
-                12 => {
-                    let entry = expected_sets
-                        .get_mut(&wire::text(attrs, 2)?)
-                        .ok_or(Error::Invalid)?;
-                    entry.1.extend(element_keys(&wire::attrs(&wire::one(attrs, 3)?.value)?)?);
-                }
-                _ => {}
-            }
+        if expected_chains != actual_chains || regroup(expected_rules) != regroup(actual_rules) {
+            return Ok(Agreement::Different);
         }
         let mut actual_sets = std::collections::BTreeMap::new();
         for (attrs, keys) in &graph.sets {
@@ -361,12 +354,22 @@ impl Owner {
                 return Err(Error::Conflict);
             }
         }
-        for entry in expected_sets.values_mut().chain(actual_sets.values_mut()) {
+        for entry in actual_sets.values_mut() {
             entry.1.sort();
         }
-        Ok(expected_chains == actual_chains
-            && regroup(expected_rules) == regroup(actual_rules)
-            && expected_sets == actual_sets)
+        if expected_sets(&program, false)? == actual_sets {
+            return Ok(Agreement::Exact);
+        }
+        // LEGACY(<=4.4.x): kernel state applied before typed sets carries every
+        // set with key and data type 0 and no userdata, which Linux stores and
+        // dumps but never interprets, so it enforces exactly the same graph.
+        // Such a graph is adopted, inspected and released as this graph, and
+        // reconciliation always replaces it. Remove with the next major.
+        Ok(if expected_sets(&program, true)? == actual_sets {
+            Agreement::Untyped
+        } else {
+            Agreement::Different
+        })
     }
     fn adopt(&mut self, graph: Graph, transition: &Transition) -> Result<Graph> {
         self.binding(&graph, transition.previous.as_ref())?;
@@ -464,13 +467,18 @@ impl Owner {
         let mut operations = Vec::new();
         let generation = if let Some(graph) = graph {
             let graph = self.adopt(graph, transition)?;
-            if self.matches(&graph, &transition.target)? {
+            let target = self.agreement(&graph, &transition.target)?;
+            if target == Agreement::Exact {
                 transition.target.validate_interfaces()?;
                 return self.applied(&graph, transition.target.clone());
             }
-            let previous = transition.previous.as_ref().ok_or(Error::Conflict)?;
-            if !self.matches(&graph, &previous.prepared)? {
-                return Err(Error::Conflict);
+            // LEGACY(<=4.4.x): the target's own untyped graph is never already
+            // applied; it is replaced like a previous graph, in the same batch.
+            if target == Agreement::Different {
+                let previous = transition.previous.as_ref().ok_or(Error::Conflict)?;
+                if !self.matches(&graph, &previous.prepared)? {
+                    return Err(Error::Conflict);
+                }
             }
             for rule in &graph.rules {
                 operations.push((
@@ -533,7 +541,7 @@ impl Owner {
         self.binding(&graph, transition.previous.as_ref())?;
         if wire::number(&graph.table, 2)? != 6
             || wire::number(&graph.table, 7)? != self.socket()?.port
-            || !self.matches(&graph, &transition.target)?
+            || self.agreement(&graph, &transition.target)? != Agreement::Exact
         {
             return Err(Error::Conflict);
         }
@@ -668,6 +676,61 @@ impl Owner {
     }
 }
 
+/// How a kernel graph agrees with a compiled one.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+enum Agreement {
+    /// Every chain, rule, set and element, with every set's types.
+    Exact,
+    /// LEGACY(<=4.4.x): the same graph with untyped sets. Remove with the next
+    /// major.
+    Untyped,
+    Different,
+}
+
+/// Sets by name, each with its identity and sorted element keys.
+type Sets = std::collections::BTreeMap<String, (Vec<u8>, Vec<Vec<u8>>)>;
+/// The compiled graph's sets. LEGACY(<=4.4.x): `untyped` declares them as a
+/// release before typed sets did; remove the parameter with the next major.
+fn expected_sets(program: &[(u16, Vec<Attr>)], untyped: bool) -> Result<Sets> {
+    // Element order is the set backend's; element keys are the identity.
+    let mut sets = Sets::new();
+    for (kind, attrs) in program {
+        match kind {
+            9 => {
+                let identity = if untyped {
+                    set_identity(&untyped_set(attrs))?
+                } else {
+                    set_identity(attrs)?
+                };
+                sets.insert(wire::text(attrs, 2)?, (identity, Vec::new()));
+            }
+            12 => {
+                let entry = sets
+                    .get_mut(&wire::text(attrs, 2)?)
+                    .ok_or(Error::Invalid)?;
+                entry.1.extend(element_keys(&wire::attrs(&wire::one(attrs, 3)?.value)?)?);
+            }
+            _ => {}
+        }
+    }
+    for entry in sets.values_mut() {
+        entry.1.sort();
+    }
+    Ok(sets)
+}
+/// LEGACY(<=4.4.x): a set declaration as releases before typed sets wrote it:
+/// key and data type 0 and no userdata. Remove with the next major.
+pub(super) fn untyped_set(attributes: &[Attr]) -> Vec<Attr> {
+    attributes
+        .iter()
+        .filter(|attribute| attribute.id() != 13)
+        .map(|attribute| match attribute.id() {
+            4 | 6 => Attr::u32(attribute.id(), 0),
+            _ => attribute.clone(),
+        })
+        .collect()
+}
+
 fn chain_identity(attributes: &[Attr]) -> Result<Vec<u8>> {
     let mut identity = Vec::new();
     for attribute in attributes {
@@ -681,9 +744,10 @@ fn chain_identity(attributes: &[Attr]) -> Result<Vec<u8>> {
     serde_json::to_vec(&wire::canonical(&identity, false)?).map_err(|_| Error::Protocol)
 }
 /// A set is its table, name, flags, key type and key length, a map's data type
-/// and length, and the field lengths of a concatenation. The handle, the
-/// informational backend type and count, the transaction ID and an empty
-/// description are not identity; anything else rejects.
+/// and length, the field lengths of a concatenation and its userdata (byte
+/// orders and `typeof` descriptions). The handle, the informational backend
+/// type and count, the transaction ID and an empty description are not
+/// identity; anything else rejects.
 fn set_identity(attributes: &[Attr]) -> Result<Vec<u8>> {
     let mut identity = Vec::new();
     for attribute in attributes {
@@ -694,13 +758,17 @@ fn set_identity(attributes: &[Attr]) -> Result<Vec<u8>> {
                     identity.push(Attr::bytes(9, fields));
                 }
             }
-            1..=7 => identity.push(attribute.clone()),
+            1..=7 | 13 => identity.push(attribute.clone()),
             _ => return Err(Error::Conflict),
         }
     }
     for id in [1, 2, 3, 4, 5] {
         wire::one(&identity, id)?;
     }
+    // At most one userdata: a typed set carries it, a legacy untyped one not.
+    if identity.iter().filter(|attribute| attribute.id() == 13).count() > 1 {
+        return Err(Error::Conflict);
+    }
     // A map carries its data type and length, and nothing else does.
     let map = wire::number(&identity, 3)? & 8 != 0;
     for id in [6, 7] {