From f2f7b6ffec7bf657966353c850d25c6ab218ff7c Mon Sep 17 00:00:00 2001 From: Vika Date: Tue, 22 Oct 2024 21:52:10 +0300 Subject: vendor libsecret The libsecret-rs crate is unmaintained, so I'm vendoring it for now. Bumping the glib version turned out to be enough. The exact process I used was: 1. Cloning the repository 2. Making changes 3. `cargo build` to ensure it works 4. `cargo package --no-verify` (b/c it tries to build all crates separately instead of the entire workspace as a whole) 5. `mkdir libsecret/sys -p` 6. `tar --strip-components 1 -C libsecret -xvf ../libsecret-rs/target/package/libsecret-0.6.0.crate` 7. `tar --strip-components 1 -C libsecret/sys -xvf ../libsecret-rs/target/package/libsecret-sys-0.6.0.crate` Then `Cargo.toml` is modified to ensure the libsecret and its `-sys` crate build out of my vendored sources. In the future, if I gain maintainership of the `libsecret` crate, I could just revert this commit to make it point back to the upstream. --- libsecret/src/collection.rs | 267 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 267 insertions(+) create mode 100644 libsecret/src/collection.rs (limited to 'libsecret/src/collection.rs') diff --git a/libsecret/src/collection.rs b/libsecret/src/collection.rs new file mode 100644 index 0000000..6360a09 --- /dev/null +++ b/libsecret/src/collection.rs @@ -0,0 +1,267 @@ +// Take a look at the license at the top of the repository in the LICENSE file. + +use crate::{hashtable::attribute_names_and_values, Item}; +use crate::{Collection, Schema, SearchFlags}; + +use glib::object::IsA; +use glib::translate::*; + +use std::boxed::Box as Box_; +use std::collections::HashMap; +use std::pin::Pin; +use std::ptr; + +pub trait CollectionExtManual: 'static { + #[doc(alias = "secret_collection_search")] + fn search, glib::Error>) + 'static>( + &self, + schema: Option<&Schema>, + attributes: HashMap<&str, &str>, + flags: SearchFlags, + cancellable: Option<&impl IsA>, + callback: P, + ); + + fn search_future( + &self, + schema: Option<&Schema>, + attributes: HashMap<&str, &str>, + flags: SearchFlags, + ) -> Pin, glib::Error>> + 'static>>; + + #[doc(alias = "secret_collection_search_sync")] + fn search_sync( + &self, + schema: Option<&Schema>, + attributes: HashMap<&str, &str>, + flags: SearchFlags, + cancellable: Option<&impl IsA>, + ) -> Result, glib::Error>; + + #[doc(alias = "secret_collection_search_for_dbus_paths")] + fn search_for_dbus_paths, glib::Error>) + 'static>( + &self, + schema: Option<&Schema>, + attributes: HashMap<&str, &str>, + cancellable: Option<&impl IsA>, + callback: P, + ); + + fn search_for_dbus_paths_future( + &self, + schema: Option<&Schema>, + attributes: HashMap<&str, &str>, + ) -> Pin< + Box_, glib::Error>> + 'static>, + >; + + #[doc(alias = "secret_collection_search_for_dbus_paths_sync")] + fn search_for_dbus_paths_sync( + &self, + schema: Option<&Schema>, + attributes: HashMap<&str, &str>, + cancellable: Option<&impl IsA>, + ) -> Result, glib::Error>; +} + +impl> CollectionExtManual for O { + fn search, glib::Error>) + 'static>( + &self, + schema: Option<&Schema>, + attributes: HashMap<&str, &str>, + flags: SearchFlags, + cancellable: Option<&impl IsA>, + callback: P, + ) { + unsafe { + let user_data: Box_> = + Box_::new(glib::thread_guard::ThreadGuard::new(callback)); + unsafe extern "C" fn search_trampoline< + P: FnOnce(Result, glib::Error>) + 'static, + >( + _source_object: *mut glib::gobject_ffi::GObject, + res: *mut gio::ffi::GAsyncResult, + user_data: glib::ffi::gpointer, + ) { + let mut error = ptr::null_mut(); + let ret = + ffi::secret_collection_search_finish(_source_object as *mut _, res, &mut error); + let result = if error.is_null() { + Ok(FromGlibPtrContainer::from_glib_full(ret)) + } else { + Err(from_glib_full(error)) + }; + let callback: Box_> = + Box_::from_raw(user_data as *mut _); + let callback: P = callback.into_inner(); + callback(result); + } + let callback = search_trampoline::

; + + ffi::secret_collection_search( + self.as_ref().to_glib_none().0, + schema.to_glib_none().0, + attribute_names_and_values(attributes), + flags.into_glib(), + cancellable.map(|p| p.as_ref()).to_glib_none().0, + Some(callback), + Box_::into_raw(user_data) as *mut _, + ); + } + } + + fn search_future( + &self, + schema: Option<&Schema>, + attributes: HashMap<&str, &str>, + flags: SearchFlags, + ) -> Pin, glib::Error>> + 'static>> { + let schema = schema.map(ToOwned::to_owned); + let owned_map = attributes + .into_iter() + .map(|(k, v)| (k.to_string(), v.to_string())) + .collect::>(); + + Box_::pin(gio::GioFuture::new(self, move |obj, cancellable, send| { + let attributes = owned_map + .iter() + .map(|(k, v)| (k.as_str(), v.as_str())) + .collect::>(); + + obj.search( + schema.as_ref().map(::std::borrow::Borrow::borrow), + attributes, + flags, + Some(cancellable), + move |res| { + send.resolve(res); + }, + ); + })) + } + + fn search_sync( + &self, + schema: Option<&Schema>, + attributes: HashMap<&str, &str>, + flags: SearchFlags, + cancellable: Option<&impl IsA>, + ) -> Result, glib::Error> { + unsafe { + let mut err = std::ptr::null_mut(); + let res = ffi::secret_collection_search_sync( + self.as_ref().to_glib_none().0, + schema.to_glib_none().0, + attribute_names_and_values(attributes), + flags.into_glib(), + cancellable.map(|p| p.as_ref()).to_glib_none().0, + &mut err, + ); + if err.is_null() { + Ok(FromGlibPtrContainer::from_glib_full(res)) + } else { + Err(from_glib_full(err)) + } + } + } + #[doc(alias = "secret_collection_search_for_dbus_paths_sync")] + fn search_for_dbus_paths_sync( + &self, + schema: Option<&Schema>, + attributes: HashMap<&str, &str>, + cancellable: Option<&impl IsA>, + ) -> Result, glib::Error> { + unsafe { + let mut err = std::ptr::null_mut(); + let res = ffi::secret_collection_search_for_dbus_paths_sync( + self.as_ref().to_glib_none().0, + schema.to_glib_none().0, + attribute_names_and_values(attributes), + cancellable.map(|p| p.as_ref()).to_glib_none().0, + &mut err, + ); + if err.is_null() { + Ok(FromGlibPtrContainer::from_glib_full(res)) + } else { + Err(from_glib_full(err)) + } + } + } + + #[doc(alias = "secret_collection_search_for_dbus_paths")] + fn search_for_dbus_paths, glib::Error>) + 'static>( + &self, + schema: Option<&Schema>, + attributes: HashMap<&str, &str>, + cancellable: Option<&impl IsA>, + callback: P, + ) { + unsafe { + let user_data: Box_> = + Box_::new(glib::thread_guard::ThreadGuard::new(callback)); + unsafe extern "C" fn search_trampoline< + P: FnOnce(Result, glib::Error>) + 'static, + >( + _source_object: *mut glib::gobject_ffi::GObject, + res: *mut gio::ffi::GAsyncResult, + user_data: glib::ffi::gpointer, + ) { + let mut error = ptr::null_mut(); + let ret = ffi::secret_collection_search_for_dbus_paths_finish( + _source_object as *mut _, + res, + &mut error, + ); + let result = if error.is_null() { + Ok(FromGlibPtrContainer::from_glib_full(ret)) + } else { + Err(from_glib_full(error)) + }; + let callback: Box_> = + Box_::from_raw(user_data as *mut _); + let callback: P = callback.into_inner(); + callback(result); + } + let callback = search_trampoline::

; + + ffi::secret_collection_search_for_dbus_paths( + self.as_ref().to_glib_none().0, + schema.to_glib_none().0, + attribute_names_and_values(attributes), + cancellable.map(|p| p.as_ref()).to_glib_none().0, + Some(callback), + Box_::into_raw(user_data) as *mut _, + ); + } + } + + fn search_for_dbus_paths_future( + &self, + schema: Option<&Schema>, + attributes: HashMap<&str, &str>, + ) -> Pin< + Box_, glib::Error>> + 'static>, + > { + let schema = schema.map(ToOwned::to_owned); + let owned_map = attributes + .into_iter() + .map(|(k, v)| (k.to_string(), v.to_string())) + .collect::>(); + + Box_::pin(gio::GioFuture::new(self, move |obj, cancellable, send| { + let attributes = owned_map + .iter() + .map(|(k, v)| (k.as_str(), v.as_str())) + .collect::>(); + + obj.search_for_dbus_paths( + schema.as_ref().map(::std::borrow::Borrow::borrow), + attributes, + Some(cancellable), + move |res| { + send.resolve(res); + }, + ); + })) + } +} -- cgit 1.4.1