Blob Blame Raw
From c167d6127db45d8426437c273060c8c8f7fbcb9b Mon Sep 17 00:00:00 2001
From: Firstyear <william.brown@suse.com>
Date: Wed, 23 Sep 2020 09:19:34 +1000
Subject: [PATCH 04/12] Ticket 4326 - entryuuid fixup did not work correctly
 (#4328)

Bug Description: due to an oversight in how fixup tasks
worked, the entryuuid fixup task did not work correctly and
would not persist over restarts.

Fix Description: Correctly implement entryuuid fixup.

fixes: #4326

Author: William Brown <william@blackhats.net.au>

Review by: mreynolds (thanks!)
---
 .../tests/suites/entryuuid/basic_test.py      |  24 +++-
 src/plugins/entryuuid/src/lib.rs              |  43 ++++++-
 src/slapi_r_plugin/src/constants.rs           |   5 +
 src/slapi_r_plugin/src/entry.rs               |   8 ++
 src/slapi_r_plugin/src/lib.rs                 |   2 +
 src/slapi_r_plugin/src/macros.rs              |   2 +-
 src/slapi_r_plugin/src/modify.rs              | 118 ++++++++++++++++++
 src/slapi_r_plugin/src/pblock.rs              |   7 ++
 src/slapi_r_plugin/src/value.rs               |   4 +
 9 files changed, 206 insertions(+), 7 deletions(-)
 create mode 100644 src/slapi_r_plugin/src/modify.rs

diff --git a/dirsrvtests/tests/suites/entryuuid/basic_test.py b/dirsrvtests/tests/suites/entryuuid/basic_test.py
index beb73701d..4d8a40909 100644
--- a/dirsrvtests/tests/suites/entryuuid/basic_test.py
+++ b/dirsrvtests/tests/suites/entryuuid/basic_test.py
@@ -12,6 +12,7 @@ import time
 import shutil
 from lib389.idm.user import nsUserAccounts, UserAccounts
 from lib389.idm.account import Accounts
+from lib389.idm.domain import Domain
 from lib389.topologies import topology_st as topology
 from lib389.backend import Backends
 from lib389.paths import Paths
@@ -190,6 +191,7 @@ def test_entryuuid_fixup_task(topology):
         3. Enable the entryuuid plugin
         4. Run the fixup
         5. Assert the entryuuid now exists
+        6. Restart and check they persist
 
     :expectedresults:
         1. Success
@@ -197,6 +199,7 @@ def test_entryuuid_fixup_task(topology):
         3. Success
         4. Success
         5. Suddenly EntryUUID!
+        6. Still has EntryUUID!
     """
     # 1. Disable the plugin
     plug = EntryUUIDPlugin(topology.standalone)
@@ -220,7 +223,22 @@ def test_entryuuid_fixup_task(topology):
     assert(task.is_complete() and task.get_exit_code() == 0)
     topology.standalone.config.loglevel(vals=(ErrorLog.DEFAULT,))
 
-    # 5. Assert the uuid.
-    euuid = account.get_attr_val_utf8('entryUUID')
-    assert(euuid is not None)
+    # 5.1 Assert the uuid on the user.
+    euuid_user = account.get_attr_val_utf8('entryUUID')
+    assert(euuid_user is not None)
+
+    # 5.2 Assert it on the domain entry.
+    domain = Domain(topology.standalone, dn=DEFAULT_SUFFIX)
+    euuid_domain = domain.get_attr_val_utf8('entryUUID')
+    assert(euuid_domain is not None)
+
+    # Assert it persists after a restart.
+    topology.standalone.restart()
+    # 6.1 Assert the uuid on the use.
+    euuid_user_2 = account.get_attr_val_utf8('entryUUID')
+    assert(euuid_user_2 == euuid_user)
+
+    # 6.2 Assert it on the domain entry.
+    euuid_domain_2 = domain.get_attr_val_utf8('entryUUID')
+    assert(euuid_domain_2 == euuid_domain)
 
diff --git a/src/plugins/entryuuid/src/lib.rs b/src/plugins/entryuuid/src/lib.rs
index 6b5e8d1bb..92977db05 100644
--- a/src/plugins/entryuuid/src/lib.rs
+++ b/src/plugins/entryuuid/src/lib.rs
@@ -187,9 +187,46 @@ impl SlapiPlugin3 for EntryUuid {
     }
 }
 
-pub fn entryuuid_fixup_mapfn(mut e: EntryRef, _data: &()) -> Result<(), PluginError> {
-    assign_uuid(&mut e);
-    Ok(())
+pub fn entryuuid_fixup_mapfn(e: &EntryRef, _data: &()) -> Result<(), PluginError> {
+    /* Supply a modification to the entry. */
+    let sdn = e.get_sdnref();
+
+    /* Sanity check that entryuuid doesn't already exist */
+    if e.contains_attr("entryUUID") {
+        log_error!(
+            ErrorLevel::Trace,
+            "skipping fixup for -> {}",
+            sdn.to_dn_string()
+        );
+        return Ok(());
+    }
+
+    // Setup the modifications
+    let mut mods = SlapiMods::new();
+
+    let u: Uuid = Uuid::new_v4();
+    let uuid_value = Value::from(&u);
+    let values: ValueArray = std::iter::once(uuid_value).collect();
+    mods.append(ModType::Replace, "entryUUID", values);
+
+    /* */
+    let lmod = Modify::new(&sdn, mods, plugin_id())?;
+
+    match lmod.execute() {
+        Ok(_) => {
+            log_error!(ErrorLevel::Trace, "fixed-up -> {}", sdn.to_dn_string());
+            Ok(())
+        }
+        Err(e) => {
+            log_error!(
+                ErrorLevel::Error,
+                "entryuuid_fixup_mapfn -> fixup failed -> {} {:?}",
+                sdn.to_dn_string(),
+                e
+            );
+            Err(PluginError::GenericFailure)
+        }
+    }
 }
 
 #[cfg(test)]
diff --git a/src/slapi_r_plugin/src/constants.rs b/src/slapi_r_plugin/src/constants.rs
index cf76ccbdb..34845c2f4 100644
--- a/src/slapi_r_plugin/src/constants.rs
+++ b/src/slapi_r_plugin/src/constants.rs
@@ -5,6 +5,11 @@ use std::os::raw::c_char;
 pub const LDAP_SUCCESS: i32 = 0;
 pub const PLUGIN_DEFAULT_PRECEDENCE: i32 = 50;
 
+#[repr(i32)]
+pub enum OpFlags {
+    ByassReferrals = 0x0040_0000,
+}
+
 #[repr(i32)]
 /// The set of possible function handles we can register via the pblock. These
 /// values correspond to slapi-plugin.h.
diff --git a/src/slapi_r_plugin/src/entry.rs b/src/slapi_r_plugin/src/entry.rs
index 034efe692..22ae45189 100644
--- a/src/slapi_r_plugin/src/entry.rs
+++ b/src/slapi_r_plugin/src/entry.rs
@@ -70,6 +70,14 @@ impl EntryRef {
         }
     }
 
+    pub fn contains_attr(&self, name: &str) -> bool {
+        let cname = CString::new(name).expect("invalid attr name");
+        let va = unsafe { slapi_entry_attr_get_valuearray(self.raw_e, cname.as_ptr()) };
+
+        // If it's null, it's not present, so flip the logic.
+        !va.is_null()
+    }
+
     pub fn add_value(&mut self, a: &str, v: &ValueRef) {
         // turn the attr to a c string.
         // TODO FIX
diff --git a/src/slapi_r_plugin/src/lib.rs b/src/slapi_r_plugin/src/lib.rs
index d7fc22e52..076907bae 100644
--- a/src/slapi_r_plugin/src/lib.rs
+++ b/src/slapi_r_plugin/src/lib.rs
@@ -9,6 +9,7 @@ pub mod dn;
 pub mod entry;
 pub mod error;
 pub mod log;
+pub mod modify;
 pub mod pblock;
 pub mod plugin;
 pub mod search;
@@ -24,6 +25,7 @@ pub mod prelude {
     pub use crate::entry::EntryRef;
     pub use crate::error::{DseCallbackStatus, LDAPError, PluginError, RPluginError};
     pub use crate::log::{log_error, ErrorLevel};
+    pub use crate::modify::{ModType, Modify, SlapiMods};
     pub use crate::pblock::{Pblock, PblockRef};
     pub use crate::plugin::{register_plugin_ext, PluginIdRef, SlapiPlugin3};
     pub use crate::search::{Search, SearchScope};
diff --git a/src/slapi_r_plugin/src/macros.rs b/src/slapi_r_plugin/src/macros.rs
index 030449632..bc8dfa60f 100644
--- a/src/slapi_r_plugin/src/macros.rs
+++ b/src/slapi_r_plugin/src/macros.rs
@@ -825,7 +825,7 @@ macro_rules! slapi_r_search_callback_mapfn {
                 let e = EntryRef::new(raw_e);
                 let data_ptr = raw_data as *const _;
                 let data = unsafe { &(*data_ptr) };
-                match $cb_mod_ident(e, data) {
+                match $cb_mod_ident(&e, data) {
                     Ok(_) => LDAPError::Success as i32,
                     Err(e) => e as i32,
                 }
diff --git a/src/slapi_r_plugin/src/modify.rs b/src/slapi_r_plugin/src/modify.rs
new file mode 100644
index 000000000..30864377a
--- /dev/null
+++ b/src/slapi_r_plugin/src/modify.rs
@@ -0,0 +1,118 @@
+use crate::constants::OpFlags;
+use crate::dn::SdnRef;
+use crate::error::{LDAPError, PluginError};
+use crate::pblock::Pblock;
+use crate::plugin::PluginIdRef;
+use crate::value::{slapi_value, ValueArray};
+
+use std::ffi::CString;
+use std::ops::{Deref, DerefMut};
+use std::os::raw::c_char;
+
+extern "C" {
+    fn slapi_modify_internal_set_pb_ext(
+        pb: *const libc::c_void,
+        dn: *const libc::c_void,
+        mods: *const *const libc::c_void,
+        controls: *const *const libc::c_void,
+        uniqueid: *const c_char,
+        plugin_ident: *const libc::c_void,
+        op_flags: i32,
+    );
+    fn slapi_modify_internal_pb(pb: *const libc::c_void);
+    fn slapi_mods_free(smods: *const *const libc::c_void);
+    fn slapi_mods_get_ldapmods_byref(smods: *const libc::c_void) -> *const *const libc::c_void;
+    fn slapi_mods_new() -> *const libc::c_void;
+    fn slapi_mods_add_mod_values(
+        smods: *const libc::c_void,
+        mtype: i32,
+        attrtype: *const c_char,
+        value: *const *const slapi_value,
+    );
+}
+
+#[derive(Debug)]
+#[repr(i32)]
+pub enum ModType {
+    Add = 0,
+    Delete = 1,
+    Replace = 2,
+}
+
+pub struct SlapiMods {
+    inner: *const libc::c_void,
+    vas: Vec<ValueArray>,
+}
+
+impl Drop for SlapiMods {
+    fn drop(&mut self) {
+        unsafe { slapi_mods_free(&self.inner as *const *const libc::c_void) }
+    }
+}
+
+impl SlapiMods {
+    pub fn new() -> Self {
+        SlapiMods {
+            inner: unsafe { slapi_mods_new() },
+            vas: Vec::new(),
+        }
+    }
+
+    pub fn append(&mut self, modtype: ModType, attrtype: &str, values: ValueArray) {
+        // We can get the value array pointer here to push to the inner
+        // because the internal pointers won't change even when we push them
+        // to the list to preserve their lifetime.
+        let vas = values.as_ptr();
+        // We take ownership of this to ensure it lives as least as long as our
+        // slapimods structure.
+        self.vas.push(values);
+        // now we can insert these to the modes.
+        let c_attrtype = CString::new(attrtype).expect("failed to allocate attrtype");
+        unsafe { slapi_mods_add_mod_values(self.inner, modtype as i32, c_attrtype.as_ptr(), vas) };
+    }
+}
+
+pub struct Modify {
+    pb: Pblock,
+    mods: SlapiMods,
+}
+
+pub struct ModifyResult {
+    pb: Pblock,
+}
+
+impl Modify {
+    pub fn new(dn: &SdnRef, mods: SlapiMods, plugin_id: PluginIdRef) -> Result<Self, PluginError> {
+        let pb = Pblock::new();
+        let lmods = unsafe { slapi_mods_get_ldapmods_byref(mods.inner) };
+        // OP_FLAG_ACTION_LOG_ACCESS
+
+        unsafe {
+            slapi_modify_internal_set_pb_ext(
+                pb.deref().as_ptr(),
+                dn.as_ptr(),
+                lmods,
+                std::ptr::null(),
+                std::ptr::null(),
+                plugin_id.raw_pid,
+                OpFlags::ByassReferrals as i32,
+            )
+        };
+
+        Ok(Modify { pb, mods })
+    }
+
+    pub fn execute(self) -> Result<ModifyResult, LDAPError> {
+        let Modify {
+            mut pb,
+            mods: _mods,
+        } = self;
+        unsafe { slapi_modify_internal_pb(pb.deref().as_ptr()) };
+        let result = pb.get_op_result();
+
+        match result {
+            0 => Ok(ModifyResult { pb }),
+            _e => Err(LDAPError::from(result)),
+        }
+    }
+}
diff --git a/src/slapi_r_plugin/src/pblock.rs b/src/slapi_r_plugin/src/pblock.rs
index b69ce1680..0f83914f3 100644
--- a/src/slapi_r_plugin/src/pblock.rs
+++ b/src/slapi_r_plugin/src/pblock.rs
@@ -11,6 +11,7 @@ pub use crate::log::{log_error, ErrorLevel};
 extern "C" {
     fn slapi_pblock_set(pb: *const libc::c_void, arg: i32, value: *const libc::c_void) -> i32;
     fn slapi_pblock_get(pb: *const libc::c_void, arg: i32, value: *const libc::c_void) -> i32;
+    fn slapi_pblock_destroy(pb: *const libc::c_void);
     fn slapi_pblock_new() -> *const libc::c_void;
 }
 
@@ -41,6 +42,12 @@ impl DerefMut for Pblock {
     }
 }
 
+impl Drop for Pblock {
+    fn drop(&mut self) {
+        unsafe { slapi_pblock_destroy(self.value.raw_pb) }
+    }
+}
+
 pub struct PblockRef {
     raw_pb: *const libc::c_void,
 }
diff --git a/src/slapi_r_plugin/src/value.rs b/src/slapi_r_plugin/src/value.rs
index 5a40dd279..46246837a 100644
--- a/src/slapi_r_plugin/src/value.rs
+++ b/src/slapi_r_plugin/src/value.rs
@@ -96,6 +96,10 @@ impl ValueArray {
         let bs = vs.into_boxed_slice();
         Box::leak(bs) as *const _ as *const *const slapi_value
     }
+
+    pub fn as_ptr(&self) -> *const *const slapi_value {
+        self.data.as_ptr() as *const *const slapi_value
+    }
 }
 
 impl FromIterator<Value> for ValueArray {
-- 
2.26.3