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.

1 files changed, 741 insertions, 0 deletions

diff --git a/libsecret/src/functions.rs b/libsecret/src/functions.rs
new file mode 100644
index 0000000..6dce25e
--- /dev/null
+++ b/libsecret/src/functions.rs
@@ -0,0 +1,741 @@
+use std::boxed::Box as Box_;
+use std::collections::HashMap;
+
+use crate::{hashtable::attribute_names_and_values, Schema};
+#[cfg(any(feature = "v0_19", feature = "dox"))]
+#[cfg_attr(feature = "dox", doc(cfg(feature = "v0_19")))]
+use crate::{Retrievable, SearchFlags, Value};
+use glib::{object::IsA, translate::*};
+
+#[doc(alias = "secret_password_clearv_sync")]
+#[doc(alias = "secret_password_clear_sync")]
+#[doc(alias = "password_clearv_sync")]
+pub fn password_clear_sync(
+    schema: Option<&Schema>,
+    attributes: HashMap<&str, &str>,
+    cancellable: Option<&impl IsA<gio::Cancellable>>,
+) -> Result<(), glib::Error> {
+    unsafe {
+        let mut err = std::ptr::null_mut();
+        ffi::secret_password_clearv_sync(
+            schema.to_glib_none().0,
+            attribute_names_and_values(attributes),
+            cancellable.map(|c| c.as_ref()).to_glib_none().0,
+            &mut err,
+        );
+        if err.is_null() {
+            Ok(())
+        } else {
+            Err(from_glib_full(err))
+        }
+    }
+}
+
+#[cfg(any(feature = "v0_19", feature = "dox"))]
+#[cfg_attr(feature = "dox", doc(cfg(feature = "v0_19")))]
+#[doc(alias = "secret_password_lookupv_binary_sync")]
+#[doc(alias = "secret_password_lookup_binary_sync")]
+#[doc(alias = "password_lookupv_binary_sync")]
+pub fn password_lookup_binary_sync(
+    schema: Option<&Schema>,
+    attributes: HashMap<&str, &str>,
+    cancellable: Option<&impl IsA<gio::Cancellable>>,
+) -> Result<Option<Value>, glib::Error> {
+    unsafe {
+        let mut err = std::ptr::null_mut();
+        let value = ffi::secret_password_lookupv_binary_sync(
+            schema.to_glib_none().0,
+            attribute_names_and_values(attributes),
+            cancellable.map(|c| c.as_ref()).to_glib_none().0,
+            &mut err,
+        );
+        if err.is_null() {
+            Ok(from_glib_full(value))
+        } else {
+            Err(from_glib_full(err))
+        }
+    }
+}
+
+#[doc(alias = "secret_password_lookupv_nonpageable_sync")]
+#[doc(alias = "secret_password_lookup_nonpageable_sync")]
+#[doc(alias = "password_lookupv_nonpageable_sync")]
+pub fn password_lookup_nonpageable_sync(
+    schema: Option<&Schema>,
+    attributes: HashMap<&str, &str>,
+    cancellable: Option<&impl IsA<gio::Cancellable>>,
+) -> Result<glib::GString, glib::Error> {
+    unsafe {
+        let mut err = std::ptr::null_mut();
+        let res = ffi::secret_password_lookupv_nonpageable_sync(
+            schema.to_glib_none().0,
+            attribute_names_and_values(attributes),
+            cancellable.map(|c| c.as_ref()).to_glib_none().0,
+            &mut err,
+        );
+        if err.is_null() {
+            Ok(from_glib_full(res))
+        } else {
+            Err(from_glib_full(err))
+        }
+    }
+}
+
+#[doc(alias = "secret_password_lookupv_sync")]
+#[doc(alias = "secret_password_lookup_sync")]
+#[doc(alias = "password_lookupv_sync")]
+pub fn password_lookup_sync(
+    schema: Option<&Schema>,
+    attributes: HashMap<&str, &str>,
+    cancellable: Option<&impl IsA<gio::Cancellable>>,
+) -> Result<Option<glib::GString>, glib::Error> {
+    unsafe {
+        let mut err = std::ptr::null_mut();
+        let res = ffi::secret_password_lookupv_sync(
+            schema.to_glib_none().0,
+            attribute_names_and_values(attributes),
+            cancellable.map(|c| c.as_ref()).to_glib_none().0,
+            &mut err,
+        );
+        if err.is_null() {
+            Ok(from_glib_full(res))
+        } else {
+            Err(from_glib_full(err))
+        }
+    }
+}
+
+#[cfg(any(feature = "v0_19", feature = "dox"))]
+#[cfg_attr(feature = "dox", doc(cfg(feature = "v0_19")))]
+#[doc(alias = "secret_password_searchv_sync")]
+#[doc(alias = "secret_password_search_sync")]
+#[doc(alias = "password_searchv_sync")]
+pub fn password_search_sync(
+    schema: Option<&Schema>,
+    attributes: HashMap<&str, &str>,
+    flags: SearchFlags,
+    cancellable: Option<&impl IsA<gio::Cancellable>>,
+) -> Result<Vec<Retrievable>, glib::Error> {
+    unsafe {
+        let mut err = std::ptr::null_mut();
+        let res = ffi::secret_password_searchv_sync(
+            schema.to_glib_none().0,
+            attribute_names_and_values(attributes),
+            flags.into_glib(),
+            cancellable.map(|c| c.as_ref()).to_glib_none().0,
+            &mut err,
+        );
+        if err.is_null() {
+            Ok(FromGlibPtrContainer::from_glib_full(res))
+        } else {
+            Err(from_glib_full(err))
+        }
+    }
+}
+
+#[cfg(any(feature = "v0_19", feature = "dox"))]
+#[cfg_attr(feature = "dox", doc(cfg(feature = "v0_19")))]
+#[doc(alias = "secret_password_storev_binary_sync")]
+#[doc(alias = "secret_password_store_binary_sync")]
+#[doc(alias = "password_storev_binary_sync")]
+pub fn password_store_binary_sync(
+    schema: Option<&Schema>,
+    attributes: HashMap<&str, &str>,
+    collection: Option<&str>,
+    label: &str,
+    value: &Value,
+    cancellable: Option<&impl IsA<gio::Cancellable>>,
+) -> Result<(), glib::Error> {
+    unsafe {
+        let mut err = std::ptr::null_mut();
+        ffi::secret_password_storev_binary_sync(
+            schema.to_glib_none().0,
+            attribute_names_and_values(attributes),
+            collection.to_glib_none().0,
+            label.to_glib_none().0,
+            value.to_glib_none().0,
+            cancellable.map(|c| c.as_ref()).to_glib_none().0,
+            &mut err,
+        );
+        if err.is_null() {
+            Ok(())
+        } else {
+            Err(from_glib_full(err))
+        }
+    }
+}
+
+#[doc(alias = "secret_password_storev_sync")]
+#[doc(alias = "secret_password_store_sync")]
+#[doc(alias = "password_storev_sync")]
+pub fn password_store_sync(
+    schema: Option<&Schema>,
+    attributes: HashMap<&str, &str>,
+    collection: Option<&str>,
+    label: &str,
+    password: &str,
+    cancellable: Option<&impl IsA<gio::Cancellable>>,
+) -> Result<(), glib::Error> {
+    unsafe {
+        let mut err = std::ptr::null_mut();
+        ffi::secret_password_storev_sync(
+            schema.to_glib_none().0,
+            attribute_names_and_values(attributes),
+            collection.to_glib_none().0,
+            label.to_glib_none().0,
+            password.to_glib_none().0,
+            cancellable.map(|c| c.as_ref()).to_glib_none().0,
+            &mut err,
+        );
+        if err.is_null() {
+            Ok(())
+        } else {
+            Err(from_glib_full(err))
+        }
+    }
+}
+
+#[doc(alias = "secret_password_clearv")]
+#[doc(alias = "secret_password_clear")]
+#[doc(alias = "password_clearv")]
+pub fn password_clear<P: FnOnce(Result<(), glib::Error>) + 'static>(
+    schema: Option<&Schema>,
+    attributes: HashMap<&str, &str>,
+    cancellable: Option<&impl IsA<gio::Cancellable>>,
+    callback: P,
+) {
+    let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        Box_::new(glib::thread_guard::ThreadGuard::new(callback));
+    unsafe extern "C" fn 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 err = std::ptr::null_mut();
+        ffi::secret_password_clear_finish(res, &mut err);
+        let result = if err.is_null() {
+            Ok(())
+        } else {
+            Err(from_glib_full(err))
+        };
+
+        let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            Box_::from_raw(user_data as *mut _);
+        let callback: P = callback.into_inner();
+        callback(result);
+    }
+
+    let callback = trampoline::<P>;
+    unsafe {
+        ffi::secret_password_clearv(
+            schema.to_glib_none().0,
+            attribute_names_and_values(attributes),
+            cancellable.map(|c| c.as_ref()).to_glib_none().0,
+            Some(callback),
+            Box_::into_raw(user_data) as *mut _,
+        );
+    }
+}
+
+#[doc(alias = "secret_password_clearv")]
+#[doc(alias = "secret_password_clear")]
+#[doc(alias = "password_clearv")]
+pub async fn password_clear_future(
+    schema: Option<&Schema>,
+    attributes: HashMap<&str, &str>,
+) -> Result<(), glib::Error> {
+    let schema = schema.map(ToOwned::to_owned);
+    let owned_map = attributes
+        .into_iter()
+        .map(|(k, v)| (k.to_string(), v.to_string()))
+        .collect::<HashMap<String, String>>();
+    gio::GioFuture::new(&(), move |_obj, cancellable, send| {
+        let attributes = owned_map
+            .iter()
+            .map(|(k, v)| (k.as_str(), v.as_str()))
+            .collect::<HashMap<&str, &str>>();
+        password_clear(
+            schema.as_ref().map(::std::borrow::Borrow::borrow),
+            attributes,
+            Some(cancellable),
+            move |res| {
+                send.resolve(res);
+            },
+        );
+    })
+    .await
+}
+
+#[doc(alias = "secret_password_lookupv")]
+#[doc(alias = "secret_password_lookup")]
+#[doc(alias = "password_lookupv")]
+pub fn password_lookup<P: FnOnce(Result<Option<glib::GString>, glib::Error>) + 'static>(
+    schema: Option<&Schema>,
+    attributes: HashMap<&str, &str>,
+    cancellable: Option<&impl IsA<gio::Cancellable>>,
+    callback: P,
+) {
+    let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        Box_::new(glib::thread_guard::ThreadGuard::new(callback));
+    unsafe extern "C" fn trampoline<
+        P: FnOnce(Result<Option<glib::GString>, glib::Error>) + 'static,
+    >(
+        _source_object: *mut glib::gobject_ffi::GObject,
+        res: *mut gio::ffi::GAsyncResult,
+        user_data: glib::ffi::gpointer,
+    ) {
+        let mut err = std::ptr::null_mut();
+        let res = ffi::secret_password_lookup_finish(res, &mut err);
+        let result = if err.is_null() {
+            Ok(from_glib_full(res))
+        } else {
+            Err(from_glib_full(err))
+        };
+        let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            Box_::from_raw(user_data as *mut _);
+        let callback: P = callback.into_inner();
+        callback(result);
+    }
+
+    let callback = trampoline::<P>;
+    unsafe {
+        ffi::secret_password_lookupv(
+            schema.to_glib_none().0,
+            attribute_names_and_values(attributes),
+            cancellable.map(|c| c.as_ref()).to_glib_none().0,
+            Some(callback),
+            Box_::into_raw(user_data) as *mut _,
+        );
+    }
+}
+
+#[doc(alias = "secret_password_lookupv")]
+#[doc(alias = "secret_password_lookup")]
+#[doc(alias = "password_lookupv")]
+pub async fn password_lookup_future(
+    schema: Option<&Schema>,
+    attributes: HashMap<&str, &str>,
+) -> Result<Option<glib::GString>, glib::Error> {
+    let schema = schema.map(ToOwned::to_owned);
+    let owned_map = attributes
+        .into_iter()
+        .map(|(k, v)| (k.to_string(), v.to_string()))
+        .collect::<HashMap<String, String>>();
+    gio::GioFuture::new(&(), move |_obj, cancellable, send| {
+        let attributes = owned_map
+            .iter()
+            .map(|(k, v)| (k.as_str(), v.as_str()))
+            .collect::<HashMap<&str, &str>>();
+        password_lookup(
+            schema.as_ref().map(::std::borrow::Borrow::borrow),
+            attributes,
+            Some(cancellable),
+            move |res| {
+                send.resolve(res);
+            },
+        );
+    })
+    .await
+}
+
+#[cfg(any(feature = "v0_19", feature = "dox"))]
+#[cfg_attr(feature = "dox", doc(cfg(feature = "v0_19")))]
+#[doc(alias = "secret_password_lookupv_binary")]
+#[doc(alias = "secret_password_lookup_binary")]
+#[doc(alias = "password_lookupv_binary")]
+pub fn password_lookup_binary<P: FnOnce(Result<Option<Value>, glib::Error>) + 'static>(
+    schema: Option<&Schema>,
+    attributes: HashMap<&str, &str>,
+    cancellable: Option<&impl IsA<gio::Cancellable>>,
+    callback: P,
+) {
+    let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        Box_::new(glib::thread_guard::ThreadGuard::new(callback));
+    unsafe extern "C" fn trampoline<P: FnOnce(Result<Option<Value>, glib::Error>) + 'static>(
+        _source_object: *mut glib::gobject_ffi::GObject,
+        res: *mut gio::ffi::GAsyncResult,
+        user_data: glib::ffi::gpointer,
+    ) {
+        let mut err = std::ptr::null_mut();
+        let res = ffi::secret_password_lookup_binary_finish(res, &mut err);
+        let result = if err.is_null() {
+            Ok(from_glib_full(res))
+        } else {
+            Err(from_glib_full(err))
+        };
+        let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            Box_::from_raw(user_data as *mut _);
+        let callback: P = callback.into_inner();
+        callback(result);
+    }
+
+    let callback = trampoline::<P>;
+    unsafe {
+        ffi::secret_password_lookupv(
+            schema.to_glib_none().0,
+            attribute_names_and_values(attributes),
+            cancellable.map(|c| c.as_ref()).to_glib_none().0,
+            Some(callback),
+            Box_::into_raw(user_data) as *mut _,
+        );
+    }
+}
+
+#[cfg(any(feature = "v0_19", feature = "dox"))]
+#[cfg_attr(feature = "dox", doc(cfg(feature = "v0_19")))]
+#[doc(alias = "secret_password_lookupv_binary")]
+#[doc(alias = "secret_password_lookup_binary")]
+#[doc(alias = "password_lookupv_binary")]
+pub async fn password_lookup_binary_future(
+    schema: Option<&Schema>,
+    attributes: HashMap<&str, &str>,
+) -> Result<Option<Value>, glib::Error> {
+    let schema = schema.map(ToOwned::to_owned);
+    let owned_map = attributes
+        .into_iter()
+        .map(|(k, v)| (k.to_string(), v.to_string()))
+        .collect::<HashMap<String, String>>();
+    gio::GioFuture::new(&(), move |_obj, cancellable, send| {
+        let attributes = owned_map
+            .iter()
+            .map(|(k, v)| (k.as_str(), v.as_str()))
+            .collect::<HashMap<&str, &str>>();
+        password_lookup_binary(
+            schema.as_ref().map(::std::borrow::Borrow::borrow),
+            attributes,
+            Some(cancellable),
+            move |res| {
+                send.resolve(res);
+            },
+        );
+    })
+    .await
+}
+
+#[doc(alias = "secret_password_lookupv_nonpageable")]
+#[doc(alias = "secret_password_lookup_nonpageable")]
+#[doc(alias = "password_lookupv_nonpageable")]
+pub fn password_lookup_nonpageable<
+    P: FnOnce(Result<Option<glib::GString>, glib::Error>) + 'static,
+>(
+    schema: Option<&Schema>,
+    attributes: HashMap<&str, &str>,
+    cancellable: Option<&impl IsA<gio::Cancellable>>,
+    callback: P,
+) {
+    let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        Box_::new(glib::thread_guard::ThreadGuard::new(callback));
+    unsafe extern "C" fn trampoline<
+        P: FnOnce(Result<Option<glib::GString>, glib::Error>) + 'static,
+    >(
+        _source_object: *mut glib::gobject_ffi::GObject,
+        res: *mut gio::ffi::GAsyncResult,
+        user_data: glib::ffi::gpointer,
+    ) {
+        let mut err = std::ptr::null_mut();
+        let res = ffi::secret_password_lookup_nonpageable_finish(res, &mut err);
+        let result = if err.is_null() {
+            Ok(from_glib_full(res))
+        } else {
+            Err(from_glib_full(err))
+        };
+        let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            Box_::from_raw(user_data as *mut _);
+        let callback: P = callback.into_inner();
+        callback(result);
+    }
+
+    let callback = trampoline::<P>;
+    unsafe {
+        ffi::secret_password_lookupv(
+            schema.to_glib_none().0,
+            attribute_names_and_values(attributes),
+            cancellable.map(|c| c.as_ref()).to_glib_none().0,
+            Some(callback),
+            Box_::into_raw(user_data) as *mut _,
+        );
+    }
+}
+
+#[doc(alias = "secret_password_lookupv_nonpageable")]
+#[doc(alias = "secret_password_lookup_nonpageable")]
+#[doc(alias = "password_lookupv_nonpageable")]
+pub async fn password_lookup_nonpageable_future(
+    schema: Option<&Schema>,
+    attributes: HashMap<&str, &str>,
+) -> Result<Option<glib::GString>, glib::Error> {
+    let schema = schema.map(ToOwned::to_owned);
+    let owned_map = attributes
+        .into_iter()
+        .map(|(k, v)| (k.to_string(), v.to_string()))
+        .collect::<HashMap<String, String>>();
+    gio::GioFuture::new(&(), move |_obj, cancellable, send| {
+        let attributes = owned_map
+            .iter()
+            .map(|(k, v)| (k.as_str(), v.as_str()))
+            .collect::<HashMap<&str, &str>>();
+        password_lookup_nonpageable(
+            schema.as_ref().map(::std::borrow::Borrow::borrow),
+            attributes,
+            Some(cancellable),
+            move |res| {
+                send.resolve(res);
+            },
+        );
+    })
+    .await
+}
+
+#[doc(alias = "secret_password_storev")]
+#[doc(alias = "secret_password_store")]
+#[doc(alias = "password_storev")]
+pub fn password_store<P: FnOnce(Result<(), glib::Error>) + 'static>(
+    schema: Option<&Schema>,
+    attributes: HashMap<&str, &str>,
+    collection: Option<&str>,
+    label: &str,
+    password: &str,
+    cancellable: Option<&impl IsA<gio::Cancellable>>,
+    callback: P,
+) {
+    let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        Box_::new(glib::thread_guard::ThreadGuard::new(callback));
+    unsafe extern "C" fn 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 err = std::ptr::null_mut();
+        ffi::secret_password_store_finish(res, &mut err);
+        let result = if err.is_null() {
+            Ok(())
+        } else {
+            Err(from_glib_full(err))
+        };
+
+        let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            Box_::from_raw(user_data as *mut _);
+        let callback: P = callback.into_inner();
+        callback(result);
+    }
+
+    let callback = trampoline::<P>;
+    unsafe {
+        ffi::secret_password_storev(
+            schema.to_glib_none().0,
+            attribute_names_and_values(attributes),
+            collection.to_glib_none().0,
+            label.to_glib_none().0,
+            password.to_glib_none().0,
+            cancellable.map(|c| c.as_ref()).to_glib_none().0,
+            Some(callback),
+            Box_::into_raw(user_data) as *mut _,
+        );
+    }
+}
+
+#[doc(alias = "secret_password_storev")]
+#[doc(alias = "secret_password_store")]
+#[doc(alias = "password_storev")]
+pub async fn password_store_future(
+    schema: Option<&Schema>,
+    attributes: HashMap<&str, &str>,
+    collection: Option<&str>,
+    label: &str,
+    password: &str,
+) -> Result<(), glib::Error> {
+    let schema = schema.map(ToOwned::to_owned);
+    let collection = collection.map(ToOwned::to_owned);
+    let label = label.to_owned();
+    let password = password.to_owned();
+    let owned_map = attributes
+        .into_iter()
+        .map(|(k, v)| (k.to_string(), v.to_string()))
+        .collect::<HashMap<String, String>>();
+    gio::GioFuture::new(&(), move |_obj, cancellable, send| {
+        let attributes = owned_map
+            .iter()
+            .map(|(k, v)| (k.as_str(), v.as_str()))
+            .collect::<HashMap<&str, &str>>();
+        password_store(
+            schema.as_ref().map(::std::borrow::Borrow::borrow),
+            attributes,
+            collection.as_ref().map(::std::borrow::Borrow::borrow),
+            &label,
+            &password,
+            Some(cancellable),
+            move |res| {
+                send.resolve(res);
+            },
+        );
+    })
+    .await
+}
+
+#[cfg(any(feature = "v0_19", feature = "dox"))]
+#[cfg_attr(feature = "dox", doc(cfg(feature = "v0_19")))]
+#[doc(alias = "secret_password_storev_binary")]
+#[doc(alias = "secret_password_store_binary")]
+#[doc(alias = "password_storev_binary")]
+pub fn password_store_binary<P: FnOnce(Result<(), glib::Error>) + 'static>(
+    schema: Option<&Schema>,
+    attributes: HashMap<&str, &str>,
+    collection: Option<&str>,
+    label: &str,
+    value: &Value,
+    cancellable: Option<&impl IsA<gio::Cancellable>>,
+    callback: P,
+) {
+    let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        Box_::new(glib::thread_guard::ThreadGuard::new(callback));
+    unsafe extern "C" fn 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 err = std::ptr::null_mut();
+        let _ = ffi::secret_password_store_finish(res, &mut err);
+        let result = if err.is_null() {
+            Ok(())
+        } else {
+            Err(from_glib_full(err))
+        };
+        let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            Box_::from_raw(user_data as *mut _);
+        let callback: P = callback.into_inner();
+        callback(result);
+    }
+
+    let callback = trampoline::<P>;
+    unsafe {
+        ffi::secret_password_storev_binary(
+            schema.to_glib_none().0,
+            attribute_names_and_values(attributes),
+            collection.to_glib_none().0,
+            label.to_glib_none().0,
+            value.to_glib_none().0,
+            cancellable.map(|c| c.as_ref()).to_glib_none().0,
+            Some(callback),
+            Box_::into_raw(user_data) as *mut _,
+        );
+    }
+}
+
+#[cfg(any(feature = "v0_19", feature = "dox"))]
+#[cfg_attr(feature = "dox", doc(cfg(feature = "v0_19")))]
+#[doc(alias = "secret_password_storev_binary")]
+#[doc(alias = "secret_password_store_binary")]
+#[doc(alias = "password_storev_binary")]
+pub async fn password_store_binary_future(
+    schema: Option<&Schema>,
+    attributes: HashMap<&str, &str>,
+    collection: Option<&str>,
+    label: &str,
+    value: &Value,
+) -> Result<(), glib::Error> {
+    let schema = schema.map(ToOwned::to_owned);
+    let collection = collection.map(ToOwned::to_owned);
+    let label = label.to_owned();
+    let password = value.clone();
+    let owned_map = attributes
+        .into_iter()
+        .map(|(k, v)| (k.to_string(), v.to_string()))
+        .collect::<HashMap<String, String>>();
+    gio::GioFuture::new(&(), move |_obj, cancellable, send| {
+        let attributes = owned_map
+            .iter()
+            .map(|(k, v)| (k.as_str(), v.as_str()))
+            .collect::<HashMap<&str, &str>>();
+        password_store_binary(
+            schema.as_ref().map(::std::borrow::Borrow::borrow),
+            attributes,
+            collection.as_ref().map(::std::borrow::Borrow::borrow),
+            &label,
+            &password,
+            Some(cancellable),
+            move |res| {
+                send.resolve(res);
+            },
+        );
+    })
+    .await
+}
+
+#[cfg(any(feature = "v0_19", feature = "dox"))]
+#[cfg_attr(feature = "dox", doc(cfg(feature = "v0_19")))]
+#[doc(alias = "secret_password_searchv")]
+#[doc(alias = "secret_password_search")]
+#[doc(alias = "password_searchv")]
+pub fn password_search<P: FnOnce(Result<Vec<Retrievable>, glib::Error>) + 'static>(
+    schema: Option<&Schema>,
+    attributes: HashMap<&str, &str>,
+    flags: SearchFlags,
+    cancellable: Option<&impl IsA<gio::Cancellable>>,
+    callback: P,
+) {
+    let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
+        Box_::new(glib::thread_guard::ThreadGuard::new(callback));
+    unsafe extern "C" fn trampoline<P: FnOnce(Result<Vec<Retrievable>, glib::Error>) + 'static>(
+        _source_object: *mut glib::gobject_ffi::GObject,
+        res: *mut gio::ffi::GAsyncResult,
+        user_data: glib::ffi::gpointer,
+    ) {
+        let mut err = std::ptr::null_mut();
+        let res = ffi::secret_password_search_finish(res, &mut err);
+        let result = if err.is_null() {
+            Ok(FromGlibPtrContainer::from_glib_full(res))
+        } else {
+            Err(from_glib_full(err))
+        };
+
+        let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
+            Box_::from_raw(user_data as *mut _);
+        let callback: P = callback.into_inner();
+        callback(result);
+    }
+
+    let callback = trampoline::<P>;
+    unsafe {
+        ffi::secret_password_searchv(
+            schema.to_glib_none().0,
+            attribute_names_and_values(attributes),
+            flags.into_glib(),
+            cancellable.map(|c| c.as_ref()).to_glib_none().0,
+            Some(callback),
+            Box_::into_raw(user_data) as *mut _,
+        );
+    }
+}
+
+#[cfg(any(feature = "v0_19", feature = "dox"))]
+#[cfg_attr(feature = "dox", doc(cfg(feature = "v0_19")))]
+#[doc(alias = "secret_password_searchv")]
+#[doc(alias = "secret_password_search")]
+#[doc(alias = "password_searchv")]
+pub async fn password_search_future(
+    schema: Option<&Schema>,
+    attributes: HashMap<&str, &str>,
+    flags: SearchFlags,
+) -> Result<Vec<Retrievable>, glib::Error> {
+    let schema = schema.map(ToOwned::to_owned);
+    let owned_map = attributes
+        .into_iter()
+        .map(|(k, v)| (k.to_string(), v.to_string()))
+        .collect::<HashMap<String, String>>();
+    gio::GioFuture::new(&(), move |_obj, cancellable, send| {
+        let attributes = owned_map
+            .iter()
+            .map(|(k, v)| (k.as_str(), v.as_str()))
+            .collect::<HashMap<&str, &str>>();
+        password_search(
+            schema.as_ref().map(::std::borrow::Borrow::borrow),
+            attributes,
+            flags,
+            Some(cancellable),
+            move |res| {
+                send.resolve(res);
+            },
+        );
+    })
+    .await
+}