diff options
Diffstat (limited to 'libsecret/src')
26 files changed, 7077 insertions, 0 deletions
diff --git a/libsecret/src/auto/backend.rs b/libsecret/src/auto/backend.rs new file mode 100644 index 0000000..bba5bf0 --- /dev/null +++ b/libsecret/src/auto/backend.rs @@ -0,0 +1,92 @@ +// This file was generated by gir (https://github.com/gtk-rs/gir) +// from +// from gir-files (https://github.com/gtk-rs/gir-files.git) +// DO NOT EDIT + +use crate::{BackendFlags, ServiceFlags}; +use glib::{prelude::*, translate::*}; +use std::{boxed::Box as Box_, pin::Pin}; + +glib::wrapper! { + #[doc(alias = "SecretBackend")] + pub struct Backend(Interface<ffi::SecretBackend, ffi::SecretBackendInterface>); + + match fn { + type_ => || ffi::secret_backend_get_type(), + } +} + +impl Backend { + pub const NONE: Option<&'static Backend> = None; + + #[doc(alias = "secret_backend_get")] + pub fn get<P: FnOnce(Result<Backend, glib::Error>) + 'static>( + flags: BackendFlags, + cancellable: Option<&impl IsA<gio::Cancellable>>, + callback: P, + ) { + let main_context = glib::MainContext::ref_thread_default(); + let is_main_context_owner = main_context.is_owner(); + let has_acquired_main_context = (!is_main_context_owner) + .then(|| main_context.acquire().ok()) + .flatten(); + assert!( + is_main_context_owner || has_acquired_main_context.is_some(), + "Async operations only allowed if the thread is owning the MainContext" + ); + + let user_data: Box_<glib::thread_guard::ThreadGuard<P>> = + Box_::new(glib::thread_guard::ThreadGuard::new(callback)); + unsafe extern "C" fn get_trampoline<P: FnOnce(Result<Backend, glib::Error>) + 'static>( + _source_object: *mut glib::gobject_ffi::GObject, + res: *mut gio::ffi::GAsyncResult, + user_data: glib::ffi::gpointer, + ) { + let mut error = std::ptr::null_mut(); + let ret = ffi::secret_backend_get_finish(res, &mut error); + let result = if error.is_null() { + Ok(from_glib_full(ret)) + } else { + Err(from_glib_full(error)) + }; + 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 = get_trampoline::<P>; + unsafe { + ffi::secret_backend_get( + flags.into_glib(), + cancellable.map(|p| p.as_ref()).to_glib_none().0, + Some(callback), + Box_::into_raw(user_data) as *mut _, + ); + } + } + + pub fn get_future( + flags: BackendFlags, + ) -> Pin<Box_<dyn std::future::Future<Output = Result<Backend, glib::Error>> + 'static>> { + Box_::pin(gio::GioFuture::new(&(), move |_obj, cancellable, send| { + Self::get(flags, Some(cancellable), move |res| { + send.resolve(res); + }); + })) + } +} + +mod sealed { + pub trait Sealed {} + impl<T: super::IsA<super::Backend>> Sealed for T {} +} + +pub trait BackendExt: IsA<Backend> + sealed::Sealed + 'static { + #[cfg(feature = "v0_19")] + #[cfg_attr(docsrs, doc(cfg(feature = "v0_19")))] + fn flags(&self) -> ServiceFlags { + ObjectExt::property(self.as_ref(), "flags") + } +} + +impl<O: IsA<Backend>> BackendExt for O {} diff --git a/libsecret/src/auto/collection.rs b/libsecret/src/auto/collection.rs new file mode 100644 index 0000000..8c91b65 --- /dev/null +++ b/libsecret/src/auto/collection.rs @@ -0,0 +1,742 @@ +// This file was generated by gir (https://github.com/gtk-rs/gir) +// from +// from gir-files (https://github.com/gtk-rs/gir-files.git) +// DO NOT EDIT + +use crate::{CollectionCreateFlags, CollectionFlags, Item, Service}; +use glib::{ + prelude::*, + signal::{connect_raw, SignalHandlerId}, + translate::*, +}; +use std::{boxed::Box as Box_, pin::Pin}; + +glib::wrapper! { + #[doc(alias = "SecretCollection")] + pub struct Collection(Object<ffi::SecretCollection, ffi::SecretCollectionClass>) @extends gio::DBusProxy, @implements gio::DBusInterface, gio::Initable; + + match fn { + type_ => || ffi::secret_collection_get_type(), + } +} + +impl Collection { + pub const NONE: Option<&'static Collection> = None; + + #[doc(alias = "secret_collection_new_for_dbus_path_sync")] + #[doc(alias = "new_for_dbus_path_sync")] + pub fn for_dbus_path_sync( + service: Option<&impl IsA<Service>>, + collection_path: &str, + flags: CollectionFlags, + cancellable: Option<&impl IsA<gio::Cancellable>>, + ) -> Result<Collection, glib::Error> { + unsafe { + let mut error = std::ptr::null_mut(); + let ret = ffi::secret_collection_new_for_dbus_path_sync( + service.map(|p| p.as_ref()).to_glib_none().0, + collection_path.to_glib_none().0, + flags.into_glib(), + cancellable.map(|p| p.as_ref()).to_glib_none().0, + &mut error, + ); + if error.is_null() { + Ok(from_glib_full(ret)) + } else { + Err(from_glib_full(error)) + } + } + } + + #[doc(alias = "secret_collection_create")] + pub fn create<P: FnOnce(Result<Collection, glib::Error>) + 'static>( + service: Option<&impl IsA<Service>>, + label: &str, + alias: Option<&str>, + flags: CollectionCreateFlags, + cancellable: Option<&impl IsA<gio::Cancellable>>, + callback: P, + ) { + let main_context = glib::MainContext::ref_thread_default(); + let is_main_context_owner = main_context.is_owner(); + let has_acquired_main_context = (!is_main_context_owner) + .then(|| main_context.acquire().ok()) + .flatten(); + assert!( + is_main_context_owner || has_acquired_main_context.is_some(), + "Async operations only allowed if the thread is owning the MainContext" + ); + + let user_data: Box_<glib::thread_guard::ThreadGuard<P>> = + Box_::new(glib::thread_guard::ThreadGuard::new(callback)); + unsafe extern "C" fn create_trampoline< + P: FnOnce(Result<Collection, glib::Error>) + 'static, + >( + _source_object: *mut glib::gobject_ffi::GObject, + res: *mut gio::ffi::GAsyncResult, + user_data: glib::ffi::gpointer, + ) { + let mut error = std::ptr::null_mut(); + let ret = ffi::secret_collection_create_finish(res, &mut error); + let result = if error.is_null() { + Ok(from_glib_full(ret)) + } else { + Err(from_glib_full(error)) + }; + 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 = create_trampoline::<P>; + unsafe { + ffi::secret_collection_create( + service.map(|p| p.as_ref()).to_glib_none().0, + label.to_glib_none().0, + alias.to_glib_none().0, + flags.into_glib(), + cancellable.map(|p| p.as_ref()).to_glib_none().0, + Some(callback), + Box_::into_raw(user_data) as *mut _, + ); + } + } + + pub fn create_future( + service: Option<&(impl IsA<Service> + Clone + 'static)>, + label: &str, + alias: Option<&str>, + flags: CollectionCreateFlags, + ) -> Pin<Box_<dyn std::future::Future<Output = Result<Collection, glib::Error>> + 'static>> + { + let service = service.map(ToOwned::to_owned); + let label = String::from(label); + let alias = alias.map(ToOwned::to_owned); + Box_::pin(gio::GioFuture::new(&(), move |_obj, cancellable, send| { + Self::create( + service.as_ref().map(::std::borrow::Borrow::borrow), + &label, + alias.as_ref().map(::std::borrow::Borrow::borrow), + flags, + Some(cancellable), + move |res| { + send.resolve(res); + }, + ); + })) + } + + #[doc(alias = "secret_collection_create_sync")] + pub fn create_sync( + service: Option<&impl IsA<Service>>, + label: &str, + alias: Option<&str>, + flags: CollectionCreateFlags, + cancellable: Option<&impl IsA<gio::Cancellable>>, + ) -> Result<Collection, glib::Error> { + unsafe { + let mut error = std::ptr::null_mut(); + let ret = ffi::secret_collection_create_sync( + service.map(|p| p.as_ref()).to_glib_none().0, + label.to_glib_none().0, + alias.to_glib_none().0, + flags.into_glib(), + cancellable.map(|p| p.as_ref()).to_glib_none().0, + &mut error, + ); + if error.is_null() { + Ok(from_glib_full(ret)) + } else { + Err(from_glib_full(error)) + } + } + } + + #[doc(alias = "secret_collection_for_alias")] + pub fn for_alias<P: FnOnce(Result<Option<Collection>, glib::Error>) + 'static>( + service: Option<&impl IsA<Service>>, + alias: &str, + flags: CollectionFlags, + cancellable: Option<&impl IsA<gio::Cancellable>>, + callback: P, + ) { + let main_context = glib::MainContext::ref_thread_default(); + let is_main_context_owner = main_context.is_owner(); + let has_acquired_main_context = (!is_main_context_owner) + .then(|| main_context.acquire().ok()) + .flatten(); + assert!( + is_main_context_owner || has_acquired_main_context.is_some(), + "Async operations only allowed if the thread is owning the MainContext" + ); + + let user_data: Box_<glib::thread_guard::ThreadGuard<P>> = + Box_::new(glib::thread_guard::ThreadGuard::new(callback)); + unsafe extern "C" fn for_alias_trampoline< + P: FnOnce(Result<Option<Collection>, glib::Error>) + 'static, + >( + _source_object: *mut glib::gobject_ffi::GObject, + res: *mut gio::ffi::GAsyncResult, + user_data: glib::ffi::gpointer, + ) { + let mut error = std::ptr::null_mut(); + let ret = ffi::secret_collection_for_alias_finish(res, &mut error); + let result = if error.is_null() { + Ok(from_glib_full(ret)) + } else { + Err(from_glib_full(error)) + }; + 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 = for_alias_trampoline::<P>; + unsafe { + ffi::secret_collection_for_alias( + service.map(|p| p.as_ref()).to_glib_none().0, + alias.to_glib_none().0, + flags.into_glib(), + cancellable.map(|p| p.as_ref()).to_glib_none().0, + Some(callback), + Box_::into_raw(user_data) as *mut _, + ); + } + } + + pub fn for_alias_future( + service: Option<&(impl IsA<Service> + Clone + 'static)>, + alias: &str, + flags: CollectionFlags, + ) -> Pin< + Box_<dyn std::future::Future<Output = Result<Option<Collection>, glib::Error>> + 'static>, + > { + let service = service.map(ToOwned::to_owned); + let alias = String::from(alias); + Box_::pin(gio::GioFuture::new(&(), move |_obj, cancellable, send| { + Self::for_alias( + service.as_ref().map(::std::borrow::Borrow::borrow), + &alias, + flags, + Some(cancellable), + move |res| { + send.resolve(res); + }, + ); + })) + } + + #[doc(alias = "secret_collection_for_alias_sync")] + pub fn for_alias_sync( + service: Option<&impl IsA<Service>>, + alias: &str, + flags: CollectionFlags, + cancellable: Option<&impl IsA<gio::Cancellable>>, + ) -> Result<Option<Collection>, glib::Error> { + unsafe { + let mut error = std::ptr::null_mut(); + let ret = ffi::secret_collection_for_alias_sync( + service.map(|p| p.as_ref()).to_glib_none().0, + alias.to_glib_none().0, + flags.into_glib(), + cancellable.map(|p| p.as_ref()).to_glib_none().0, + &mut error, + ); + if error.is_null() { + Ok(from_glib_full(ret)) + } else { + Err(from_glib_full(error)) + } + } + } + + #[doc(alias = "secret_collection_new_for_dbus_path")] + pub fn new_for_dbus_path<P: FnOnce(Result<Collection, glib::Error>) + 'static>( + service: Option<&impl IsA<Service>>, + collection_path: &str, + flags: CollectionFlags, + cancellable: Option<&impl IsA<gio::Cancellable>>, + callback: P, + ) { + let main_context = glib::MainContext::ref_thread_default(); + let is_main_context_owner = main_context.is_owner(); + let has_acquired_main_context = (!is_main_context_owner) + .then(|| main_context.acquire().ok()) + .flatten(); + assert!( + is_main_context_owner || has_acquired_main_context.is_some(), + "Async operations only allowed if the thread is owning the MainContext" + ); + + let user_data: Box_<glib::thread_guard::ThreadGuard<P>> = + Box_::new(glib::thread_guard::ThreadGuard::new(callback)); + unsafe extern "C" fn new_for_dbus_path_trampoline< + P: FnOnce(Result<Collection, glib::Error>) + 'static, + >( + _source_object: *mut glib::gobject_ffi::GObject, + res: *mut gio::ffi::GAsyncResult, + user_data: glib::ffi::gpointer, + ) { + let mut error = std::ptr::null_mut(); + let ret = ffi::secret_collection_new_for_dbus_path_finish(res, &mut error); + let result = if error.is_null() { + Ok(from_glib_full(ret)) + } else { + Err(from_glib_full(error)) + }; + 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 = new_for_dbus_path_trampoline::<P>; + unsafe { + ffi::secret_collection_new_for_dbus_path( + service.map(|p| p.as_ref()).to_glib_none().0, + collection_path.to_glib_none().0, + flags.into_glib(), + cancellable.map(|p| p.as_ref()).to_glib_none().0, + Some(callback), + Box_::into_raw(user_data) as *mut _, + ); + } + } + + pub fn new_for_dbus_path_future( + service: Option<&(impl IsA<Service> + Clone + 'static)>, + collection_path: &str, + flags: CollectionFlags, + ) -> Pin<Box_<dyn std::future::Future<Output = Result<Collection, glib::Error>> + 'static>> + { + let service = service.map(ToOwned::to_owned); + let collection_path = String::from(collection_path); + Box_::pin(gio::GioFuture::new(&(), move |_obj, cancellable, send| { + Self::new_for_dbus_path( + service.as_ref().map(::std::borrow::Borrow::borrow), + &collection_path, + flags, + Some(cancellable), + move |res| { + send.resolve(res); + }, + ); + })) + } +} + +mod sealed { + pub trait Sealed {} + impl<T: super::IsA<super::Collection>> Sealed for T {} +} + +pub trait CollectionExt: IsA<Collection> + sealed::Sealed + 'static { + #[doc(alias = "secret_collection_delete")] + fn delete<P: FnOnce(Result<(), glib::Error>) + 'static>( + &self, + cancellable: Option<&impl IsA<gio::Cancellable>>, + callback: P, + ) { + let main_context = glib::MainContext::ref_thread_default(); + let is_main_context_owner = main_context.is_owner(); + let has_acquired_main_context = (!is_main_context_owner) + .then(|| main_context.acquire().ok()) + .flatten(); + assert!( + is_main_context_owner || has_acquired_main_context.is_some(), + "Async operations only allowed if the thread is owning the MainContext" + ); + + let user_data: Box_<glib::thread_guard::ThreadGuard<P>> = + Box_::new(glib::thread_guard::ThreadGuard::new(callback)); + unsafe extern "C" fn delete_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 = std::ptr::null_mut(); + let _ = ffi::secret_collection_delete_finish(_source_object as *mut _, res, &mut error); + let result = if error.is_null() { + Ok(()) + } else { + Err(from_glib_full(error)) + }; + 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 = delete_trampoline::<P>; + unsafe { + ffi::secret_collection_delete( + self.as_ref().to_glib_none().0, + cancellable.map(|p| p.as_ref()).to_glib_none().0, + Some(callback), + Box_::into_raw(user_data) as *mut _, + ); + } + } + + fn delete_future( + &self, + ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> { + Box_::pin(gio::GioFuture::new(self, move |obj, cancellable, send| { + obj.delete(Some(cancellable), move |res| { + send.resolve(res); + }); + })) + } + + #[doc(alias = "secret_collection_delete_sync")] + fn delete_sync( + &self, + cancellable: Option<&impl IsA<gio::Cancellable>>, + ) -> Result<(), glib::Error> { + unsafe { + let mut error = std::ptr::null_mut(); + let is_ok = ffi::secret_collection_delete_sync( + self.as_ref().to_glib_none().0, + cancellable.map(|p| p.as_ref()).to_glib_none().0, + &mut error, + ); + debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null()); + if error.is_null() { + Ok(()) + } else { + Err(from_glib_full(error)) + } + } + } + + #[doc(alias = "secret_collection_get_created")] + #[doc(alias = "get_created")] + fn created(&self) -> u64 { + unsafe { ffi::secret_collection_get_created(self.as_ref().to_glib_none().0) } + } + + #[doc(alias = "secret_collection_get_flags")] + #[doc(alias = "get_flags")] + fn flags(&self) -> CollectionFlags { + unsafe { + from_glib(ffi::secret_collection_get_flags( + self.as_ref().to_glib_none().0, + )) + } + } + + #[doc(alias = "secret_collection_get_items")] + #[doc(alias = "get_items")] + fn items(&self) -> Vec<Item> { + unsafe { + FromGlibPtrContainer::from_glib_full(ffi::secret_collection_get_items( + self.as_ref().to_glib_none().0, + )) + } + } + + #[doc(alias = "secret_collection_get_label")] + #[doc(alias = "get_label")] + fn label(&self) -> glib::GString { + unsafe { + from_glib_full(ffi::secret_collection_get_label( + self.as_ref().to_glib_none().0, + )) + } + } + + #[doc(alias = "secret_collection_get_locked")] + #[doc(alias = "get_locked")] + fn is_locked(&self) -> bool { + unsafe { + from_glib(ffi::secret_collection_get_locked( + self.as_ref().to_glib_none().0, + )) + } + } + + #[doc(alias = "secret_collection_get_modified")] + #[doc(alias = "get_modified")] + fn modified(&self) -> u64 { + unsafe { ffi::secret_collection_get_modified(self.as_ref().to_glib_none().0) } + } + + #[doc(alias = "secret_collection_get_service")] + #[doc(alias = "get_service")] + fn service(&self) -> Service { + unsafe { + from_glib_none(ffi::secret_collection_get_service( + self.as_ref().to_glib_none().0, + )) + } + } + + #[doc(alias = "secret_collection_load_items")] + fn load_items<P: FnOnce(Result<(), glib::Error>) + 'static>( + &self, + cancellable: Option<&impl IsA<gio::Cancellable>>, + callback: P, + ) { + let main_context = glib::MainContext::ref_thread_default(); + let is_main_context_owner = main_context.is_owner(); + let has_acquired_main_context = (!is_main_context_owner) + .then(|| main_context.acquire().ok()) + .flatten(); + assert!( + is_main_context_owner || has_acquired_main_context.is_some(), + "Async operations only allowed if the thread is owning the MainContext" + ); + + let user_data: Box_<glib::thread_guard::ThreadGuard<P>> = + Box_::new(glib::thread_guard::ThreadGuard::new(callback)); + unsafe extern "C" fn load_items_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 = std::ptr::null_mut(); + let _ = + ffi::secret_collection_load_items_finish(_source_object as *mut _, res, &mut error); + let result = if error.is_null() { + Ok(()) + } else { + Err(from_glib_full(error)) + }; + 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 = load_items_trampoline::<P>; + unsafe { + ffi::secret_collection_load_items( + self.as_ref().to_glib_none().0, + cancellable.map(|p| p.as_ref()).to_glib_none().0, + Some(callback), + Box_::into_raw(user_data) as *mut _, + ); + } + } + + fn load_items_future( + &self, + ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> { + Box_::pin(gio::GioFuture::new(self, move |obj, cancellable, send| { + obj.load_items(Some(cancellable), move |res| { + send.resolve(res); + }); + })) + } + + #[doc(alias = "secret_collection_load_items_sync")] + fn load_items_sync( + &self, + cancellable: Option<&impl IsA<gio::Cancellable>>, + ) -> Result<(), glib::Error> { + unsafe { + let mut error = std::ptr::null_mut(); + let is_ok = ffi::secret_collection_load_items_sync( + self.as_ref().to_glib_none().0, + cancellable.map(|p| p.as_ref()).to_glib_none().0, + &mut error, + ); + debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null()); + if error.is_null() { + Ok(()) + } else { + Err(from_glib_full(error)) + } + } + } + + #[doc(alias = "secret_collection_refresh")] + fn refresh(&self) { + unsafe { + ffi::secret_collection_refresh(self.as_ref().to_glib_none().0); + } + } + + #[doc(alias = "secret_collection_set_label")] + fn set_label<P: FnOnce(Result<(), glib::Error>) + 'static>( + &self, + label: &str, + cancellable: Option<&impl IsA<gio::Cancellable>>, + callback: P, + ) { + let main_context = glib::MainContext::ref_thread_default(); + let is_main_context_owner = main_context.is_owner(); + let has_acquired_main_context = (!is_main_context_owner) + .then(|| main_context.acquire().ok()) + .flatten(); + assert!( + is_main_context_owner || has_acquired_main_context.is_some(), + "Async operations only allowed if the thread is owning the MainContext" + ); + + let user_data: Box_<glib::thread_guard::ThreadGuard<P>> = + Box_::new(glib::thread_guard::ThreadGuard::new(callback)); + unsafe extern "C" fn set_label_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 = std::ptr::null_mut(); + let _ = + ffi::secret_collection_set_label_finish(_source_object as *mut _, res, &mut error); + let result = if error.is_null() { + Ok(()) + } else { + Err(from_glib_full(error)) + }; + 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 = set_label_trampoline::<P>; + unsafe { + ffi::secret_collection_set_label( + self.as_ref().to_glib_none().0, + label.to_glib_none().0, + cancellable.map(|p| p.as_ref()).to_glib_none().0, + Some(callback), + Box_::into_raw(user_data) as *mut _, + ); + } + } + + fn set_label_future( + &self, + label: &str, + ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> { + let label = String::from(label); + Box_::pin(gio::GioFuture::new(self, move |obj, cancellable, send| { + obj.set_label(&label, Some(cancellable), move |res| { + send.resolve(res); + }); + })) + } + + #[doc(alias = "secret_collection_set_label_sync")] + fn set_label_sync( + &self, + label: &str, + cancellable: Option<&impl IsA<gio::Cancellable>>, + ) -> Result<(), glib::Error> { + unsafe { + let mut error = std::ptr::null_mut(); + let is_ok = ffi::secret_collection_set_label_sync( + self.as_ref().to_glib_none().0, + label.to_glib_none().0, + cancellable.map(|p| p.as_ref()).to_glib_none().0, + &mut error, + ); + debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null()); + if error.is_null() { + Ok(()) + } else { + Err(from_glib_full(error)) + } + } + } + + fn set_created(&self, created: u64) { + ObjectExt::set_property(self.as_ref(), "created", created) + } + + fn set_modified(&self, modified: u64) { + ObjectExt::set_property(self.as_ref(), "modified", modified) + } + + #[doc(alias = "created")] + fn connect_created_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { + unsafe extern "C" fn notify_created_trampoline<P: IsA<Collection>, F: Fn(&P) + 'static>( + this: *mut ffi::SecretCollection, + _param_spec: glib::ffi::gpointer, + f: glib::ffi::gpointer, + ) { + let f: &F = &*(f as *const F); + f(Collection::from_glib_borrow(this).unsafe_cast_ref()) + } + unsafe { + let f: Box_<F> = Box_::new(f); + connect_raw( + self.as_ptr() as *mut _, + b"notify::created\0".as_ptr() as *const _, + Some(std::mem::transmute::<_, unsafe extern "C" fn()>( + notify_created_trampoline::<Self, F> as *const (), + )), + Box_::into_raw(f), + ) + } + } + + #[doc(alias = "label")] + fn connect_label_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { + unsafe extern "C" fn notify_label_trampoline<P: IsA<Collection>, F: Fn(&P) + 'static>( + this: *mut ffi::SecretCollection, + _param_spec: glib::ffi::gpointer, + f: glib::ffi::gpointer, + ) { + let f: &F = &*(f as *const F); + f(Collection::from_glib_borrow(this).unsafe_cast_ref()) + } + unsafe { + let f: Box_<F> = Box_::new(f); + connect_raw( + self.as_ptr() as *mut _, + b"notify::label\0".as_ptr() as *const _, + Some(std::mem::transmute::<_, unsafe extern "C" fn()>( + notify_label_trampoline::<Self, F> as *const (), + )), + Box_::into_raw(f), + ) + } + } + + #[doc(alias = "locked")] + fn connect_locked_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { + unsafe extern "C" fn notify_locked_trampoline<P: IsA<Collection>, F: Fn(&P) + 'static>( + this: *mut ffi::SecretCollection, + _param_spec: glib::ffi::gpointer, + f: glib::ffi::gpointer, + ) { + let f: &F = &*(f as *const F); + f(Collection::from_glib_borrow(this).unsafe_cast_ref()) + } + unsafe { + let f: Box_<F> = Box_::new(f); + connect_raw( + self.as_ptr() as *mut _, + b"notify::locked\0".as_ptr() as *const _, + Some(std::mem::transmute::<_, unsafe extern "C" fn()>( + notify_locked_trampoline::<Self, F> as *const (), + )), + Box_::into_raw(f), + ) + } + } + + #[doc(alias = "modified")] + fn connect_modified_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { + unsafe extern "C" fn notify_modified_trampoline<P: IsA<Collection>, F: Fn(&P) + 'static>( + this: *mut ffi::SecretCollection, + _param_spec: glib::ffi::gpointer, + f: glib::ffi::gpointer, + ) { + let f: &F = &*(f as *const F); + f(Collection::from_glib_borrow(this).unsafe_cast_ref()) + } + unsafe { + let f: Box_<F> = Box_::new(f); + connect_raw( + self.as_ptr() as *mut _, + b"notify::modified\0".as_ptr() as *const _, + Some(std::mem::transmute::<_, unsafe extern "C" fn()>( + notify_modified_trampoline::<Self, F> as *const (), + )), + Box_::into_raw(f), + ) + } + } +} + +impl<O: IsA<Collection>> CollectionExt for O {} diff --git a/libsecret/src/auto/constants.rs b/libsecret/src/auto/constants.rs new file mode 100644 index 0000000..1086b79 --- /dev/null +++ b/libsecret/src/auto/constants.rs @@ -0,0 +1,16 @@ +// This file was generated by gir (https://github.com/gtk-rs/gir) +// from +// from gir-files (https://github.com/gtk-rs/gir-files.git) +// DO NOT EDIT + +use glib::GStr; + +#[doc(alias = "SECRET_BACKEND_EXTENSION_POINT_NAME")] +pub static BACKEND_EXTENSION_POINT_NAME: &GStr = + unsafe { GStr::from_utf8_with_nul_unchecked(ffi::SECRET_BACKEND_EXTENSION_POINT_NAME) }; +#[doc(alias = "SECRET_COLLECTION_DEFAULT")] +pub static COLLECTION_DEFAULT: &GStr = + unsafe { GStr::from_utf8_with_nul_unchecked(ffi::SECRET_COLLECTION_DEFAULT) }; +#[doc(alias = "SECRET_COLLECTION_SESSION")] +pub static COLLECTION_SESSION: &GStr = + unsafe { GStr::from_utf8_with_nul_unchecked(ffi::SECRET_COLLECTION_SESSION) }; diff --git a/libsecret/src/auto/enums.rs b/libsecret/src/auto/enums.rs new file mode 100644 index 0000000..d9cf2ff --- /dev/null +++ b/libsecret/src/auto/enums.rs @@ -0,0 +1,462 @@ +// This file was generated by gir (https://github.com/gtk-rs/gir) +// from +// from gir-files (https://github.com/gtk-rs/gir-files.git) +// DO NOT EDIT + +use glib::{prelude::*, translate::*}; + +#[cfg(feature = "v0_19")] +#[cfg_attr(docsrs, doc(cfg(feature = "v0_19")))] +#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] +#[non_exhaustive] +#[doc(alias = "SecretBackendFlags")] +pub enum BackendFlags { + #[doc(alias = "SECRET_BACKEND_NONE")] + None, + #[doc(alias = "SECRET_BACKEND_OPEN_SESSION")] + OpenSession, + #[doc(alias = "SECRET_BACKEND_LOAD_COLLECTIONS")] + LoadCollections, + #[doc(hidden)] + __Unknown(i32), +} + +#[cfg(feature = "v0_19")] +#[cfg_attr(docsrs, doc(cfg(feature = "v0_19")))] +#[doc(hidden)] +impl IntoGlib for BackendFlags { + type GlibType = ffi::SecretBackendFlags; + + #[inline] + fn into_glib(self) -> ffi::SecretBackendFlags { + match self { + Self::None => ffi::SECRET_BACKEND_NONE, + Self::OpenSession => ffi::SECRET_BACKEND_OPEN_SESSION, + Self::LoadCollections => ffi::SECRET_BACKEND_LOAD_COLLECTIONS, + Self::__Unknown(value) => value, + } + } +} + +#[cfg(feature = "v0_19")] +#[cfg_attr(docsrs, doc(cfg(feature = "v0_19")))] +#[doc(hidden)] +impl FromGlib<ffi::SecretBackendFlags> for BackendFlags { + #[inline] + unsafe fn from_glib(value: ffi::SecretBackendFlags) -> Self { + match value { + ffi::SECRET_BACKEND_NONE => Self::None, + ffi::SECRET_BACKEND_OPEN_SESSION => Self::OpenSession, + ffi::SECRET_BACKEND_LOAD_COLLECTIONS => Self::LoadCollections, + value => Self::__Unknown(value), + } + } +} + +#[cfg(feature = "v0_19")] +#[cfg_attr(docsrs, doc(cfg(feature = "v0_19")))] +impl StaticType for BackendFlags { + #[inline] + #[doc(alias = "secret_backend_flags_get_type")] + fn static_type() -> glib::Type { + unsafe { from_glib(ffi::secret_backend_flags_get_type()) } + } +} + +#[cfg(feature = "v0_19")] +#[cfg_attr(docsrs, doc(cfg(feature = "v0_19")))] +impl glib::HasParamSpec for BackendFlags { + type ParamSpec = glib::ParamSpecEnum; + type SetValue = Self; + type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>; + + fn param_spec_builder() -> Self::BuilderFn { + Self::ParamSpec::builder_with_default + } +} + +#[cfg(feature = "v0_19")] +#[cfg_attr(docsrs, doc(cfg(feature = "v0_19")))] +impl glib::value::ValueType for BackendFlags { + type Type = Self; +} + +#[cfg(feature = "v0_19")] +#[cfg_attr(docsrs, doc(cfg(feature = "v0_19")))] +unsafe impl<'a> glib::value::FromValue<'a> for BackendFlags { + type Checker = glib::value::GenericValueTypeChecker<Self>; + + #[inline] + unsafe fn from_value(value: &'a glib::Value) -> Self { + from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) + } +} + +#[cfg(feature = "v0_19")] +#[cfg_attr(docsrs, doc(cfg(feature = "v0_19")))] +impl ToValue for BackendFlags { + #[inline] + fn to_value(&self) -> glib::Value { + let mut value = glib::Value::for_value_type::<Self>(); + unsafe { + glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); + } + value + } + + #[inline] + fn value_type(&self) -> glib::Type { + Self::static_type() + } +} + +#[cfg(feature = "v0_19")] +#[cfg_attr(docsrs, doc(cfg(feature = "v0_19")))] +impl From<BackendFlags> for glib::Value { + #[inline] + fn from(v: BackendFlags) -> Self { + ToValue::to_value(&v) + } +} + +#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] +#[non_exhaustive] +#[doc(alias = "SecretError")] +pub enum Error { + #[doc(alias = "SECRET_ERROR_PROTOCOL")] + Protocol, + #[doc(alias = "SECRET_ERROR_IS_LOCKED")] + IsLocked, + #[doc(alias = "SECRET_ERROR_NO_SUCH_OBJECT")] + NoSuchObject, + #[doc(alias = "SECRET_ERROR_ALREADY_EXISTS")] + AlreadyExists, + #[doc(alias = "SECRET_ERROR_INVALID_FILE_FORMAT")] + InvalidFileFormat, + #[cfg(feature = "v0_21_2")] + #[cfg_attr(docsrs, doc(cfg(feature = "v0_21_2")))] + #[doc(alias = "SECRET_ERROR_MISMATCHED_SCHEMA")] + MismatchedSchema, + #[cfg(feature = "v0_21_2")] + #[cfg_attr(docsrs, doc(cfg(feature = "v0_21_2")))] + #[doc(alias = "SECRET_ERROR_NO_MATCHING_ATTRIBUTE")] + NoMatchingAttribute, + #[cfg(feature = "v0_21_2")] + #[cfg_attr(docsrs, doc(cfg(feature = "v0_21_2")))] + #[doc(alias = "SECRET_ERROR_WRONG_TYPE")] + WrongType, + #[cfg(feature = "v0_21_2")] + #[cfg_attr(docsrs, doc(cfg(feature = "v0_21_2")))] + #[doc(alias = "SECRET_ERROR_EMPTY_TABLE")] + EmptyTable, + #[doc(hidden)] + __Unknown(i32), +} + +#[doc(hidden)] +impl IntoGlib for Error { + type GlibType = ffi::SecretError; + + #[inline] + fn into_glib(self) -> ffi::SecretError { + match self { + Self::Protocol => ffi::SECRET_ERROR_PROTOCOL, + Self::IsLocked => ffi::SECRET_ERROR_IS_LOCKED, + Self::NoSuchObject => ffi::SECRET_ERROR_NO_SUCH_OBJECT, + Self::AlreadyExists => ffi::SECRET_ERROR_ALREADY_EXISTS, + Self::InvalidFileFormat => ffi::SECRET_ERROR_INVALID_FILE_FORMAT, + #[cfg(feature = "v0_21_2")] + Self::MismatchedSchema => ffi::SECRET_ERROR_MISMATCHED_SCHEMA, + #[cfg(feature = "v0_21_2")] + Self::NoMatchingAttribute => ffi::SECRET_ERROR_NO_MATCHING_ATTRIBUTE, + #[cfg(feature = "v0_21_2")] + Self::WrongType => ffi::SECRET_ERROR_WRONG_TYPE, + #[cfg(feature = "v0_21_2")] + Self::EmptyTable => ffi::SECRET_ERROR_EMPTY_TABLE, + Self::__Unknown(value) => value, + } + } +} + +#[doc(hidden)] +impl FromGlib<ffi::SecretError> for Error { + #[inline] + unsafe fn from_glib(value: ffi::SecretError) -> Self { + match value { + ffi::SECRET_ERROR_PROTOCOL => Self::Protocol, + ffi::SECRET_ERROR_IS_LOCKED => Self::IsLocked, + ffi::SECRET_ERROR_NO_SUCH_OBJECT => Self::NoSuchObject, + ffi::SECRET_ERROR_ALREADY_EXISTS => Self::AlreadyExists, + ffi::SECRET_ERROR_INVALID_FILE_FORMAT => Self::InvalidFileFormat, + #[cfg(feature = "v0_21_2")] + ffi::SECRET_ERROR_MISMATCHED_SCHEMA => Self::MismatchedSchema, + #[cfg(feature = "v0_21_2")] + ffi::SECRET_ERROR_NO_MATCHING_ATTRIBUTE => Self::NoMatchingAttribute, + #[cfg(feature = "v0_21_2")] + ffi::SECRET_ERROR_WRONG_TYPE => Self::WrongType, + #[cfg(feature = "v0_21_2")] + ffi::SECRET_ERROR_EMPTY_TABLE => Self::EmptyTable, + value => Self::__Unknown(value), + } + } +} + +impl StaticType for Error { + #[inline] + #[doc(alias = "secret_error_get_type")] + fn static_type() -> glib::Type { + unsafe { from_glib(ffi::secret_error_get_type()) } + } +} + +impl glib::HasParamSpec for Error { + type ParamSpec = glib::ParamSpecEnum; + type SetValue = Self; + type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>; + + fn param_spec_builder() -> Self::BuilderFn { + Self::ParamSpec::builder_with_default + } +} + +impl glib::value::ValueType for Error { + type Type = Self; +} + +unsafe impl<'a> glib::value::FromValue<'a> for Error { + type Checker = glib::value::GenericValueTypeChecker<Self>; + + #[inline] + unsafe fn from_value(value: &'a glib::Value) -> Self { + from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) + } +} + +impl ToValue for Error { + #[inline] + fn to_value(&self) -> glib::Value { + let mut value = glib::Value::for_value_type::<Self>(); + unsafe { + glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); + } + value + } + + #[inline] + fn value_type(&self) -> glib::Type { + Self::static_type() + } +} + +impl From<Error> for glib::Value { + #[inline] + fn from(v: Error) -> Self { + ToValue::to_value(&v) + } +} + +#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] +#[non_exhaustive] +#[doc(alias = "SecretSchemaAttributeType")] +pub enum SchemaAttributeType { + #[doc(alias = "SECRET_SCHEMA_ATTRIBUTE_STRING")] + String, + #[doc(alias = "SECRET_SCHEMA_ATTRIBUTE_INTEGER")] + Integer, + #[doc(alias = "SECRET_SCHEMA_ATTRIBUTE_BOOLEAN")] + Boolean, + #[doc(hidden)] + __Unknown(i32), +} + +#[doc(hidden)] +impl IntoGlib for SchemaAttributeType { + type GlibType = ffi::SecretSchemaAttributeType; + + #[inline] + fn into_glib(self) -> ffi::SecretSchemaAttributeType { + match self { + Self::String => ffi::SECRET_SCHEMA_ATTRIBUTE_STRING, + Self::Integer => ffi::SECRET_SCHEMA_ATTRIBUTE_INTEGER, + Self::Boolean => ffi::SECRET_SCHEMA_ATTRIBUTE_BOOLEAN, + Self::__Unknown(value) => value, + } + } +} + +#[doc(hidden)] +impl FromGlib<ffi::SecretSchemaAttributeType> for SchemaAttributeType { + #[inline] + unsafe fn from_glib(value: ffi::SecretSchemaAttributeType) -> Self { + match value { + ffi::SECRET_SCHEMA_ATTRIBUTE_STRING => Self::String, + ffi::SECRET_SCHEMA_ATTRIBUTE_INTEGER => Self::Integer, + ffi::SECRET_SCHEMA_ATTRIBUTE_BOOLEAN => Self::Boolean, + value => Self::__Unknown(value), + } + } +} + +impl StaticType for SchemaAttributeType { + #[inline] + #[doc(alias = "secret_schema_attribute_type_get_type")] + fn static_type() -> glib::Type { + unsafe { from_glib(ffi::secret_schema_attribute_type_get_type()) } + } +} + +impl glib::HasParamSpec for SchemaAttributeType { + type ParamSpec = glib::ParamSpecEnum; + type SetValue = Self; + type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>; + + fn param_spec_builder() -> Self::BuilderFn { + Self::ParamSpec::builder_with_default + } +} + +impl glib::value::ValueType for SchemaAttributeType { + type Type = Self; +} + +unsafe impl<'a> glib::value::FromValue<'a> for SchemaAttributeType { + type Checker = glib::value::GenericValueTypeChecker<Self>; + + #[inline] + unsafe fn from_value(value: &'a glib::Value) -> Self { + from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) + } +} + +impl ToValue for SchemaAttributeType { + #[inline] + fn to_value(&self) -> glib::Value { + let mut value = glib::Value::for_value_type::<Self>(); + unsafe { + glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); + } + value + } + + #[inline] + fn value_type(&self) -> glib::Type { + Self::static_type() + } +} + +impl From<SchemaAttributeType> for glib::Value { + #[inline] + fn from(v: SchemaAttributeType) -> Self { + ToValue::to_value(&v) + } +} + +#[cfg(feature = "v0_18_6")] +#[cfg_attr(docsrs, doc(cfg(feature = "v0_18_6")))] +#[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] +#[non_exhaustive] +#[doc(alias = "SecretSchemaType")] +pub enum SchemaType { + #[doc(alias = "SECRET_SCHEMA_TYPE_NOTE")] + Note, + #[doc(alias = "SECRET_SCHEMA_TYPE_COMPAT_NETWORK")] + CompatNetwork, + #[doc(hidden)] + __Unknown(i32), +} + +#[cfg(feature = "v0_18_6")] +#[cfg_attr(docsrs, doc(cfg(feature = "v0_18_6")))] +#[doc(hidden)] +impl IntoGlib for SchemaType { + type GlibType = ffi::SecretSchemaType; + + #[inline] + fn into_glib(self) -> ffi::SecretSchemaType { + match self { + Self::Note => ffi::SECRET_SCHEMA_TYPE_NOTE, + Self::CompatNetwork => ffi::SECRET_SCHEMA_TYPE_COMPAT_NETWORK, + Self::__Unknown(value) => value, + } + } +} + +#[cfg(feature = "v0_18_6")] +#[cfg_attr(docsrs, doc(cfg(feature = "v0_18_6")))] +#[doc(hidden)] +impl FromGlib<ffi::SecretSchemaType> for SchemaType { + #[inline] + unsafe fn from_glib(value: ffi::SecretSchemaType) -> Self { + match value { + ffi::SECRET_SCHEMA_TYPE_NOTE => Self::Note, + ffi::SECRET_SCHEMA_TYPE_COMPAT_NETWORK => Self::CompatNetwork, + value => Self::__Unknown(value), + } + } +} + +#[cfg(feature = "v0_18_6")] +#[cfg_attr(docsrs, doc(cfg(feature = "v0_18_6")))] +impl StaticType for SchemaType { + #[inline] + #[doc(alias = "secret_schema_type_get_type")] + fn static_type() -> glib::Type { + unsafe { from_glib(ffi::secret_schema_type_get_type()) } + } +} + +#[cfg(feature = "v0_18_6")] +#[cfg_attr(docsrs, doc(cfg(feature = "v0_18_6")))] +impl glib::HasParamSpec for SchemaType { + type ParamSpec = glib::ParamSpecEnum; + type SetValue = Self; + type BuilderFn = fn(&str, Self) -> glib::ParamSpecEnumBuilder<Self>; + + fn param_spec_builder() -> Self::BuilderFn { + Self::ParamSpec::builder_with_default + } +} + +#[cfg(feature = "v0_18_6")] +#[cfg_attr(docsrs, doc(cfg(feature = "v0_18_6")))] +impl glib::value::ValueType for SchemaType { + type Type = Self; +} + +#[cfg(feature = "v0_18_6")] +#[cfg_attr(docsrs, doc(cfg(feature = "v0_18_6")))] +unsafe impl<'a> glib::value::FromValue<'a> for SchemaType { + type Checker = glib::value::GenericValueTypeChecker<Self>; + + #[inline] + unsafe fn from_value(value: &'a glib::Value) -> Self { + from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) + } +} + +#[cfg(feature = "v0_18_6")] +#[cfg_attr(docsrs, doc(cfg(feature = "v0_18_6")))] +impl ToValue for SchemaType { + #[inline] + fn to_value(&self) -> glib::Value { + let mut value = glib::Value::for_value_type::<Self>(); + unsafe { + glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); + } + value + } + + #[inline] + fn value_type(&self) -> glib::Type { + Self::static_type() + } +} + +#[cfg(feature = "v0_18_6")] +#[cfg_attr(docsrs, doc(cfg(feature = "v0_18_6")))] +impl From<SchemaType> for glib::Value { + #[inline] + fn from(v: SchemaType) -> Self { + ToValue::to_value(&v) + } +} diff --git a/libsecret/src/auto/flags.rs b/libsecret/src/auto/flags.rs new file mode 100644 index 0000000..81c0f71 --- /dev/null +++ b/libsecret/src/auto/flags.rs @@ -0,0 +1,591 @@ +// This file was generated by gir (https://github.com/gtk-rs/gir) +// from +// from gir-files (https://github.com/gtk-rs/gir-files.git) +// DO NOT EDIT + +use glib::{bitflags::bitflags, prelude::*, translate::*}; + +bitflags! { + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] + #[doc(alias = "SecretCollectionCreateFlags")] + pub struct CollectionCreateFlags: u32 { + #[doc(alias = "SECRET_COLLECTION_CREATE_NONE")] + const NONE = ffi::SECRET_COLLECTION_CREATE_NONE as _; + } +} + +#[doc(hidden)] +impl IntoGlib for CollectionCreateFlags { + type GlibType = ffi::SecretCollectionCreateFlags; + + #[inline] + fn into_glib(self) -> ffi::SecretCollectionCreateFlags { + self.bits() + } +} + +#[doc(hidden)] +impl FromGlib<ffi::SecretCollectionCreateFlags> for CollectionCreateFlags { + #[inline] + unsafe fn from_glib(value: ffi::SecretCollectionCreateFlags) -> Self { + Self::from_bits_truncate(value) + } +} + +impl StaticType for CollectionCreateFlags { + #[inline] + #[doc(alias = "secret_collection_create_flags_get_type")] + fn static_type() -> glib::Type { + unsafe { from_glib(ffi::secret_collection_create_flags_get_type()) } + } +} + +impl glib::HasParamSpec for CollectionCreateFlags { + type ParamSpec = glib::ParamSpecFlags; + type SetValue = Self; + type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>; + + fn param_spec_builder() -> Self::BuilderFn { + Self::ParamSpec::builder + } +} + +impl glib::value::ValueType for CollectionCreateFlags { + type Type = Self; +} + +unsafe impl<'a> glib::value::FromValue<'a> for CollectionCreateFlags { + type Checker = glib::value::GenericValueTypeChecker<Self>; + + #[inline] + unsafe fn from_value(value: &'a glib::Value) -> Self { + from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) + } +} + +impl ToValue for CollectionCreateFlags { + #[inline] + fn to_value(&self) -> glib::Value { + let mut value = glib::Value::for_value_type::<Self>(); + unsafe { + glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib()); + } + value + } + + #[inline] + fn value_type(&self) -> glib::Type { + Self::static_type() + } +} + +impl From<CollectionCreateFlags> for glib::Value { + #[inline] + fn from(v: CollectionCreateFlags) -> Self { + ToValue::to_value(&v) + } +} + +bitflags! { + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] + #[doc(alias = "SecretCollectionFlags")] + pub struct CollectionFlags: u32 { + #[doc(alias = "SECRET_COLLECTION_NONE")] + const NONE = ffi::SECRET_COLLECTION_NONE as _; + #[doc(alias = "SECRET_COLLECTION_LOAD_ITEMS")] + const LOAD_ITEMS = ffi::SECRET_COLLECTION_LOAD_ITEMS as _; + } +} + +#[doc(hidden)] +impl IntoGlib for CollectionFlags { + type GlibType = ffi::SecretCollectionFlags; + + #[inline] + fn into_glib(self) -> ffi::SecretCollectionFlags { + self.bits() + } +} + +#[doc(hidden)] +impl FromGlib<ffi::SecretCollectionFlags> for CollectionFlags { + #[inline] + unsafe fn from_glib(value: ffi::SecretCollectionFlags) -> Self { + Self::from_bits_truncate(value) + } +} + +impl StaticType for CollectionFlags { + #[inline] + #[doc(alias = "secret_collection_flags_get_type")] + fn static_type() -> glib::Type { + unsafe { from_glib(ffi::secret_collection_flags_get_type()) } + } +} + +impl glib::HasParamSpec for CollectionFlags { + type ParamSpec = glib::ParamSpecFlags; + type SetValue = Self; + type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>; + + fn param_spec_builder() -> Self::BuilderFn { + Self::ParamSpec::builder + } +} + +impl glib::value::ValueType for CollectionFlags { + type Type = Self; +} + +unsafe impl<'a> glib::value::FromValue<'a> for CollectionFlags { + type Checker = glib::value::GenericValueTypeChecker<Self>; + + #[inline] + unsafe fn from_value(value: &'a glib::Value) -> Self { + from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) + } +} + +impl ToValue for CollectionFlags { + #[inline] + fn to_value(&self) -> glib::Value { + let mut value = glib::Value::for_value_type::<Self>(); + unsafe { + glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib()); + } + value + } + + #[inline] + fn value_type(&self) -> glib::Type { + Self::static_type() + } +} + +impl From<CollectionFlags> for glib::Value { + #[inline] + fn from(v: CollectionFlags) -> Self { + ToValue::to_value(&v) + } +} + +bitflags! { + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] + #[doc(alias = "SecretItemCreateFlags")] + pub struct ItemCreateFlags: u32 { + #[doc(alias = "SECRET_ITEM_CREATE_NONE")] + const NONE = ffi::SECRET_ITEM_CREATE_NONE as _; + #[doc(alias = "SECRET_ITEM_CREATE_REPLACE")] + const REPLACE = ffi::SECRET_ITEM_CREATE_REPLACE as _; + } +} + +#[doc(hidden)] +impl IntoGlib for ItemCreateFlags { + type GlibType = ffi::SecretItemCreateFlags; + + #[inline] + fn into_glib(self) -> ffi::SecretItemCreateFlags { + self.bits() + } +} + +#[doc(hidden)] +impl FromGlib<ffi::SecretItemCreateFlags> for ItemCreateFlags { + #[inline] + unsafe fn from_glib(value: ffi::SecretItemCreateFlags) -> Self { + Self::from_bits_truncate(value) + } +} + +impl StaticType for ItemCreateFlags { + #[inline] + #[doc(alias = "secret_item_create_flags_get_type")] + fn static_type() -> glib::Type { + unsafe { from_glib(ffi::secret_item_create_flags_get_type()) } + } +} + +impl glib::HasParamSpec for ItemCreateFlags { + type ParamSpec = glib::ParamSpecFlags; + type SetValue = Self; + type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>; + + fn param_spec_builder() -> Self::BuilderFn { + Self::ParamSpec::builder + } +} + +impl glib::value::ValueType for ItemCreateFlags { + type Type = Self; +} + +unsafe impl<'a> glib::value::FromValue<'a> for ItemCreateFlags { + type Checker = glib::value::GenericValueTypeChecker<Self>; + + #[inline] + unsafe fn from_value(value: &'a glib::Value) -> Self { + from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) + } +} + +impl ToValue for ItemCreateFlags { + #[inline] + fn to_value(&self) -> glib::Value { + let mut value = glib::Value::for_value_type::<Self>(); + unsafe { + glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib()); + } + value + } + + #[inline] + fn value_type(&self) -> glib::Type { + Self::static_type() + } +} + +impl From<ItemCreateFlags> for glib::Value { + #[inline] + fn from(v: ItemCreateFlags) -> Self { + ToValue::to_value(&v) + } +} + +bitflags! { + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] + #[doc(alias = "SecretItemFlags")] + pub struct ItemFlags: u32 { + #[doc(alias = "SECRET_ITEM_NONE")] + const NONE = ffi::SECRET_ITEM_NONE as _; + #[doc(alias = "SECRET_ITEM_LOAD_SECRET")] + const LOAD_SECRET = ffi::SECRET_ITEM_LOAD_SECRET as _; + } +} + +#[doc(hidden)] +impl IntoGlib for ItemFlags { + type GlibType = ffi::SecretItemFlags; + + #[inline] + fn into_glib(self) -> ffi::SecretItemFlags { + self.bits() + } +} + +#[doc(hidden)] +impl FromGlib<ffi::SecretItemFlags> for ItemFlags { + #[inline] + unsafe fn from_glib(value: ffi::SecretItemFlags) -> Self { + Self::from_bits_truncate(value) + } +} + +impl StaticType for ItemFlags { + #[inline] + #[doc(alias = "secret_item_flags_get_type")] + fn static_type() -> glib::Type { + unsafe { from_glib(ffi::secret_item_flags_get_type()) } + } +} + +impl glib::HasParamSpec for ItemFlags { + type ParamSpec = glib::ParamSpecFlags; + type SetValue = Self; + type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>; + + fn param_spec_builder() -> Self::BuilderFn { + Self::ParamSpec::builder + } +} + +impl glib::value::ValueType for ItemFlags { + type Type = Self; +} + +unsafe impl<'a> glib::value::FromValue<'a> for ItemFlags { + type Checker = glib::value::GenericValueTypeChecker<Self>; + + #[inline] + unsafe fn from_value(value: &'a glib::Value) -> Self { + from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) + } +} + +impl ToValue for ItemFlags { + #[inline] + fn to_value(&self) -> glib::Value { + let mut value = glib::Value::for_value_type::<Self>(); + unsafe { + glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib()); + } + value + } + + #[inline] + fn value_type(&self) -> glib::Type { + Self::static_type() + } +} + +impl From<ItemFlags> for glib::Value { + #[inline] + fn from(v: ItemFlags) -> Self { + ToValue::to_value(&v) + } +} + +bitflags! { + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] + #[doc(alias = "SecretSchemaFlags")] + pub struct SchemaFlags: u32 { + #[doc(alias = "SECRET_SCHEMA_NONE")] + const NONE = ffi::SECRET_SCHEMA_NONE as _; + #[doc(alias = "SECRET_SCHEMA_DONT_MATCH_NAME")] + const DONT_MATCH_NAME = ffi::SECRET_SCHEMA_DONT_MATCH_NAME as _; + } +} + +#[doc(hidden)] +impl IntoGlib for SchemaFlags { + type GlibType = ffi::SecretSchemaFlags; + + #[inline] + fn into_glib(self) -> ffi::SecretSchemaFlags { + self.bits() + } +} + +#[doc(hidden)] +impl FromGlib<ffi::SecretSchemaFlags> for SchemaFlags { + #[inline] + unsafe fn from_glib(value: ffi::SecretSchemaFlags) -> Self { + Self::from_bits_truncate(value) + } +} + +impl StaticType for SchemaFlags { + #[inline] + #[doc(alias = "secret_schema_flags_get_type")] + fn static_type() -> glib::Type { + unsafe { from_glib(ffi::secret_schema_flags_get_type()) } + } +} + +impl glib::HasParamSpec for SchemaFlags { + type ParamSpec = glib::ParamSpecFlags; + type SetValue = Self; + type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>; + + fn param_spec_builder() -> Self::BuilderFn { + Self::ParamSpec::builder + } +} + +impl glib::value::ValueType for SchemaFlags { + type Type = Self; +} + +unsafe impl<'a> glib::value::FromValue<'a> for SchemaFlags { + type Checker = glib::value::GenericValueTypeChecker<Self>; + + #[inline] + unsafe fn from_value(value: &'a glib::Value) -> Self { + from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) + } +} + +impl ToValue for SchemaFlags { + #[inline] + fn to_value(&self) -> glib::Value { + let mut value = glib::Value::for_value_type::<Self>(); + unsafe { + glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib()); + } + value + } + + #[inline] + fn value_type(&self) -> glib::Type { + Self::static_type() + } +} + +impl From<SchemaFlags> for glib::Value { + #[inline] + fn from(v: SchemaFlags) -> Self { + ToValue::to_value(&v) + } +} + +bitflags! { + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] + #[doc(alias = "SecretSearchFlags")] + pub struct SearchFlags: u32 { + #[doc(alias = "SECRET_SEARCH_NONE")] + const NONE = ffi::SECRET_SEARCH_NONE as _; + #[doc(alias = "SECRET_SEARCH_ALL")] + const ALL = ffi::SECRET_SEARCH_ALL as _; + #[doc(alias = "SECRET_SEARCH_UNLOCK")] + const UNLOCK = ffi::SECRET_SEARCH_UNLOCK as _; + #[doc(alias = "SECRET_SEARCH_LOAD_SECRETS")] + const LOAD_SECRETS = ffi::SECRET_SEARCH_LOAD_SECRETS as _; + } +} + +#[doc(hidden)] +impl IntoGlib for SearchFlags { + type GlibType = ffi::SecretSearchFlags; + + #[inline] + fn into_glib(self) -> ffi::SecretSearchFlags { + self.bits() + } +} + +#[doc(hidden)] +impl FromGlib<ffi::SecretSearchFlags> for SearchFlags { + #[inline] + unsafe fn from_glib(value: ffi::SecretSearchFlags) -> Self { + Self::from_bits_truncate(value) + } +} + +impl StaticType for SearchFlags { + #[inline] + #[doc(alias = "secret_search_flags_get_type")] + fn static_type() -> glib::Type { + unsafe { from_glib(ffi::secret_search_flags_get_type()) } + } +} + +impl glib::HasParamSpec for SearchFlags { + type ParamSpec = glib::ParamSpecFlags; + type SetValue = Self; + type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>; + + fn param_spec_builder() -> Self::BuilderFn { + Self::ParamSpec::builder + } +} + +impl glib::value::ValueType for SearchFlags { + type Type = Self; +} + +unsafe impl<'a> glib::value::FromValue<'a> for SearchFlags { + type Checker = glib::value::GenericValueTypeChecker<Self>; + + #[inline] + unsafe fn from_value(value: &'a glib::Value) -> Self { + from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) + } +} + +impl ToValue for SearchFlags { + #[inline] + fn to_value(&self) -> glib::Value { + let mut value = glib::Value::for_value_type::<Self>(); + unsafe { + glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib()); + } + value + } + + #[inline] + fn value_type(&self) -> glib::Type { + Self::static_type() + } +} + +impl From<SearchFlags> for glib::Value { + #[inline] + fn from(v: SearchFlags) -> Self { + ToValue::to_value(&v) + } +} + +bitflags! { + #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] + #[doc(alias = "SecretServiceFlags")] + pub struct ServiceFlags: u32 { + #[doc(alias = "SECRET_SERVICE_NONE")] + const NONE = ffi::SECRET_SERVICE_NONE as _; + #[doc(alias = "SECRET_SERVICE_OPEN_SESSION")] + const OPEN_SESSION = ffi::SECRET_SERVICE_OPEN_SESSION as _; + #[doc(alias = "SECRET_SERVICE_LOAD_COLLECTIONS")] + const LOAD_COLLECTIONS = ffi::SECRET_SERVICE_LOAD_COLLECTIONS as _; + } +} + +#[doc(hidden)] +impl IntoGlib for ServiceFlags { + type GlibType = ffi::SecretServiceFlags; + + #[inline] + fn into_glib(self) -> ffi::SecretServiceFlags { + self.bits() + } +} + +#[doc(hidden)] +impl FromGlib<ffi::SecretServiceFlags> for ServiceFlags { + #[inline] + unsafe fn from_glib(value: ffi::SecretServiceFlags) -> Self { + Self::from_bits_truncate(value) + } +} + +impl StaticType for ServiceFlags { + #[inline] + #[doc(alias = "secret_service_flags_get_type")] + fn static_type() -> glib::Type { + unsafe { from_glib(ffi::secret_service_flags_get_type()) } + } +} + +impl glib::HasParamSpec for ServiceFlags { + type ParamSpec = glib::ParamSpecFlags; + type SetValue = Self; + type BuilderFn = fn(&str) -> glib::ParamSpecFlagsBuilder<Self>; + + fn param_spec_builder() -> Self::BuilderFn { + Self::ParamSpec::builder + } +} + +impl glib::value::ValueType for ServiceFlags { + type Type = Self; +} + +unsafe impl<'a> glib::value::FromValue<'a> for ServiceFlags { + type Checker = glib::value::GenericValueTypeChecker<Self>; + + #[inline] + unsafe fn from_value(value: &'a glib::Value) -> Self { + from_glib(glib::gobject_ffi::g_value_get_flags(value.to_glib_none().0)) + } +} + +impl ToValue for ServiceFlags { + #[inline] + fn to_value(&self) -> glib::Value { + let mut value = glib::Value::for_value_type::<Self>(); + unsafe { + glib::gobject_ffi::g_value_set_flags(value.to_glib_none_mut().0, self.into_glib()); + } + value + } + + #[inline] + fn value_type(&self) -> glib::Type { + Self::static_type() + } +} + +impl From<ServiceFlags> for glib::Value { + #[inline] + fn from(v: ServiceFlags) -> Self { + ToValue::to_value(&v) + } +} diff --git a/libsecret/src/auto/functions.rs b/libsecret/src/auto/functions.rs new file mode 100644 index 0000000..173139f --- /dev/null +++ b/libsecret/src/auto/functions.rs @@ -0,0 +1,41 @@ +// This file was generated by gir (https://github.com/gtk-rs/gir) +// from +// from gir-files (https://github.com/gtk-rs/gir-files.git) +// DO NOT EDIT + +#[cfg(feature = "v0_19")] +#[cfg_attr(docsrs, doc(cfg(feature = "v0_19")))] +use crate::{Retrievable, Value}; +#[cfg(feature = "v0_18_6")] +#[cfg_attr(docsrs, doc(cfg(feature = "v0_18_6")))] +use crate::{Schema, SchemaType}; +use glib::{prelude::*, translate::*}; + +//#[cfg(feature = "v0_21_2")] +//#[cfg_attr(docsrs, doc(cfg(feature = "v0_21_2")))] +//#[doc(alias = "secret_attributes_validate")] +//pub fn attributes_validate(schema: &Schema, attributes: /*Unknown conversion*//*Unimplemented*/HashTable TypeId { ns_id: 0, id: 25 }/TypeId { ns_id: 0, id: 25 }) -> Result<(), glib::Error> { +// unsafe { TODO: call ffi:secret_attributes_validate() } +//} + +#[cfg(feature = "v0_18_6")] +#[cfg_attr(docsrs, doc(cfg(feature = "v0_18_6")))] +#[doc(alias = "secret_get_schema")] +#[doc(alias = "get_schema")] +pub fn schema(type_: SchemaType) -> Schema { + unsafe { from_glib_none(ffi::secret_get_schema(type_.into_glib())) } +} + +#[doc(alias = "secret_password_free")] +pub fn password_free(password: Option<&str>) { + unsafe { + ffi::secret_password_free(password.to_glib_none().0); + } +} + +#[doc(alias = "secret_password_wipe")] +pub fn password_wipe(password: Option<&str>) { + unsafe { + ffi::secret_password_wipe(password.to_glib_none().0); + } +} diff --git a/libsecret/src/auto/item.rs b/libsecret/src/auto/item.rs new file mode 100644 index 0000000..5fb03e6 --- /dev/null +++ b/libsecret/src/auto/item.rs @@ -0,0 +1,556 @@ +// This file was generated by gir (https://github.com/gtk-rs/gir) +// from +// from gir-files (https://github.com/gtk-rs/gir-files.git) +// DO NOT EDIT + +#[cfg(feature = "v0_19")] +#[cfg_attr(docsrs, doc(cfg(feature = "v0_19")))] +use crate::Retrievable; +use crate::{ItemFlags, Service, Value}; +use glib::{ + prelude::*, + signal::{connect_raw, SignalHandlerId}, + translate::*, +}; +use std::{boxed::Box as Box_, pin::Pin}; + +#[cfg(feature = "v0_19")] +#[cfg_attr(docsrs, doc(cfg(feature = "v0_19")))] +glib::wrapper! { + #[doc(alias = "SecretItem")] + pub struct Item(Object<ffi::SecretItem, ffi::SecretItemClass>) @extends gio::DBusProxy, @implements gio::DBusInterface, gio::Initable, Retrievable; + + match fn { + type_ => || ffi::secret_item_get_type(), + } +} + +#[cfg(not(any(feature = "v0_19")))] +glib::wrapper! { + #[doc(alias = "SecretItem")] + pub struct Item(Object<ffi::SecretItem, ffi::SecretItemClass>) @extends gio::DBusProxy, @implements gio::DBusInterface, gio::Initable; + + match fn { + type_ => || ffi::secret_item_get_type(), + } +} + +impl Item { + pub const NONE: Option<&'static Item> = None; + + #[doc(alias = "secret_item_new_for_dbus_path_sync")] + #[doc(alias = "new_for_dbus_path_sync")] + pub fn for_dbus_path_sync( + service: Option<&impl IsA<Service>>, + item_path: &str, + flags: ItemFlags, + cancellable: Option<&impl IsA<gio::Cancellable>>, + ) -> Result<Item, glib::Error> { + unsafe { + let mut error = std::ptr::null_mut(); + let ret = ffi::secret_item_new_for_dbus_path_sync( + service.map(|p| p.as_ref()).to_glib_none().0, + item_path.to_glib_none().0, + flags.into_glib(), + cancellable.map(|p| p.as_ref()).to_glib_none().0, + &mut error, + ); + if error.is_null() { + Ok(from_glib_full(ret)) + } else { + Err(from_glib_full(error)) + } + } + } + + #[doc(alias = "secret_item_new_for_dbus_path")] + pub fn new_for_dbus_path<P: FnOnce(Result<Item, glib::Error>) + 'static>( + service: Option<&impl IsA<Service>>, + item_path: &str, + flags: ItemFlags, + cancellable: Option<&impl IsA<gio::Cancellable>>, + callback: P, + ) { + let main_context = glib::MainContext::ref_thread_default(); + let is_main_context_owner = main_context.is_owner(); + let has_acquired_main_context = (!is_main_context_owner) + .then(|| main_context.acquire().ok()) + .flatten(); + assert!( + is_main_context_owner || has_acquired_main_context.is_some(), + "Async operations only allowed if the thread is owning the MainContext" + ); + + let user_data: Box_<glib::thread_guard::ThreadGuard<P>> = + Box_::new(glib::thread_guard::ThreadGuard::new(callback)); + unsafe extern "C" fn new_for_dbus_path_trampoline< + P: FnOnce(Result<Item, glib::Error>) + 'static, + >( + _source_object: *mut glib::gobject_ffi::GObject, + res: *mut gio::ffi::GAsyncResult, + user_data: glib::ffi::gpointer, + ) { + let mut error = std::ptr::null_mut(); + let ret = ffi::secret_item_new_for_dbus_path_finish(res, &mut error); + let result = if error.is_null() { + Ok(from_glib_full(ret)) + } else { + Err(from_glib_full(error)) + }; + 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 = new_for_dbus_path_trampoline::<P>; + unsafe { + ffi::secret_item_new_for_dbus_path( + service.map(|p| p.as_ref()).to_glib_none().0, + item_path.to_glib_none().0, + flags.into_glib(), + cancellable.map(|p| p.as_ref()).to_glib_none().0, + Some(callback), + Box_::into_raw(user_data) as *mut _, + ); + } + } + + pub fn new_for_dbus_path_future( + service: Option<&(impl IsA<Service> + Clone + 'static)>, + item_path: &str, + flags: ItemFlags, + ) -> Pin<Box_<dyn std::future::Future<Output = Result<Item, glib::Error>> + 'static>> { + let service = service.map(ToOwned::to_owned); + let item_path = String::from(item_path); + Box_::pin(gio::GioFuture::new(&(), move |_obj, cancellable, send| { + Self::new_for_dbus_path( + service.as_ref().map(::std::borrow::Borrow::borrow), + &item_path, + flags, + Some(cancellable), + move |res| { + send.resolve(res); + }, + ); + })) + } +} + +mod sealed { + pub trait Sealed {} + impl<T: super::IsA<super::Item>> Sealed for T {} +} + +pub trait ItemExt: IsA<Item> + sealed::Sealed + 'static { + #[doc(alias = "secret_item_delete")] + fn delete<P: FnOnce(Result<(), glib::Error>) + 'static>( + &self, + cancellable: Option<&impl IsA<gio::Cancellable>>, + callback: P, + ) { + let main_context = glib::MainContext::ref_thread_default(); + let is_main_context_owner = main_context.is_owner(); + let has_acquired_main_context = (!is_main_context_owner) + .then(|| main_context.acquire().ok()) + .flatten(); + assert!( + is_main_context_owner || has_acquired_main_context.is_some(), + "Async operations only allowed if the thread is owning the MainContext" + ); + + let user_data: Box_<glib::thread_guard::ThreadGuard<P>> = + Box_::new(glib::thread_guard::ThreadGuard::new(callback)); + unsafe extern "C" fn delete_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 = std::ptr::null_mut(); + let _ = ffi::secret_item_delete_finish(_source_object as *mut _, res, &mut error); + let result = if error.is_null() { + Ok(()) + } else { + Err(from_glib_full(error)) + }; + 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 = delete_trampoline::<P>; + unsafe { + ffi::secret_item_delete( + self.as_ref().to_glib_none().0, + cancellable.map(|p| p.as_ref()).to_glib_none().0, + Some(callback), + Box_::into_raw(user_data) as *mut _, + ); + } + } + + fn delete_future( + &self, + ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> { + Box_::pin(gio::GioFuture::new(self, move |obj, cancellable, send| { + obj.delete(Some(cancellable), move |res| { + send.resolve(res); + }); + })) + } + + #[doc(alias = "secret_item_delete_sync")] + fn delete_sync( + &self, + cancellable: Option<&impl IsA<gio::Cancellable>>, + ) -> Result<(), glib::Error> { + unsafe { + let mut error = std::ptr::null_mut(); + let is_ok = ffi::secret_item_delete_sync( + self.as_ref().to_glib_none().0, + cancellable.map(|p| p.as_ref()).to_glib_none().0, + &mut error, + ); + debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null()); + if error.is_null() { + Ok(()) + } else { + Err(from_glib_full(error)) + } + } + } + + #[cfg(not(feature = "v0_19"))] + #[cfg_attr(docsrs, doc(cfg(not(feature = "v0_19"))))] + #[doc(alias = "secret_item_get_created")] + #[doc(alias = "get_created")] + fn created(&self) -> u64 { + unsafe { ffi::secret_item_get_created(self.as_ref().to_glib_none().0) } + } + + #[doc(alias = "secret_item_get_flags")] + #[doc(alias = "get_flags")] + fn flags(&self) -> ItemFlags { + unsafe { from_glib(ffi::secret_item_get_flags(self.as_ref().to_glib_none().0)) } + } + + #[cfg(not(feature = "v0_19"))] + #[cfg_attr(docsrs, doc(cfg(not(feature = "v0_19"))))] + #[doc(alias = "secret_item_get_label")] + #[doc(alias = "get_label")] + fn label(&self) -> glib::GString { + unsafe { from_glib_full(ffi::secret_item_get_label(self.as_ref().to_glib_none().0)) } + } + + #[doc(alias = "secret_item_get_locked")] + #[doc(alias = "get_locked")] + fn is_locked(&self) -> bool { + unsafe { from_glib(ffi::secret_item_get_locked(self.as_ref().to_glib_none().0)) } + } + + #[cfg(not(feature = "v0_19"))] + #[cfg_attr(docsrs, doc(cfg(not(feature = "v0_19"))))] + #[doc(alias = "secret_item_get_modified")] + #[doc(alias = "get_modified")] + fn modified(&self) -> u64 { + unsafe { ffi::secret_item_get_modified(self.as_ref().to_glib_none().0) } + } + + #[doc(alias = "secret_item_get_schema_name")] + #[doc(alias = "get_schema_name")] + fn schema_name(&self) -> Option<glib::GString> { + unsafe { + from_glib_full(ffi::secret_item_get_schema_name( + self.as_ref().to_glib_none().0, + )) + } + } + + #[doc(alias = "secret_item_get_secret")] + #[doc(alias = "get_secret")] + fn secret(&self) -> Option<Value> { + unsafe { from_glib_full(ffi::secret_item_get_secret(self.as_ref().to_glib_none().0)) } + } + + #[doc(alias = "secret_item_get_service")] + #[doc(alias = "get_service")] + fn service(&self) -> Service { + unsafe { from_glib_none(ffi::secret_item_get_service(self.as_ref().to_glib_none().0)) } + } + + #[doc(alias = "secret_item_load_secret")] + fn load_secret<P: FnOnce(Result<(), glib::Error>) + 'static>( + &self, + cancellable: Option<&impl IsA<gio::Cancellable>>, + callback: P, + ) { + let main_context = glib::MainContext::ref_thread_default(); + let is_main_context_owner = main_context.is_owner(); + let has_acquired_main_context = (!is_main_context_owner) + .then(|| main_context.acquire().ok()) + .flatten(); + assert!( + is_main_context_owner || has_acquired_main_context.is_some(), + "Async operations only allowed if the thread is owning the MainContext" + ); + + let user_data: Box_<glib::thread_guard::ThreadGuard<P>> = + Box_::new(glib::thread_guard::ThreadGuard::new(callback)); + unsafe extern "C" fn load_secret_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 = std::ptr::null_mut(); + let _ = ffi::secret_item_load_secret_finish(_source_object as *mut _, res, &mut error); + let result = if error.is_null() { + Ok(()) + } else { + Err(from_glib_full(error)) + }; + 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 = load_secret_trampoline::<P>; + unsafe { + ffi::secret_item_load_secret( + self.as_ref().to_glib_none().0, + cancellable.map(|p| p.as_ref()).to_glib_none().0, + Some(callback), + Box_::into_raw(user_data) as *mut _, + ); + } + } + + fn load_secret_future( + &self, + ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> { + Box_::pin(gio::GioFuture::new(self, move |obj, cancellable, send| { + obj.load_secret(Some(cancellable), move |res| { + send.resolve(res); + }); + })) + } + + #[doc(alias = "secret_item_load_secret_sync")] + fn load_secret_sync( + &self, + cancellable: Option<&impl IsA<gio::Cancellable>>, + ) -> Result<(), glib::Error> { + unsafe { + let mut error = std::ptr::null_mut(); + let is_ok = ffi::secret_item_load_secret_sync( + self.as_ref().to_glib_none().0, + cancellable.map(|p| p.as_ref()).to_glib_none().0, + &mut error, + ); + debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null()); + if error.is_null() { + Ok(()) + } else { + Err(from_glib_full(error)) + } + } + } + + #[doc(alias = "secret_item_refresh")] + fn refresh(&self) { + unsafe { + ffi::secret_item_refresh(self.as_ref().to_glib_none().0); + } + } + + #[doc(alias = "secret_item_set_label")] + fn set_label<P: FnOnce(Result<(), glib::Error>) + 'static>( + &self, + label: &str, + cancellable: Option<&impl IsA<gio::Cancellable>>, + callback: P, + ) { + let main_context = glib::MainContext::ref_thread_default(); + let is_main_context_owner = main_context.is_owner(); + let has_acquired_main_context = (!is_main_context_owner) + .then(|| main_context.acquire().ok()) + .flatten(); + assert!( + is_main_context_owner || has_acquired_main_context.is_some(), + "Async operations only allowed if the thread is owning the MainContext" + ); + + let user_data: Box_<glib::thread_guard::ThreadGuard<P>> = + Box_::new(glib::thread_guard::ThreadGuard::new(callback)); + unsafe extern "C" fn set_label_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 = std::ptr::null_mut(); + let _ = ffi::secret_item_set_label_finish(_source_object as *mut _, res, &mut error); + let result = if error.is_null() { + Ok(()) + } else { + Err(from_glib_full(error)) + }; + 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 = set_label_trampoline::<P>; + unsafe { + ffi::secret_item_set_label( + self.as_ref().to_glib_none().0, + label.to_glib_none().0, + cancellable.map(|p| p.as_ref()).to_glib_none().0, + Some(callback), + Box_::into_raw(user_data) as *mut _, + ); + } + } + + fn set_label_future( + &self, + label: &str, + ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> { + let label = String::from(label); + Box_::pin(gio::GioFuture::new(self, move |obj, cancellable, send| { + obj.set_label(&label, Some(cancellable), move |res| { + send.resolve(res); + }); + })) + } + + #[doc(alias = "secret_item_set_label_sync")] + fn set_label_sync( + &self, + label: &str, + cancellable: Option<&impl IsA<gio::Cancellable>>, + ) -> Result<(), glib::Error> { + unsafe { + let mut error = std::ptr::null_mut(); + let is_ok = ffi::secret_item_set_label_sync( + self.as_ref().to_glib_none().0, + label.to_glib_none().0, + cancellable.map(|p| p.as_ref()).to_glib_none().0, + &mut error, + ); + debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null()); + if error.is_null() { + Ok(()) + } else { + Err(from_glib_full(error)) + } + } + } + + #[doc(alias = "secret_item_set_secret")] + fn set_secret<P: FnOnce(Result<(), glib::Error>) + 'static>( + &self, + value: &Value, + cancellable: Option<&impl IsA<gio::Cancellable>>, + callback: P, + ) { + let main_context = glib::MainContext::ref_thread_default(); + let is_main_context_owner = main_context.is_owner(); + let has_acquired_main_context = (!is_main_context_owner) + .then(|| main_context.acquire().ok()) + .flatten(); + assert!( + is_main_context_owner || has_acquired_main_context.is_some(), + "Async operations only allowed if the thread is owning the MainContext" + ); + + let user_data: Box_<glib::thread_guard::ThreadGuard<P>> = + Box_::new(glib::thread_guard::ThreadGuard::new(callback)); + unsafe extern "C" fn set_secret_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 = std::ptr::null_mut(); + let _ = ffi::secret_item_set_secret_finish(_source_object as *mut _, res, &mut error); + let result = if error.is_null() { + Ok(()) + } else { + Err(from_glib_full(error)) + }; + 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 = set_secret_trampoline::<P>; + unsafe { + ffi::secret_item_set_secret( + self.as_ref().to_glib_none().0, + value.to_glib_none().0, + cancellable.map(|p| p.as_ref()).to_glib_none().0, + Some(callback), + Box_::into_raw(user_data) as *mut _, + ); + } + } + + fn set_secret_future( + &self, + value: &Value, + ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> { + let value = value.clone(); + Box_::pin(gio::GioFuture::new(self, move |obj, cancellable, send| { + obj.set_secret(&value, Some(cancellable), move |res| { + send.resolve(res); + }); + })) + } + + #[doc(alias = "secret_item_set_secret_sync")] + fn set_secret_sync( + &self, + value: &Value, + cancellable: Option<&impl IsA<gio::Cancellable>>, + ) -> Result<(), glib::Error> { + unsafe { + let mut error = std::ptr::null_mut(); + let is_ok = ffi::secret_item_set_secret_sync( + self.as_ref().to_glib_none().0, + value.to_glib_none().0, + cancellable.map(|p| p.as_ref()).to_glib_none().0, + &mut error, + ); + debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null()); + if error.is_null() { + Ok(()) + } else { + Err(from_glib_full(error)) + } + } + } + + #[doc(alias = "locked")] + fn connect_locked_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { + unsafe extern "C" fn notify_locked_trampoline<P: IsA<Item>, F: Fn(&P) + 'static>( + this: *mut ffi::SecretItem, + _param_spec: glib::ffi::gpointer, + f: glib::ffi::gpointer, + ) { + let f: &F = &*(f as *const F); + f(Item::from_glib_borrow(this).unsafe_cast_ref()) + } + unsafe { + let f: Box_<F> = Box_::new(f); + connect_raw( + self.as_ptr() as *mut _, + b"notify::locked\0".as_ptr() as *const _, + Some(std::mem::transmute::<_, unsafe extern "C" fn()>( + notify_locked_trampoline::<Self, F> as *const (), + )), + Box_::into_raw(f), + ) + } + } +} + +impl<O: IsA<Item>> ItemExt for O {} diff --git a/libsecret/src/auto/mod.rs b/libsecret/src/auto/mod.rs new file mode 100644 index 0000000..a8d7346 --- /dev/null +++ b/libsecret/src/auto/mod.rs @@ -0,0 +1,75 @@ +// This file was generated by gir (https://github.com/gtk-rs/gir) +// from +// from gir-files (https://github.com/gtk-rs/gir-files.git) +// DO NOT EDIT + +#[cfg(feature = "v0_19")] +#[cfg_attr(docsrs, doc(cfg(feature = "v0_19")))] +mod backend; +#[cfg(feature = "v0_19")] +#[cfg_attr(docsrs, doc(cfg(feature = "v0_19")))] +pub use self::backend::Backend; + +mod collection; +pub use self::collection::Collection; + +mod item; +pub use self::item::Item; + +mod prompt; +pub use self::prompt::Prompt; + +#[cfg(feature = "v0_19")] +#[cfg_attr(docsrs, doc(cfg(feature = "v0_19")))] +mod retrievable; +#[cfg(feature = "v0_19")] +#[cfg_attr(docsrs, doc(cfg(feature = "v0_19")))] +pub use self::retrievable::Retrievable; + +mod service; +pub use self::service::Service; + +mod schema; +pub use self::schema::Schema; + +mod schema_attribute; +pub use self::schema_attribute::SchemaAttribute; + +mod enums; +#[cfg(feature = "v0_19")] +#[cfg_attr(docsrs, doc(cfg(feature = "v0_19")))] +pub use self::enums::BackendFlags; +pub use self::enums::Error; +pub use self::enums::SchemaAttributeType; +#[cfg(feature = "v0_18_6")] +#[cfg_attr(docsrs, doc(cfg(feature = "v0_18_6")))] +pub use self::enums::SchemaType; + +mod flags; +pub use self::flags::CollectionCreateFlags; +pub use self::flags::CollectionFlags; +pub use self::flags::ItemCreateFlags; +pub use self::flags::ItemFlags; +pub use self::flags::SchemaFlags; +pub use self::flags::SearchFlags; +pub use self::flags::ServiceFlags; + +pub(crate) mod functions; + +mod constants; +pub use self::constants::BACKEND_EXTENSION_POINT_NAME; +pub use self::constants::COLLECTION_DEFAULT; +pub use self::constants::COLLECTION_SESSION; + +pub(crate) mod traits { + #[cfg(feature = "v0_19")] + #[cfg_attr(docsrs, doc(cfg(feature = "v0_19")))] + pub use super::backend::BackendExt; + pub use super::collection::CollectionExt; + pub use super::item::ItemExt; + pub use super::prompt::PromptExt; + #[cfg(feature = "v0_19")] + #[cfg_attr(docsrs, doc(cfg(feature = "v0_19")))] + pub use super::retrievable::RetrievableExt; + pub use super::service::ServiceExt; +} diff --git a/libsecret/src/auto/prompt.rs b/libsecret/src/auto/prompt.rs new file mode 100644 index 0000000..245f68a --- /dev/null +++ b/libsecret/src/auto/prompt.rs @@ -0,0 +1,76 @@ +// This file was generated by gir (https://github.com/gtk-rs/gir) +// from +// from gir-files (https://github.com/gtk-rs/gir-files.git) +// DO NOT EDIT + +use glib::{prelude::*, translate::*}; + +glib::wrapper! { + #[doc(alias = "SecretPrompt")] + pub struct Prompt(Object<ffi::SecretPrompt, ffi::SecretPromptClass>) @extends gio::DBusProxy, @implements gio::DBusInterface, gio::Initable; + + match fn { + type_ => || ffi::secret_prompt_get_type(), + } +} + +impl Prompt { + pub const NONE: Option<&'static Prompt> = None; +} + +mod sealed { + pub trait Sealed {} + impl<T: super::IsA<super::Prompt>> Sealed for T {} +} + +pub trait PromptExt: IsA<Prompt> + sealed::Sealed + 'static { + #[doc(alias = "secret_prompt_perform_sync")] + fn perform_sync( + &self, + window_id: Option<&str>, + cancellable: Option<&impl IsA<gio::Cancellable>>, + return_type: &glib::VariantTy, + ) -> Result<glib::Variant, glib::Error> { + unsafe { + let mut error = std::ptr::null_mut(); + let ret = ffi::secret_prompt_perform_sync( + self.as_ref().to_glib_none().0, + window_id.to_glib_none().0, + cancellable.map(|p| p.as_ref()).to_glib_none().0, + return_type.to_glib_none().0, + &mut error, + ); + if error.is_null() { + Ok(from_glib_full(ret)) + } else { + Err(from_glib_full(error)) + } + } + } + + #[doc(alias = "secret_prompt_run")] + fn run( + &self, + window_id: Option<&str>, + cancellable: Option<&impl IsA<gio::Cancellable>>, + return_type: &glib::VariantTy, + ) -> Result<glib::Variant, glib::Error> { + unsafe { + let mut error = std::ptr::null_mut(); + let ret = ffi::secret_prompt_run( + self.as_ref().to_glib_none().0, + window_id.to_glib_none().0, + cancellable.map(|p| p.as_ref()).to_glib_none().0, + return_type.to_glib_none().0, + &mut error, + ); + if error.is_null() { + Ok(from_glib_full(ret)) + } else { + Err(from_glib_full(error)) + } + } + } +} + +impl<O: IsA<Prompt>> PromptExt for O {} diff --git a/libsecret/src/auto/retrievable.rs b/libsecret/src/auto/retrievable.rs new file mode 100644 index 0000000..14ab08f --- /dev/null +++ b/libsecret/src/auto/retrievable.rs @@ -0,0 +1,269 @@ +// This file was generated by gir (https://github.com/gtk-rs/gir) +// from +// from gir-files (https://github.com/gtk-rs/gir-files.git) +// DO NOT EDIT + +use crate::Value; +use glib::{ + prelude::*, + signal::{connect_raw, SignalHandlerId}, + translate::*, +}; +use std::{boxed::Box as Box_, pin::Pin}; + +glib::wrapper! { + #[doc(alias = "SecretRetrievable")] + pub struct Retrievable(Interface<ffi::SecretRetrievable, ffi::SecretRetrievableInterface>); + + match fn { + type_ => || ffi::secret_retrievable_get_type(), + } +} + +impl Retrievable { + pub const NONE: Option<&'static Retrievable> = None; +} + +mod sealed { + pub trait Sealed {} + impl<T: super::IsA<super::Retrievable>> Sealed for T {} +} + +pub trait RetrievableExt: IsA<Retrievable> + sealed::Sealed + 'static { + #[doc(alias = "secret_retrievable_get_created")] + #[doc(alias = "get_created")] + fn created(&self) -> u64 { + unsafe { ffi::secret_retrievable_get_created(self.as_ref().to_glib_none().0) } + } + + #[doc(alias = "secret_retrievable_get_label")] + #[doc(alias = "get_label")] + fn label(&self) -> glib::GString { + unsafe { + from_glib_full(ffi::secret_retrievable_get_label( + self.as_ref().to_glib_none().0, + )) + } + } + + #[doc(alias = "secret_retrievable_get_modified")] + #[doc(alias = "get_modified")] + fn modified(&self) -> u64 { + unsafe { ffi::secret_retrievable_get_modified(self.as_ref().to_glib_none().0) } + } + + #[doc(alias = "secret_retrievable_retrieve_secret")] + fn retrieve_secret<P: FnOnce(Result<Option<Value>, glib::Error>) + 'static>( + &self, + cancellable: Option<&impl IsA<gio::Cancellable>>, + callback: P, + ) { + let main_context = glib::MainContext::ref_thread_default(); + let is_main_context_owner = main_context.is_owner(); + let has_acquired_main_context = (!is_main_context_owner) + .then(|| main_context.acquire().ok()) + .flatten(); + assert!( + is_main_context_owner || has_acquired_main_context.is_some(), + "Async operations only allowed if the thread is owning the MainContext" + ); + + let user_data: Box_<glib::thread_guard::ThreadGuard<P>> = + Box_::new(glib::thread_guard::ThreadGuard::new(callback)); + unsafe extern "C" fn retrieve_secret_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 error = std::ptr::null_mut(); + let ret = ffi::secret_retrievable_retrieve_secret_finish( + _source_object as *mut _, + res, + &mut error, + ); + let result = if error.is_null() { + Ok(from_glib_full(ret)) + } else { + Err(from_glib_full(error)) + }; + 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 = retrieve_secret_trampoline::<P>; + unsafe { + ffi::secret_retrievable_retrieve_secret( + self.as_ref().to_glib_none().0, + cancellable.map(|p| p.as_ref()).to_glib_none().0, + Some(callback), + Box_::into_raw(user_data) as *mut _, + ); + } + } + + fn retrieve_secret_future( + &self, + ) -> Pin<Box_<dyn std::future::Future<Output = Result<Option<Value>, glib::Error>> + 'static>> + { + Box_::pin(gio::GioFuture::new(self, move |obj, cancellable, send| { + obj.retrieve_secret(Some(cancellable), move |res| { + send.resolve(res); + }); + })) + } + + #[doc(alias = "secret_retrievable_retrieve_secret_sync")] + fn retrieve_secret_sync( + &self, + cancellable: Option<&impl IsA<gio::Cancellable>>, + ) -> Result<Option<Value>, glib::Error> { + unsafe { + let mut error = std::ptr::null_mut(); + let ret = ffi::secret_retrievable_retrieve_secret_sync( + self.as_ref().to_glib_none().0, + cancellable.map(|p| p.as_ref()).to_glib_none().0, + &mut error, + ); + if error.is_null() { + Ok(from_glib_full(ret)) + } else { + Err(from_glib_full(error)) + } + } + } + + //#[cfg(feature = "v0_19")] + //#[cfg_attr(docsrs, doc(cfg(feature = "v0_19")))] + //fn set_attributes(&self, attributes: /*Unimplemented*/HashTable TypeId { ns_id: 0, id: 28 }/TypeId { ns_id: 0, id: 28 }) { + // ObjectExt::set_property(self.as_ref(),"attributes", attributes) + //} + + #[cfg(feature = "v0_19")] + #[cfg_attr(docsrs, doc(cfg(feature = "v0_19")))] + fn set_created(&self, created: u64) { + ObjectExt::set_property(self.as_ref(), "created", created) + } + + #[cfg(feature = "v0_19")] + #[cfg_attr(docsrs, doc(cfg(feature = "v0_19")))] + fn set_label(&self, label: Option<&str>) { + ObjectExt::set_property(self.as_ref(), "label", label) + } + + #[cfg(feature = "v0_19")] + #[cfg_attr(docsrs, doc(cfg(feature = "v0_19")))] + fn set_modified(&self, modified: u64) { + ObjectExt::set_property(self.as_ref(), "modified", modified) + } + + #[cfg(feature = "v0_19")] + #[cfg_attr(docsrs, doc(cfg(feature = "v0_19")))] + #[doc(alias = "attributes")] + fn connect_attributes_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { + unsafe extern "C" fn notify_attributes_trampoline< + P: IsA<Retrievable>, + F: Fn(&P) + 'static, + >( + this: *mut ffi::SecretRetrievable, + _param_spec: glib::ffi::gpointer, + f: glib::ffi::gpointer, + ) { + let f: &F = &*(f as *const F); + f(Retrievable::from_glib_borrow(this).unsafe_cast_ref()) + } + unsafe { + let f: Box_<F> = Box_::new(f); + connect_raw( + self.as_ptr() as *mut _, + b"notify::attributes\0".as_ptr() as *const _, + Some(std::mem::transmute::<_, unsafe extern "C" fn()>( + notify_attributes_trampoline::<Self, F> as *const (), + )), + Box_::into_raw(f), + ) + } + } + + #[cfg(feature = "v0_19")] + #[cfg_attr(docsrs, doc(cfg(feature = "v0_19")))] + #[doc(alias = "created")] + fn connect_created_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { + unsafe extern "C" fn notify_created_trampoline<P: IsA<Retrievable>, F: Fn(&P) + 'static>( + this: *mut ffi::SecretRetrievable, + _param_spec: glib::ffi::gpointer, + f: glib::ffi::gpointer, + ) { + let f: &F = &*(f as *const F); + f(Retrievable::from_glib_borrow(this).unsafe_cast_ref()) + } + unsafe { + let f: Box_<F> = Box_::new(f); + connect_raw( + self.as_ptr() as *mut _, + b"notify::created\0".as_ptr() as *const _, + Some(std::mem::transmute::<_, unsafe extern "C" fn()>( + notify_created_trampoline::<Self, F> as *const (), + )), + Box_::into_raw(f), + ) + } + } + + #[cfg(feature = "v0_19")] + #[cfg_attr(docsrs, doc(cfg(feature = "v0_19")))] + #[doc(alias = "label")] + fn connect_label_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { + unsafe extern "C" fn notify_label_trampoline<P: IsA<Retrievable>, F: Fn(&P) + 'static>( + this: *mut ffi::SecretRetrievable, + _param_spec: glib::ffi::gpointer, + f: glib::ffi::gpointer, + ) { + let f: &F = &*(f as *const F); + f(Retrievable::from_glib_borrow(this).unsafe_cast_ref()) + } + unsafe { + let f: Box_<F> = Box_::new(f); + connect_raw( + self.as_ptr() as *mut _, + b"notify::label\0".as_ptr() as *const _, + Some(std::mem::transmute::<_, unsafe extern "C" fn()>( + notify_label_trampoline::<Self, F> as *const (), + )), + Box_::into_raw(f), + ) + } + } + + #[cfg(feature = "v0_19")] + #[cfg_attr(docsrs, doc(cfg(feature = "v0_19")))] + #[doc(alias = "modified")] + fn connect_modified_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId { + unsafe extern "C" fn notify_modified_trampoline< + P: IsA<Retrievable>, + F: Fn(&P) + 'static, + >( + this: *mut ffi::SecretRetrievable, + _param_spec: glib::ffi::gpointer, + f: glib::ffi::gpointer, + ) { + let f: &F = &*(f as *const F); + f(Retrievable::from_glib_borrow(this).unsafe_cast_ref()) + } + unsafe { + let f: Box_<F> = Box_::new(f); + connect_raw( + self.as_ptr() as *mut _, + b"notify::modified\0".as_ptr() as *const _, + Some(std::mem::transmute::<_, unsafe extern "C" fn()>( + notify_modified_trampoline::<Self, F> as *const (), + )), + Box_::into_raw(f), + ) + } + } +} + +impl<O: IsA<Retrievable>> RetrievableExt for O {} diff --git a/libsecret/src/auto/schema.rs b/libsecret/src/auto/schema.rs new file mode 100644 index 0000000..9889b31 --- /dev/null +++ b/libsecret/src/auto/schema.rs @@ -0,0 +1,15 @@ +// This file was generated by gir (https://github.com/gtk-rs/gir) +// from +// from gir-files (https://github.com/gtk-rs/gir-files.git) +// DO NOT EDIT + +glib::wrapper! { + #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] + pub struct Schema(Shared<ffi::SecretSchema>); + + match fn { + ref => |ptr| ffi::secret_schema_ref(ptr), + unref => |ptr| ffi::secret_schema_unref(ptr), + type_ => || ffi::secret_schema_get_type(), + } +} diff --git a/libsecret/src/auto/schema_attribute.rs b/libsecret/src/auto/schema_attribute.rs new file mode 100644 index 0000000..be20632 --- /dev/null +++ b/libsecret/src/auto/schema_attribute.rs @@ -0,0 +1,15 @@ +// This file was generated by gir (https://github.com/gtk-rs/gir) +// from +// from gir-files (https://github.com/gtk-rs/gir-files.git) +// DO NOT EDIT + +glib::wrapper! { + #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] + pub struct SchemaAttribute(Boxed<ffi::SecretSchemaAttribute>); + + match fn { + copy => |ptr| glib::gobject_ffi::g_boxed_copy(ffi::secret_schema_attribute_get_type(), ptr as *mut _) as *mut ffi::SecretSchemaAttribute, + free => |ptr| glib::gobject_ffi::g_boxed_free(ffi::secret_schema_attribute_get_type(), ptr as *mut _), + type_ => || ffi::secret_schema_attribute_get_type(), + } +} diff --git a/libsecret/src/auto/service.rs b/libsecret/src/auto/service.rs new file mode 100644 index 0000000..b4882b3 --- /dev/null +++ b/libsecret/src/auto/service.rs @@ -0,0 +1,1208 @@ +// This file was generated by gir (https://github.com/gtk-rs/gir) +// from +// from gir-files (https://github.com/gtk-rs/gir-files.git) +// DO NOT EDIT + +#[cfg(feature = "v0_19")] +#[cfg_attr(docsrs, doc(cfg(feature = "v0_19")))] +use crate::Backend; +use crate::{Collection, Item, Prompt, ServiceFlags, Value}; +use glib::{prelude::*, translate::*}; +use std::{boxed::Box as Box_, pin::Pin}; + +#[cfg(feature = "v0_19")] +#[cfg_attr(docsrs, doc(cfg(feature = "v0_19")))] +glib::wrapper! { + #[doc(alias = "SecretService")] + pub struct Service(Object<ffi::SecretService, ffi::SecretServiceClass>) @extends gio::DBusProxy, @implements gio::DBusInterface, gio::Initable, Backend; + + match fn { + type_ => || ffi::secret_service_get_type(), + } +} + +#[cfg(not(any(feature = "v0_19")))] +glib::wrapper! { + #[doc(alias = "SecretService")] + pub struct Service(Object<ffi::SecretService, ffi::SecretServiceClass>) @extends gio::DBusProxy, @implements gio::DBusInterface, gio::Initable; + + match fn { + type_ => || ffi::secret_service_get_type(), + } +} + +impl Service { + pub const NONE: Option<&'static Service> = None; + + #[doc(alias = "secret_service_disconnect")] + pub fn disconnect() { + unsafe { + ffi::secret_service_disconnect(); + } + } + + #[doc(alias = "secret_service_get")] + pub fn get<P: FnOnce(Result<Service, glib::Error>) + 'static>( + flags: ServiceFlags, + cancellable: Option<&impl IsA<gio::Cancellable>>, + callback: P, + ) { + let main_context = glib::MainContext::ref_thread_default(); + let is_main_context_owner = main_context.is_owner(); + let has_acquired_main_context = (!is_main_context_owner) + .then(|| main_context.acquire().ok()) + .flatten(); + assert!( + is_main_context_owner || has_acquired_main_context.is_some(), + "Async operations only allowed if the thread is owning the MainContext" + ); + + let user_data: Box_<glib::thread_guard::ThreadGuard<P>> = + Box_::new(glib::thread_guard::ThreadGuard::new(callback)); + unsafe extern "C" fn get_trampoline<P: FnOnce(Result<Service, glib::Error>) + 'static>( + _source_object: *mut glib::gobject_ffi::GObject, + res: *mut gio::ffi::GAsyncResult, + user_data: glib::ffi::gpointer, + ) { + let mut error = std::ptr::null_mut(); + let ret = ffi::secret_service_get_finish(res, &mut error); + let result = if error.is_null() { + Ok(from_glib_full(ret)) + } else { + Err(from_glib_full(error)) + }; + 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 = get_trampoline::<P>; + unsafe { + ffi::secret_service_get( + flags.into_glib(), + cancellable.map(|p| p.as_ref()).to_glib_none().0, + Some(callback), + Box_::into_raw(user_data) as *mut _, + ); + } + } + + pub fn get_future( + flags: ServiceFlags, + ) -> Pin<Box_<dyn std::future::Future<Output = Result<Service, glib::Error>> + 'static>> { + Box_::pin(gio::GioFuture::new(&(), move |_obj, cancellable, send| { + Self::get(flags, Some(cancellable), move |res| { + send.resolve(res); + }); + })) + } + + #[doc(alias = "secret_service_get_sync")] + #[doc(alias = "get_sync")] + pub fn sync( + flags: ServiceFlags, + cancellable: Option<&impl IsA<gio::Cancellable>>, + ) -> Result<Service, glib::Error> { + unsafe { + let mut error = std::ptr::null_mut(); + let ret = ffi::secret_service_get_sync( + flags.into_glib(), + cancellable.map(|p| p.as_ref()).to_glib_none().0, + &mut error, + ); + if error.is_null() { + Ok(from_glib_full(ret)) + } else { + Err(from_glib_full(error)) + } + } + } + + #[doc(alias = "secret_service_open")] + pub fn open<P: FnOnce(Result<Service, glib::Error>) + 'static>( + service_gtype: glib::types::Type, + service_bus_name: Option<&str>, + flags: ServiceFlags, + cancellable: Option<&impl IsA<gio::Cancellable>>, + callback: P, + ) { + let main_context = glib::MainContext::ref_thread_default(); + let is_main_context_owner = main_context.is_owner(); + let has_acquired_main_context = (!is_main_context_owner) + .then(|| main_context.acquire().ok()) + .flatten(); + assert!( + is_main_context_owner || has_acquired_main_context.is_some(), + "Async operations only allowed if the thread is owning the MainContext" + ); + + let user_data: Box_<glib::thread_guard::ThreadGuard<P>> = + Box_::new(glib::thread_guard::ThreadGuard::new(callback)); + unsafe extern "C" fn open_trampoline<P: FnOnce(Result<Service, glib::Error>) + 'static>( + _source_object: *mut glib::gobject_ffi::GObject, + res: *mut gio::ffi::GAsyncResult, + user_data: glib::ffi::gpointer, + ) { + let mut error = std::ptr::null_mut(); + let ret = ffi::secret_service_open_finish(res, &mut error); + let result = if error.is_null() { + Ok(from_glib_full(ret)) + } else { + Err(from_glib_full(error)) + }; + 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 = open_trampoline::<P>; + unsafe { + ffi::secret_service_open( + service_gtype.into_glib(), + service_bus_name.to_glib_none().0, + flags.into_glib(), + cancellable.map(|p| p.as_ref()).to_glib_none().0, + Some(callback), + Box_::into_raw(user_data) as *mut _, + ); + } + } + + pub fn open_future( + service_gtype: glib::types::Type, + service_bus_name: Option<&str>, + flags: ServiceFlags, + ) -> Pin<Box_<dyn std::future::Future<Output = Result<Service, glib::Error>> + 'static>> { + let service_bus_name = service_bus_name.map(ToOwned::to_owned); + Box_::pin(gio::GioFuture::new(&(), move |_obj, cancellable, send| { + Self::open( + service_gtype, + service_bus_name.as_ref().map(::std::borrow::Borrow::borrow), + flags, + Some(cancellable), + move |res| { + send.resolve(res); + }, + ); + })) + } + + #[doc(alias = "secret_service_open_sync")] + pub fn open_sync( + service_gtype: glib::types::Type, + service_bus_name: Option<&str>, + flags: ServiceFlags, + cancellable: Option<&impl IsA<gio::Cancellable>>, + ) -> Result<Service, glib::Error> { + unsafe { + let mut error = std::ptr::null_mut(); + let ret = ffi::secret_service_open_sync( + service_gtype.into_glib(), + service_bus_name.to_glib_none().0, + flags.into_glib(), + cancellable.map(|p| p.as_ref()).to_glib_none().0, + &mut error, + ); + if error.is_null() { + Ok(from_glib_full(ret)) + } else { + Err(from_glib_full(error)) + } + } + } +} + +mod sealed { + pub trait Sealed {} + impl<T: super::IsA<super::Service>> Sealed for T {} +} + +pub trait ServiceExt: IsA<Service> + sealed::Sealed + 'static { + //#[doc(alias = "secret_service_clear_sync")] + //fn clear_sync(&self, schema: Option<&Schema>, attributes: /*Unknown conversion*//*Unimplemented*/HashTable TypeId { ns_id: 0, id: 28 }/TypeId { ns_id: 0, id: 28 }, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(), glib::Error> { + // unsafe { TODO: call ffi:secret_service_clear_sync() } + //} + + //#[doc(alias = "secret_service_create_collection_dbus_path_sync")] + //fn create_collection_dbus_path_sync(&self, properties: /*Unknown conversion*//*Unimplemented*/HashTable TypeId { ns_id: 0, id: 28 }/TypeId { ns_id: 2, id: 222 }, alias: Option<&str>, flags: CollectionCreateFlags, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<glib::GString, glib::Error> { + // unsafe { TODO: call ffi:secret_service_create_collection_dbus_path_sync() } + //} + + //#[doc(alias = "secret_service_create_item_dbus_path_sync")] + //fn create_item_dbus_path_sync(&self, collection_path: &str, properties: /*Unknown conversion*//*Unimplemented*/HashTable TypeId { ns_id: 0, id: 28 }/TypeId { ns_id: 2, id: 222 }, value: &Value, flags: ItemCreateFlags, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<glib::GString, glib::Error> { + // unsafe { TODO: call ffi:secret_service_create_item_dbus_path_sync() } + //} + + #[doc(alias = "secret_service_decode_dbus_secret")] + fn decode_dbus_secret(&self, value: &glib::Variant) -> Value { + unsafe { + from_glib_full(ffi::secret_service_decode_dbus_secret( + self.as_ref().to_glib_none().0, + value.to_glib_none().0, + )) + } + } + + #[doc(alias = "secret_service_delete_item_dbus_path")] + fn delete_item_dbus_path<P: FnOnce(Result<(), glib::Error>) + 'static>( + &self, + item_path: &str, + cancellable: Option<&impl IsA<gio::Cancellable>>, + callback: P, + ) { + let main_context = glib::MainContext::ref_thread_default(); + let is_main_context_owner = main_context.is_owner(); + let has_acquired_main_context = (!is_main_context_owner) + .then(|| main_context.acquire().ok()) + .flatten(); + assert!( + is_main_context_owner || has_acquired_main_context.is_some(), + "Async operations only allowed if the thread is owning the MainContext" + ); + + let user_data: Box_<glib::thread_guard::ThreadGuard<P>> = + Box_::new(glib::thread_guard::ThreadGuard::new(callback)); + unsafe extern "C" fn delete_item_dbus_path_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 = std::ptr::null_mut(); + let _ = ffi::secret_service_delete_item_dbus_path_finish( + _source_object as *mut _, + res, + &mut error, + ); + let result = if error.is_null() { + Ok(()) + } else { + Err(from_glib_full(error)) + }; + 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 = delete_item_dbus_path_trampoline::<P>; + unsafe { + ffi::secret_service_delete_item_dbus_path( + self.as_ref().to_glib_none().0, + item_path.to_glib_none().0, + cancellable.map(|p| p.as_ref()).to_glib_none().0, + Some(callback), + Box_::into_raw(user_data) as *mut _, + ); + } + } + + fn delete_item_dbus_path_future( + &self, + item_path: &str, + ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> { + let item_path = String::from(item_path); + Box_::pin(gio::GioFuture::new(self, move |obj, cancellable, send| { + obj.delete_item_dbus_path(&item_path, Some(cancellable), move |res| { + send.resolve(res); + }); + })) + } + + #[doc(alias = "secret_service_delete_item_dbus_path_sync")] + fn delete_item_dbus_path_sync( + &self, + item_path: &str, + cancellable: Option<&impl IsA<gio::Cancellable>>, + ) -> Result<(), glib::Error> { + unsafe { + let mut error = std::ptr::null_mut(); + let is_ok = ffi::secret_service_delete_item_dbus_path_sync( + self.as_ref().to_glib_none().0, + item_path.to_glib_none().0, + cancellable.map(|p| p.as_ref()).to_glib_none().0, + &mut error, + ); + debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null()); + if error.is_null() { + Ok(()) + } else { + Err(from_glib_full(error)) + } + } + } + + #[doc(alias = "secret_service_encode_dbus_secret")] + fn encode_dbus_secret(&self, value: &Value) -> glib::Variant { + unsafe { + from_glib_none(ffi::secret_service_encode_dbus_secret( + self.as_ref().to_glib_none().0, + value.to_glib_none().0, + )) + } + } + + #[doc(alias = "secret_service_ensure_session")] + fn ensure_session<P: FnOnce(Result<(), glib::Error>) + 'static>( + &self, + cancellable: Option<&impl IsA<gio::Cancellable>>, + callback: P, + ) { + let main_context = glib::MainContext::ref_thread_default(); + let is_main_context_owner = main_context.is_owner(); + let has_acquired_main_context = (!is_main_context_owner) + .then(|| main_context.acquire().ok()) + .flatten(); + assert!( + is_main_context_owner || has_acquired_main_context.is_some(), + "Async operations only allowed if the thread is owning the MainContext" + ); + + let user_data: Box_<glib::thread_guard::ThreadGuard<P>> = + Box_::new(glib::thread_guard::ThreadGuard::new(callback)); + unsafe extern "C" fn ensure_session_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 = std::ptr::null_mut(); + let _ = ffi::secret_service_ensure_session_finish( + _source_object as *mut _, + res, + &mut error, + ); + let result = if error.is_null() { + Ok(()) + } else { + Err(from_glib_full(error)) + }; + 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 = ensure_session_trampoline::<P>; + unsafe { + ffi::secret_service_ensure_session( + self.as_ref().to_glib_none().0, + cancellable.map(|p| p.as_ref()).to_glib_none().0, + Some(callback), + Box_::into_raw(user_data) as *mut _, + ); + } + } + + fn ensure_session_future( + &self, + ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> { + Box_::pin(gio::GioFuture::new(self, move |obj, cancellable, send| { + obj.ensure_session(Some(cancellable), move |res| { + send.resolve(res); + }); + })) + } + + #[doc(alias = "secret_service_ensure_session_sync")] + fn ensure_session_sync( + &self, + cancellable: Option<&impl IsA<gio::Cancellable>>, + ) -> Result<(), glib::Error> { + unsafe { + let mut error = std::ptr::null_mut(); + let is_ok = ffi::secret_service_ensure_session_sync( + self.as_ref().to_glib_none().0, + cancellable.map(|p| p.as_ref()).to_glib_none().0, + &mut error, + ); + debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null()); + if error.is_null() { + Ok(()) + } else { + Err(from_glib_full(error)) + } + } + } + + #[doc(alias = "secret_service_get_collection_gtype")] + #[doc(alias = "get_collection_gtype")] + fn collection_gtype(&self) -> glib::types::Type { + unsafe { + from_glib(ffi::secret_service_get_collection_gtype( + self.as_ref().to_glib_none().0, + )) + } + } + + #[doc(alias = "secret_service_get_collections")] + #[doc(alias = "get_collections")] + fn collections(&self) -> Vec<Collection> { + unsafe { + FromGlibPtrContainer::from_glib_full(ffi::secret_service_get_collections( + self.as_ref().to_glib_none().0, + )) + } + } + + #[doc(alias = "secret_service_get_flags")] + #[doc(alias = "get_flags")] + fn flags(&self) -> ServiceFlags { + unsafe { + from_glib(ffi::secret_service_get_flags( + self.as_ref().to_glib_none().0, + )) + } + } + + #[doc(alias = "secret_service_get_item_gtype")] + #[doc(alias = "get_item_gtype")] + fn item_gtype(&self) -> glib::types::Type { + unsafe { + from_glib(ffi::secret_service_get_item_gtype( + self.as_ref().to_glib_none().0, + )) + } + } + + #[doc(alias = "secret_service_get_secret_for_dbus_path")] + #[doc(alias = "get_secret_for_dbus_path")] + fn secret_for_dbus_path<P: FnOnce(Result<Option<Value>, glib::Error>) + 'static>( + &self, + item_path: &str, + cancellable: Option<&impl IsA<gio::Cancellable>>, + callback: P, + ) { + let main_context = glib::MainContext::ref_thread_default(); + let is_main_context_owner = main_context.is_owner(); + let has_acquired_main_context = (!is_main_context_owner) + .then(|| main_context.acquire().ok()) + .flatten(); + assert!( + is_main_context_owner || has_acquired_main_context.is_some(), + "Async operations only allowed if the thread is owning the MainContext" + ); + + let user_data: Box_<glib::thread_guard::ThreadGuard<P>> = + Box_::new(glib::thread_guard::ThreadGuard::new(callback)); + unsafe extern "C" fn secret_for_dbus_path_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 error = std::ptr::null_mut(); + let ret = ffi::secret_service_get_secret_for_dbus_path_finish( + _source_object as *mut _, + res, + &mut error, + ); + let result = if error.is_null() { + Ok(from_glib_full(ret)) + } else { + Err(from_glib_full(error)) + }; + 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 = secret_for_dbus_path_trampoline::<P>; + unsafe { + ffi::secret_service_get_secret_for_dbus_path( + self.as_ref().to_glib_none().0, + item_path.to_glib_none().0, + cancellable.map(|p| p.as_ref()).to_glib_none().0, + Some(callback), + Box_::into_raw(user_data) as *mut _, + ); + } + } + + fn secret_for_dbus_path_future( + &self, + item_path: &str, + ) -> Pin<Box_<dyn std::future::Future<Output = Result<Option<Value>, glib::Error>> + 'static>> + { + let item_path = String::from(item_path); + Box_::pin(gio::GioFuture::new(self, move |obj, cancellable, send| { + obj.secret_for_dbus_path(&item_path, Some(cancellable), move |res| { + send.resolve(res); + }); + })) + } + + #[doc(alias = "secret_service_get_secret_for_dbus_path_sync")] + #[doc(alias = "get_secret_for_dbus_path_sync")] + fn secret_for_dbus_path_sync( + &self, + item_path: &str, + cancellable: Option<&impl IsA<gio::Cancellable>>, + ) -> Result<Option<Value>, glib::Error> { + unsafe { + let mut error = std::ptr::null_mut(); + let ret = ffi::secret_service_get_secret_for_dbus_path_sync( + self.as_ref().to_glib_none().0, + item_path.to_glib_none().0, + cancellable.map(|p| p.as_ref()).to_glib_none().0, + &mut error, + ); + if error.is_null() { + Ok(from_glib_full(ret)) + } else { + Err(from_glib_full(error)) + } + } + } + + //#[doc(alias = "secret_service_get_secrets_for_dbus_paths_sync")] + //#[doc(alias = "get_secrets_for_dbus_paths_sync")] + //fn secrets_for_dbus_paths_sync(&self, item_paths: &str, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result</*Unknown conversion*//*Unimplemented*/HashTable TypeId { ns_id: 0, id: 28 }/TypeId { ns_id: 1, id: 3 }, glib::Error> { + // unsafe { TODO: call ffi:secret_service_get_secrets_for_dbus_paths_sync() } + //} + + #[doc(alias = "secret_service_get_session_algorithms")] + #[doc(alias = "get_session_algorithms")] + fn session_algorithms(&self) -> Option<glib::GString> { + unsafe { + from_glib_none(ffi::secret_service_get_session_algorithms( + self.as_ref().to_glib_none().0, + )) + } + } + + #[doc(alias = "secret_service_get_session_dbus_path")] + #[doc(alias = "get_session_dbus_path")] + fn session_dbus_path(&self) -> Option<glib::GString> { + unsafe { + from_glib_none(ffi::secret_service_get_session_dbus_path( + self.as_ref().to_glib_none().0, + )) + } + } + + #[doc(alias = "secret_service_load_collections")] + fn load_collections<P: FnOnce(Result<(), glib::Error>) + 'static>( + &self, + cancellable: Option<&impl IsA<gio::Cancellable>>, + callback: P, + ) { + let main_context = glib::MainContext::ref_thread_default(); + let is_main_context_owner = main_context.is_owner(); + let has_acquired_main_context = (!is_main_context_owner) + .then(|| main_context.acquire().ok()) + .flatten(); + assert!( + is_main_context_owner || has_acquired_main_context.is_some(), + "Async operations only allowed if the thread is owning the MainContext" + ); + + let user_data: Box_<glib::thread_guard::ThreadGuard<P>> = + Box_::new(glib::thread_guard::ThreadGuard::new(callback)); + unsafe extern "C" fn load_collections_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 = std::ptr::null_mut(); + let _ = ffi::secret_service_load_collections_finish( + _source_object as *mut _, + res, + &mut error, + ); + let result = if error.is_null() { + Ok(()) + } else { + Err(from_glib_full(error)) + }; + 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 = load_collections_trampoline::<P>; + unsafe { + ffi::secret_service_load_collections( + self.as_ref().to_glib_none().0, + cancellable.map(|p| p.as_ref()).to_glib_none().0, + Some(callback), + Box_::into_raw(user_data) as *mut _, + ); + } + } + + fn load_collections_future( + &self, + ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> { + Box_::pin(gio::GioFuture::new(self, move |obj, cancellable, send| { + obj.load_collections(Some(cancellable), move |res| { + send.resolve(res); + }); + })) + } + + #[doc(alias = "secret_service_load_collections_sync")] + fn load_collections_sync( + &self, + cancellable: Option<&impl IsA<gio::Cancellable>>, + ) -> Result<(), glib::Error> { + unsafe { + let mut error = std::ptr::null_mut(); + let is_ok = ffi::secret_service_load_collections_sync( + self.as_ref().to_glib_none().0, + cancellable.map(|p| p.as_ref()).to_glib_none().0, + &mut error, + ); + debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null()); + if error.is_null() { + Ok(()) + } else { + Err(from_glib_full(error)) + } + } + } + + //#[doc(alias = "secret_service_lock_sync")] + //fn lock_sync(&self, objects: &[gio::DBusProxy], cancellable: Option<&impl IsA<gio::Cancellable>>, locked: /*Unimplemented*/Vec<gio::DBusProxy>) -> Result<i32, glib::Error> { + // unsafe { TODO: call ffi:secret_service_lock_sync() } + //} + + //#[doc(alias = "secret_service_lookup_sync")] + //fn lookup_sync(&self, schema: Option<&Schema>, attributes: /*Unknown conversion*//*Unimplemented*/HashTable TypeId { ns_id: 0, id: 28 }/TypeId { ns_id: 0, id: 28 }, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<Value, glib::Error> { + // unsafe { TODO: call ffi:secret_service_lookup_sync() } + //} + + #[doc(alias = "secret_service_prompt")] + fn prompt<P: FnOnce(Result<glib::Variant, glib::Error>) + 'static>( + &self, + prompt: &impl IsA<Prompt>, + return_type: Option<&glib::VariantTy>, + cancellable: Option<&impl IsA<gio::Cancellable>>, + callback: P, + ) { + let main_context = glib::MainContext::ref_thread_default(); + let is_main_context_owner = main_context.is_owner(); + let has_acquired_main_context = (!is_main_context_owner) + .then(|| main_context.acquire().ok()) + .flatten(); + assert!( + is_main_context_owner || has_acquired_main_context.is_some(), + "Async operations only allowed if the thread is owning the MainContext" + ); + + let user_data: Box_<glib::thread_guard::ThreadGuard<P>> = + Box_::new(glib::thread_guard::ThreadGuard::new(callback)); + unsafe extern "C" fn prompt_trampoline< + P: FnOnce(Result<glib::Variant, glib::Error>) + 'static, + >( + _source_object: *mut glib::gobject_ffi::GObject, + res: *mut gio::ffi::GAsyncResult, + user_data: glib::ffi::gpointer, + ) { + let mut error = std::ptr::null_mut(); + let ret = ffi::secret_service_prompt_finish(_source_object as *mut _, res, &mut error); + let result = if error.is_null() { + Ok(from_glib_full(ret)) + } else { + Err(from_glib_full(error)) + }; + 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 = prompt_trampoline::<P>; + unsafe { + ffi::secret_service_prompt( + self.as_ref().to_glib_none().0, + prompt.as_ref().to_glib_none().0, + return_type.to_glib_none().0, + cancellable.map(|p| p.as_ref()).to_glib_none().0, + Some(callback), + Box_::into_raw(user_data) as *mut _, + ); + } + } + + fn prompt_future( + &self, + prompt: &(impl IsA<Prompt> + Clone + 'static), + return_type: Option<&glib::VariantTy>, + ) -> Pin<Box_<dyn std::future::Future<Output = Result<glib::Variant, glib::Error>> + 'static>> + { + let prompt = prompt.clone(); + let return_type = return_type.map(ToOwned::to_owned); + Box_::pin(gio::GioFuture::new(self, move |obj, cancellable, send| { + obj.prompt( + &prompt, + return_type.as_ref().map(::std::borrow::Borrow::borrow), + Some(cancellable), + move |res| { + send.resolve(res); + }, + ); + })) + } + + #[doc(alias = "secret_service_prompt_at_dbus_path")] + fn prompt_at_dbus_path<P: FnOnce(Result<Option<glib::Variant>, glib::Error>) + 'static>( + &self, + prompt_path: &str, + return_type: Option<&glib::VariantTy>, + cancellable: Option<&impl IsA<gio::Cancellable>>, + callback: P, + ) { + let main_context = glib::MainContext::ref_thread_default(); + let is_main_context_owner = main_context.is_owner(); + let has_acquired_main_context = (!is_main_context_owner) + .then(|| main_context.acquire().ok()) + .flatten(); + assert!( + is_main_context_owner || has_acquired_main_context.is_some(), + "Async operations only allowed if the thread is owning the MainContext" + ); + + let user_data: Box_<glib::thread_guard::ThreadGuard<P>> = + Box_::new(glib::thread_guard::ThreadGuard::new(callback)); + unsafe extern "C" fn prompt_at_dbus_path_trampoline< + P: FnOnce(Result<Option<glib::Variant>, glib::Error>) + 'static, + >( + _source_object: *mut glib::gobject_ffi::GObject, + res: *mut gio::ffi::GAsyncResult, + user_data: glib::ffi::gpointer, + ) { + let mut error = std::ptr::null_mut(); + let ret = ffi::secret_service_prompt_at_dbus_path_finish( + _source_object as *mut _, + res, + &mut error, + ); + let result = if error.is_null() { + Ok(from_glib_full(ret)) + } else { + Err(from_glib_full(error)) + }; + 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 = prompt_at_dbus_path_trampoline::<P>; + unsafe { + ffi::secret_service_prompt_at_dbus_path( + self.as_ref().to_glib_none().0, + prompt_path.to_glib_none().0, + return_type.to_glib_none().0, + cancellable.map(|p| p.as_ref()).to_glib_none().0, + Some(callback), + Box_::into_raw(user_data) as *mut _, + ); + } + } + + fn prompt_at_dbus_path_future( + &self, + prompt_path: &str, + return_type: Option<&glib::VariantTy>, + ) -> Pin< + Box_< + dyn std::future::Future<Output = Result<Option<glib::Variant>, glib::Error>> + 'static, + >, + > { + let prompt_path = String::from(prompt_path); + let return_type = return_type.map(ToOwned::to_owned); + Box_::pin(gio::GioFuture::new(self, move |obj, cancellable, send| { + obj.prompt_at_dbus_path( + &prompt_path, + return_type.as_ref().map(::std::borrow::Borrow::borrow), + Some(cancellable), + move |res| { + send.resolve(res); + }, + ); + })) + } + + #[doc(alias = "secret_service_prompt_at_dbus_path_sync")] + fn prompt_at_dbus_path_sync( + &self, + prompt_path: &str, + cancellable: Option<&impl IsA<gio::Cancellable>>, + return_type: Option<&glib::VariantTy>, + ) -> Result<Option<glib::Variant>, glib::Error> { + unsafe { + let mut error = std::ptr::null_mut(); + let ret = ffi::secret_service_prompt_at_dbus_path_sync( + self.as_ref().to_glib_none().0, + prompt_path.to_glib_none().0, + cancellable.map(|p| p.as_ref()).to_glib_none().0, + return_type.to_glib_none().0, + &mut error, + ); + if error.is_null() { + Ok(from_glib_full(ret)) + } else { + Err(from_glib_full(error)) + } + } + } + + #[doc(alias = "secret_service_prompt_sync")] + fn prompt_sync( + &self, + prompt: &impl IsA<Prompt>, + cancellable: Option<&impl IsA<gio::Cancellable>>, + return_type: &glib::VariantTy, + ) -> Result<glib::Variant, glib::Error> { + unsafe { + let mut error = std::ptr::null_mut(); + let ret = ffi::secret_service_prompt_sync( + self.as_ref().to_glib_none().0, + prompt.as_ref().to_glib_none().0, + cancellable.map(|p| p.as_ref()).to_glib_none().0, + return_type.to_glib_none().0, + &mut error, + ); + if error.is_null() { + Ok(from_glib_full(ret)) + } else { + Err(from_glib_full(error)) + } + } + } + + #[doc(alias = "secret_service_read_alias_dbus_path")] + fn read_alias_dbus_path<P: FnOnce(Result<Option<glib::GString>, glib::Error>) + 'static>( + &self, + alias: &str, + cancellable: Option<&impl IsA<gio::Cancellable>>, + callback: P, + ) { + let main_context = glib::MainContext::ref_thread_default(); + let is_main_context_owner = main_context.is_owner(); + let has_acquired_main_context = (!is_main_context_owner) + .then(|| main_context.acquire().ok()) + .flatten(); + assert!( + is_main_context_owner || has_acquired_main_context.is_some(), + "Async operations only allowed if the thread is owning the MainContext" + ); + + let user_data: Box_<glib::thread_guard::ThreadGuard<P>> = + Box_::new(glib::thread_guard::ThreadGuard::new(callback)); + unsafe extern "C" fn read_alias_dbus_path_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 error = std::ptr::null_mut(); + let ret = ffi::secret_service_read_alias_dbus_path_finish( + _source_object as *mut _, + res, + &mut error, + ); + let result = if error.is_null() { + Ok(from_glib_full(ret)) + } else { + Err(from_glib_full(error)) + }; + 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 = read_alias_dbus_path_trampoline::<P>; + unsafe { + ffi::secret_service_read_alias_dbus_path( + self.as_ref().to_glib_none().0, + alias.to_glib_none().0, + cancellable.map(|p| p.as_ref()).to_glib_none().0, + Some(callback), + Box_::into_raw(user_data) as *mut _, + ); + } + } + + fn read_alias_dbus_path_future( + &self, + alias: &str, + ) -> Pin< + Box_< + dyn std::future::Future<Output = Result<Option<glib::GString>, glib::Error>> + 'static, + >, + > { + let alias = String::from(alias); + Box_::pin(gio::GioFuture::new(self, move |obj, cancellable, send| { + obj.read_alias_dbus_path(&alias, Some(cancellable), move |res| { + send.resolve(res); + }); + })) + } + + #[doc(alias = "secret_service_read_alias_dbus_path_sync")] + fn read_alias_dbus_path_sync( + &self, + alias: &str, + cancellable: Option<&impl IsA<gio::Cancellable>>, + ) -> Result<Option<glib::GString>, glib::Error> { + unsafe { + let mut error = std::ptr::null_mut(); + let ret = ffi::secret_service_read_alias_dbus_path_sync( + self.as_ref().to_glib_none().0, + alias.to_glib_none().0, + cancellable.map(|p| p.as_ref()).to_glib_none().0, + &mut error, + ); + if error.is_null() { + Ok(from_glib_full(ret)) + } else { + Err(from_glib_full(error)) + } + } + } + + //#[doc(alias = "secret_service_search_for_dbus_paths_sync")] + //fn search_for_dbus_paths_sync(&self, schema: Option<&Schema>, attributes: /*Unknown conversion*//*Unimplemented*/HashTable TypeId { ns_id: 0, id: 28 }/TypeId { ns_id: 0, id: 28 }, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(Vec<glib::GString>, Vec<glib::GString>), glib::Error> { + // unsafe { TODO: call ffi:secret_service_search_for_dbus_paths_sync() } + //} + + //#[doc(alias = "secret_service_search_sync")] + //fn search_sync(&self, schema: Option<&Schema>, attributes: /*Unknown conversion*//*Unimplemented*/HashTable TypeId { ns_id: 0, id: 28 }/TypeId { ns_id: 0, id: 28 }, flags: SearchFlags, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<Vec<Item>, glib::Error> { + // unsafe { TODO: call ffi:secret_service_search_sync() } + //} + + #[doc(alias = "secret_service_set_alias")] + fn set_alias<P: FnOnce(Result<(), glib::Error>) + 'static>( + &self, + alias: &str, + collection: Option<&impl IsA<Collection>>, + cancellable: Option<&impl IsA<gio::Cancellable>>, + callback: P, + ) { + let main_context = glib::MainContext::ref_thread_default(); + let is_main_context_owner = main_context.is_owner(); + let has_acquired_main_context = (!is_main_context_owner) + .then(|| main_context.acquire().ok()) + .flatten(); + assert!( + is_main_context_owner || has_acquired_main_context.is_some(), + "Async operations only allowed if the thread is owning the MainContext" + ); + + let user_data: Box_<glib::thread_guard::ThreadGuard<P>> = + Box_::new(glib::thread_guard::ThreadGuard::new(callback)); + unsafe extern "C" fn set_alias_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 = std::ptr::null_mut(); + let _ = ffi::secret_service_set_alias_finish(_source_object as *mut _, res, &mut error); + let result = if error.is_null() { + Ok(()) + } else { + Err(from_glib_full(error)) + }; + 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 = set_alias_trampoline::<P>; + unsafe { + ffi::secret_service_set_alias( + self.as_ref().to_glib_none().0, + alias.to_glib_none().0, + collection.map(|p| p.as_ref()).to_glib_none().0, + cancellable.map(|p| p.as_ref()).to_glib_none().0, + Some(callback), + Box_::into_raw(user_data) as *mut _, + ); + } + } + + fn set_alias_future( + &self, + alias: &str, + collection: Option<&(impl IsA<Collection> + Clone + 'static)>, + ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> { + let alias = String::from(alias); + let collection = collection.map(ToOwned::to_owned); + Box_::pin(gio::GioFuture::new(self, move |obj, cancellable, send| { + obj.set_alias( + &alias, + collection.as_ref().map(::std::borrow::Borrow::borrow), + Some(cancellable), + move |res| { + send.resolve(res); + }, + ); + })) + } + + #[doc(alias = "secret_service_set_alias_sync")] + fn set_alias_sync( + &self, + alias: &str, + collection: Option<&impl IsA<Collection>>, + cancellable: Option<&impl IsA<gio::Cancellable>>, + ) -> Result<(), glib::Error> { + unsafe { + let mut error = std::ptr::null_mut(); + let is_ok = ffi::secret_service_set_alias_sync( + self.as_ref().to_glib_none().0, + alias.to_glib_none().0, + collection.map(|p| p.as_ref()).to_glib_none().0, + cancellable.map(|p| p.as_ref()).to_glib_none().0, + &mut error, + ); + debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null()); + if error.is_null() { + Ok(()) + } else { + Err(from_glib_full(error)) + } + } + } + + #[doc(alias = "secret_service_set_alias_to_dbus_path")] + fn set_alias_to_dbus_path<P: FnOnce(Result<(), glib::Error>) + 'static>( + &self, + alias: &str, + collection_path: Option<&str>, + cancellable: Option<&impl IsA<gio::Cancellable>>, + callback: P, + ) { + let main_context = glib::MainContext::ref_thread_default(); + let is_main_context_owner = main_context.is_owner(); + let has_acquired_main_context = (!is_main_context_owner) + .then(|| main_context.acquire().ok()) + .flatten(); + assert!( + is_main_context_owner || has_acquired_main_context.is_some(), + "Async operations only allowed if the thread is owning the MainContext" + ); + + let user_data: Box_<glib::thread_guard::ThreadGuard<P>> = + Box_::new(glib::thread_guard::ThreadGuard::new(callback)); + unsafe extern "C" fn set_alias_to_dbus_path_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 = std::ptr::null_mut(); + let _ = ffi::secret_service_set_alias_to_dbus_path_finish( + _source_object as *mut _, + res, + &mut error, + ); + let result = if error.is_null() { + Ok(()) + } else { + Err(from_glib_full(error)) + }; + 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 = set_alias_to_dbus_path_trampoline::<P>; + unsafe { + ffi::secret_service_set_alias_to_dbus_path( + self.as_ref().to_glib_none().0, + alias.to_glib_none().0, + collection_path.to_glib_none().0, + cancellable.map(|p| p.as_ref()).to_glib_none().0, + Some(callback), + Box_::into_raw(user_data) as *mut _, + ); + } + } + + fn set_alias_to_dbus_path_future( + &self, + alias: &str, + collection_path: Option<&str>, + ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> { + let alias = String::from(alias); + let collection_path = collection_path.map(ToOwned::to_owned); + Box_::pin(gio::GioFuture::new(self, move |obj, cancellable, send| { + obj.set_alias_to_dbus_path( + &alias, + collection_path.as_ref().map(::std::borrow::Borrow::borrow), + Some(cancellable), + move |res| { + send.resolve(res); + }, + ); + })) + } + + #[doc(alias = "secret_service_set_alias_to_dbus_path_sync")] + fn set_alias_to_dbus_path_sync( + &self, + alias: &str, + collection_path: Option<&str>, + cancellable: Option<&impl IsA<gio::Cancellable>>, + ) -> Result<(), glib::Error> { + unsafe { + let mut error = std::ptr::null_mut(); + let is_ok = ffi::secret_service_set_alias_to_dbus_path_sync( + self.as_ref().to_glib_none().0, + alias.to_glib_none().0, + collection_path.to_glib_none().0, + cancellable.map(|p| p.as_ref()).to_glib_none().0, + &mut error, + ); + debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null()); + if error.is_null() { + Ok(()) + } else { + Err(from_glib_full(error)) + } + } + } + + //#[doc(alias = "secret_service_store_sync")] + //fn store_sync(&self, schema: Option<&Schema>, attributes: /*Unknown conversion*//*Unimplemented*/HashTable TypeId { ns_id: 0, id: 28 }/TypeId { ns_id: 0, id: 28 }, collection: Option<&str>, label: &str, value: &Value, cancellable: Option<&impl IsA<gio::Cancellable>>) -> Result<(), glib::Error> { + // unsafe { TODO: call ffi:secret_service_store_sync() } + //} + + #[doc(alias = "secret_service_unlock_dbus_paths_sync")] + fn unlock_dbus_paths_sync( + &self, + paths: &[&str], + cancellable: Option<&impl IsA<gio::Cancellable>>, + ) -> Result<(i32, Vec<glib::GString>), glib::Error> { + unsafe { + let mut unlocked = std::ptr::null_mut(); + let mut error = std::ptr::null_mut(); + let ret = ffi::secret_service_unlock_dbus_paths_sync( + self.as_ref().to_glib_none().0, + paths.to_glib_none().0, + cancellable.map(|p| p.as_ref()).to_glib_none().0, + &mut unlocked, + &mut error, + ); + if error.is_null() { + Ok((ret, FromGlibPtrContainer::from_glib_full(unlocked))) + } else { + Err(from_glib_full(error)) + } + } + } + + //#[doc(alias = "secret_service_unlock_sync")] + //fn unlock_sync(&self, objects: &[gio::DBusProxy], cancellable: Option<&impl IsA<gio::Cancellable>>, unlocked: /*Unimplemented*/Vec<gio::DBusProxy>) -> Result<i32, glib::Error> { + // unsafe { TODO: call ffi:secret_service_unlock_sync() } + //} +} + +impl<O: IsA<Service>> ServiceExt for O {} diff --git a/libsecret/src/auto/versions.txt b/libsecret/src/auto/versions.txt new file mode 100644 index 0000000..21d9cc7 --- /dev/null +++ b/libsecret/src/auto/versions.txt @@ -0,0 +1,3 @@ +Generated by gir (https://github.com/gtk-rs/gir @ 4dd714f7f3b1) +from +from gir-files (https://github.com/gtk-rs/gir-files.git @ b9db716f1bb7) 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<P: FnOnce(Result<Vec<Item>, glib::Error>) + 'static>( + &self, + schema: Option<&Schema>, + attributes: HashMap<&str, &str>, + flags: SearchFlags, + cancellable: Option<&impl IsA<gio::Cancellable>>, + callback: P, + ); + + fn search_future( + &self, + schema: Option<&Schema>, + attributes: HashMap<&str, &str>, + flags: SearchFlags, + ) -> Pin<Box_<dyn std::future::Future<Output = Result<Vec<Item>, 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<gio::Cancellable>>, + ) -> Result<Vec<Item>, glib::Error>; + + #[doc(alias = "secret_collection_search_for_dbus_paths")] + fn search_for_dbus_paths<P: FnOnce(Result<Vec<glib::GString>, glib::Error>) + 'static>( + &self, + schema: Option<&Schema>, + attributes: HashMap<&str, &str>, + cancellable: Option<&impl IsA<gio::Cancellable>>, + callback: P, + ); + + fn search_for_dbus_paths_future( + &self, + schema: Option<&Schema>, + attributes: HashMap<&str, &str>, + ) -> Pin< + Box_<dyn std::future::Future<Output = Result<Vec<glib::GString>, 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<gio::Cancellable>>, + ) -> Result<Vec<glib::GString>, glib::Error>; +} + +impl<O: IsA<Collection>> CollectionExtManual for O { + fn search<P: FnOnce(Result<Vec<Item>, glib::Error>) + 'static>( + &self, + schema: Option<&Schema>, + attributes: HashMap<&str, &str>, + flags: SearchFlags, + cancellable: Option<&impl IsA<gio::Cancellable>>, + callback: P, + ) { + unsafe { + let user_data: Box_<glib::thread_guard::ThreadGuard<P>> = + Box_::new(glib::thread_guard::ThreadGuard::new(callback)); + unsafe extern "C" fn search_trampoline< + P: FnOnce(Result<Vec<Item>, 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_<glib::thread_guard::ThreadGuard<P>> = + Box_::from_raw(user_data as *mut _); + let callback: P = callback.into_inner(); + callback(result); + } + let callback = search_trampoline::<P>; + + 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<Box_<dyn std::future::Future<Output = Result<Vec<Item>, 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::<HashMap<String, String>>(); + + 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::<HashMap<&str, &str>>(); + + 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<gio::Cancellable>>, + ) -> Result<Vec<Item>, 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<gio::Cancellable>>, + ) -> Result<Vec<glib::GString>, 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<P: FnOnce(Result<Vec<glib::GString>, glib::Error>) + 'static>( + &self, + schema: Option<&Schema>, + attributes: HashMap<&str, &str>, + cancellable: Option<&impl IsA<gio::Cancellable>>, + callback: P, + ) { + unsafe { + let user_data: Box_<glib::thread_guard::ThreadGuard<P>> = + Box_::new(glib::thread_guard::ThreadGuard::new(callback)); + unsafe extern "C" fn search_trampoline< + P: FnOnce(Result<Vec<glib::GString>, 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_<glib::thread_guard::ThreadGuard<P>> = + Box_::from_raw(user_data as *mut _); + let callback: P = callback.into_inner(); + callback(result); + } + let callback = search_trampoline::<P>; + + 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_<dyn std::future::Future<Output = Result<Vec<glib::GString>, 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::<HashMap<String, String>>(); + + 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::<HashMap<&str, &str>>(); + + obj.search_for_dbus_paths( + schema.as_ref().map(::std::borrow::Borrow::borrow), + attributes, + Some(cancellable), + move |res| { + send.resolve(res); + }, + ); + })) + } +} diff --git a/libsecret/src/enums.rs b/libsecret/src/enums.rs new file mode 100644 index 0000000..59de400 --- /dev/null +++ b/libsecret/src/enums.rs @@ -0,0 +1,25 @@ +use glib::error::ErrorDomain; +use glib::translate::*; + +use crate::Error; + +impl ErrorDomain for Error { + fn domain() -> glib::Quark { + unsafe { from_glib(ffi::secret_error_get_quark()) } + } + + fn code(self) -> i32 { + self.into_glib() + } + + fn from(code: i32) -> Option<Self> { + match code { + ffi::SECRET_ERROR_PROTOCOL => Some(Self::Protocol), + ffi::SECRET_ERROR_IS_LOCKED => Some(Self::IsLocked), + ffi::SECRET_ERROR_NO_SUCH_OBJECT => Some(Self::NoSuchObject), + ffi::SECRET_ERROR_ALREADY_EXISTS => Some(Self::AlreadyExists), + ffi::SECRET_ERROR_INVALID_FILE_FORMAT => Some(Self::InvalidFileFormat), + value => Some(Self::__Unknown(value)), + } + } +} 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 +} diff --git a/libsecret/src/hashtable.rs b/libsecret/src/hashtable.rs new file mode 100644 index 0000000..1f42c95 --- /dev/null +++ b/libsecret/src/hashtable.rs @@ -0,0 +1,63 @@ +use glib::translate::*; +use std::collections::HashMap; + +use crate::Value; + +pub(crate) unsafe fn attribute_names_and_values( + entry: HashMap<&str, &str>, +) -> *mut glib::ffi::GHashTable { + let hash_table = glib::ffi::g_hash_table_new_full( + Some(glib::ffi::g_str_hash), + Some(glib::ffi::g_str_equal), + Some(glib::ffi::g_free), + Some(glib::ffi::g_free), + ); + + for (key, val) in entry { + let key_ptr: *mut libc::c_char = key.to_glib_full(); + let val_ptr: *mut libc::c_char = val.to_glib_full(); + glib::ffi::g_hash_table_insert(hash_table, key_ptr as *mut _, val_ptr as *mut _); + } + + hash_table +} + +pub(crate) unsafe fn attribute_names_and_properties( + hash_map: HashMap<&str, &glib::Variant>, +) -> *mut glib::ffi::GHashTable { + let hash_table = glib::ffi::g_hash_table_new_full( + Some(glib::ffi::g_str_hash), + Some(glib::ffi::g_str_equal), + Some(glib::ffi::g_free), + Some(glib::ffi::g_free), + ); + + for (name, value) in hash_map { + let key_ptr: *mut libc::c_char = name.to_glib_full(); + glib::ffi::g_hash_table_insert(hash_table, key_ptr as *mut _, value.as_ptr() as _); + } + + hash_table +} + +pub(crate) unsafe fn hash_map_from_glib_none( + ptr: *mut glib::ffi::GHashTable, +) -> HashMap<String, Value> { + unsafe extern "C" fn read_string_hash_table( + key: glib::ffi::gpointer, + value: glib::ffi::gpointer, + hash_map: glib::ffi::gpointer, + ) { + let key: String = from_glib_none(key as *const libc::c_char); + let value: Value = from_glib_none(value as *const ffi::SecretValue); + let hash_map: &mut HashMap<String, Value> = &mut *(hash_map as *mut HashMap<String, Value>); + hash_map.insert(key, value); + } + let mut map = HashMap::with_capacity(glib::ffi::g_hash_table_size(ptr) as usize); + glib::ffi::g_hash_table_foreach( + ptr, + Some(read_string_hash_table), + &mut map as *mut HashMap<String, Value> as *mut _, + ); + map +} diff --git a/libsecret/src/item.rs b/libsecret/src/item.rs new file mode 100644 index 0000000..0d0d97f --- /dev/null +++ b/libsecret/src/item.rs @@ -0,0 +1,314 @@ +// 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, ItemCreateFlags, Schema, Value}; + +use glib::object::IsA; +use glib::translate::*; + +use std::boxed::Box as Box_; +use std::collections::HashMap; +use std::pin::Pin; +use std::ptr; + +impl Item { + #[doc(alias = "secret_item_get_attributes")] + pub fn attributes(&self) -> HashMap<String, String> { + unsafe { + let table = ffi::secret_item_get_attributes(self.to_glib_none().0); + FromGlibPtrContainer::from_glib_full(table) + } + } + + #[doc(alias = "secret_item_create_sync")] + pub fn create_sync( + collection: &impl IsA<Collection>, + schema: Option<&Schema>, + attributes: HashMap<&str, &str>, + label: &str, + value: &Value, + flags: ItemCreateFlags, + cancellable: Option<&impl IsA<gio::Cancellable>>, + ) -> Result<Self, glib::Error> { + unsafe { + let mut err = std::ptr::null_mut(); + let item = ffi::secret_item_create_sync( + collection.as_ref().to_glib_none().0, + schema.to_glib_none().0, + attribute_names_and_values(attributes), + label.to_glib_none().0, + value.to_glib_none().0, + flags.into_glib(), + cancellable.map(|p| p.as_ref()).to_glib_none().0, + &mut err, + ); + if err.is_null() { + Ok(from_glib_full(item)) + } else { + Err(from_glib_full(err)) + } + } + } + + #[doc(alias = "secret_item_load_secrets_sync")] + pub fn load_secrets_sync( + items: &[Item], + cancellable: Option<&impl IsA<gio::Cancellable>>, + ) -> Result<(), glib::Error> { + unsafe { + let mut error = ptr::null_mut(); + let is_ok = ffi::secret_item_load_secrets_sync( + items.to_glib_none().0, + cancellable.map(|p| p.as_ref()).to_glib_none().0, + &mut error, + ); + assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null()); + if error.is_null() { + Ok(()) + } else { + Err(from_glib_full(error)) + } + } + } + + #[doc(alias = "secret_item_load_secrets")] + pub fn load_secrets<P: FnOnce(Result<(), glib::Error>) + 'static>( + items: &[Item], + cancellable: Option<&impl IsA<gio::Cancellable>>, + callback: P, + ) { + let main_context = glib::MainContext::ref_thread_default(); + let is_main_context_owner = main_context.is_owner(); + let has_acquired_main_context = (!is_main_context_owner) + .then(|| main_context.acquire().ok()) + .flatten(); + assert!( + is_main_context_owner || has_acquired_main_context.is_some(), + "Async operations only allowed if the thread is owning the MainContext" + ); + + let user_data: Box_<glib::thread_guard::ThreadGuard<P>> = + Box_::new(glib::thread_guard::ThreadGuard::new(callback)); + unsafe extern "C" fn load_secrets_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 _ = ffi::secret_item_load_secrets_finish(res, &mut error); + let result = if error.is_null() { + Ok(()) + } else { + Err(from_glib_full(error)) + }; + 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 = load_secrets_trampoline::<P>; + unsafe { + ffi::secret_item_load_secrets( + items.to_glib_none().0, + cancellable.map(|p| p.as_ref()).to_glib_none().0, + Some(callback), + Box_::into_raw(user_data) as *mut _, + ); + } + } + + pub fn load_secrets_future( + items: &[Item], + ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> { + let items = items.to_vec(); + Box_::pin(gio::GioFuture::new(&(), move |_obj, cancellable, send| { + Self::load_secrets(&items, Some(cancellable), move |res| { + send.resolve(res); + }); + })) + } + + #[doc(alias = "secret_item_create")] + pub fn create<P: FnOnce(Result<Item, glib::Error>) + 'static>( + collection: &impl IsA<Collection>, + schema: Option<&Schema>, + attributes: HashMap<&str, &str>, + label: &str, + value: &Value, + flags: ItemCreateFlags, + cancellable: Option<&impl IsA<gio::Cancellable>>, + callback: P, + ) { + unsafe { + let user_data: Box_<glib::thread_guard::ThreadGuard<P>> = + Box_::new(glib::thread_guard::ThreadGuard::new(callback)); + unsafe extern "C" fn create_trampoline< + P: FnOnce(Result<Item, 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_item_create_finish(res, &mut error); + let result = if error.is_null() { + Ok(from_glib_full(ret)) + } else { + Err(from_glib_full(error)) + }; + 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 = create_trampoline::<P>; + + ffi::secret_item_create( + collection.as_ref().to_glib_none().0, + schema.to_glib_none().0, + attribute_names_and_values(attributes), + label.to_glib_none().0, + value.to_glib_none().0, + flags.into_glib(), + cancellable.map(|p| p.as_ref()).to_glib_none().0, + Some(callback), + Box_::into_raw(user_data) as *mut _, + ); + } + } + + pub fn create_future( + collection: &(impl IsA<Collection> + Clone + 'static), + schema: Option<&Schema>, + attributes: HashMap<String, &str>, + label: &str, + value: &Value, + flags: ItemCreateFlags, + ) -> Pin<Box_<dyn std::future::Future<Output = Result<Item, glib::Error>> + 'static>> { + let collection = collection.clone(); + let schema = schema.map(ToOwned::to_owned); + let label = String::from(label); + let value = value.clone(); + let owned_map = attributes + .into_iter() + .map(|(k, v)| (k, v.to_string())) + .collect::<HashMap<String, String>>(); + + Box_::pin(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>>(); + Self::create( + &collection, + schema.as_ref().map(::std::borrow::Borrow::borrow), + attributes, + &label, + &value, + flags, + Some(cancellable), + move |res| { + send.resolve(res); + }, + ); + })) + } + + #[doc(alias = "secret_item_set_attributes")] + pub fn set_attributes<P: FnOnce(Result<(), glib::Error>) + 'static>( + &self, + schema: Option<&Schema>, + attributes: HashMap<&str, &str>, + cancellable: Option<&impl IsA<gio::Cancellable>>, + callback: P, + ) { + unsafe { + let user_data: Box_<glib::thread_guard::ThreadGuard<P>> = + Box_::new(glib::thread_guard::ThreadGuard::new(callback)); + unsafe extern "C" fn set_attributes_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 = ptr::null_mut(); + let _ = + ffi::secret_item_set_attributes_finish(source_object as *mut _, 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 = set_attributes_trampoline::<P>; + + ffi::secret_item_set_attributes( + self.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 _, + ); + } + } + + pub fn set_attributes_future( + &self, + schema: Option<&Schema>, + attributes: HashMap<&str, &str>, + ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), 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::<HashMap<String, String>>(); + 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::<HashMap<&str, &str>>(); + obj.set_attributes( + schema.as_ref().map(::std::borrow::Borrow::borrow), + attributes, + Some(cancellable), + move |res| { + send.resolve(res); + }, + ); + })) + } + + #[doc(alias = "secret_item_set_attributes_sync")] + pub fn set_attributes_sync( + &self, + 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_item_set_attributes_sync( + self.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(()) + } else { + Err(from_glib_full(err)) + } + } + } +} diff --git a/libsecret/src/lib.rs b/libsecret/src/lib.rs new file mode 100644 index 0000000..8d4c306 --- /dev/null +++ b/libsecret/src/lib.rs @@ -0,0 +1,123 @@ +#![cfg_attr(feature = "dox", feature(doc_cfg))] +//! # Rust Libsecret bindings +//! +//! This library contains safe Rust bindings for +//! [Libsecret](https://gitlab.gnome.org/GNOME/libsecret/), a library that +//! offers access to the Secret Service API. +//! +//! See also +//! +//! - [gtk-rs project overview](https://gtk-rs.org/) +//! +//! ## Usage +//! +//! You can add libsecret by adding it in your `Cargo.toml` file: +//! +//! ```toml +//! [dependencies.secret] +//! package = "libsecret" +//! version = "0.x.y" +//! ``` +//! +//! ### Define a password schema +//! +//! Each stored password has a set of attributes which are later used to lookup +//! the password. The names and types of the attributes are defined in a schema. +//! The schema is usually defined once globally. Here’s how to define a schema: +//! +//! ```no_run +//! let mut attributes = std::collections::HashMap::new(); +//! attributes.insert("number", libsecret::SchemaAttributeType::Integer); +//! attributes.insert("string", libsecret::SchemaAttributeType::String); +//! attributes.insert("even", libsecret::SchemaAttributeType::Boolean); +//! +//! let schema = libsecret::Schema::new("some.app.Id", libsecret::SchemaFlags::NONE, attributes); +//! ``` +//! +//! ### Store a password +//! +//! Each stored password has a set of attributes which are later used to lookup +//! the password. The attributes should not contain secrets, as they are not +//! stored in an encrypted fashion. +//! +//! This first example stores a password asynchronously, and is appropriate for GUI applications so that the UI does not block. +//! +//! ```no_run +//! let mut attributes = std::collections::HashMap::new(); +//! attributes.insert("number", "8"); +//! attributes.insert("string", "eight"); +//! attributes.insert("even", "true"); +//! +//! let collection = libsecret::COLLECTION_DEFAULT; +//! libsecret::password_store_future(Some(&schema), attributes, Some(&collection), "The Label", "the password").await?; +//! ``` +//! +//! ### Lookup a password +//! +//! Each stored password has a set of attributes which are used to lookup the +//! password. If multiple passwords match the lookup attributes, then the one +//! stored most recently is returned. +//! +//! This first example looks up a password asynchronously, and is appropriate +//! for GUI applications so that the UI does not block. +//! +//! ```no_run +//! let mut attributes = std::collections::HashMap::new(); +//! attributes.insert("number", "8"); +//! attributes.insert("even", "true"); +//! +//! let password = libsecret::password_lookup_future(Some(&schema), attributes).await?; +//! ``` +//! ### Remove a password +//! +//! Each stored password has a set of attributes which are used to find which +//! password to remove. If multiple passwords match the attributes, then the one +//! stored most recently is removed. +//! +//! This first example removes a password asynchronously, and is appropriate for +//! GUI applications so that the UI does not block. +//! +//! ```no_run +//! let mut attributes = std::collections::HashMap::new(); +//! attributes.insert("number", "8"); +//! attributes.insert("even", "true"); +//! +//! libsecret::password_clear_future(Some(&schema), attributes).await?; +//! ``` +#[allow(unused_imports)] +mod auto; + +pub use auto::functions::*; +pub use auto::*; +pub use functions::*; + +mod collection; +mod enums; +mod functions; +mod hashtable; +#[allow(clippy::too_many_arguments)] +mod item; +mod prompt; +#[cfg(any(feature = "v0_19", feature = "dox"))] +#[cfg_attr(feature = "dox", doc(cfg(feature = "v0_19")))] +mod retrievable; +mod schema; +mod schema_attribute; +#[allow(clippy::type_complexity)] +#[allow(clippy::too_many_arguments)] +mod service; +mod value; + +pub use value::Value; + +pub use ffi; + +pub mod prelude { + pub use super::auto::traits::*; + pub use super::collection::CollectionExtManual; + pub use super::prompt::PromptExtManual; + #[cfg(any(feature = "v0_19", feature = "dox"))] + #[cfg_attr(feature = "dox", doc(cfg(feature = "v0_19")))] + pub use super::retrievable::RetrievableExtManual; + pub use super::service::ServiceExtManual; +} diff --git a/libsecret/src/prompt.rs b/libsecret/src/prompt.rs new file mode 100644 index 0000000..bfb7845 --- /dev/null +++ b/libsecret/src/prompt.rs @@ -0,0 +1,100 @@ +// Take a look at the license at the top of the repository in the LICENSE file. + +use crate::Prompt; + +use glib::object::IsA; +use glib::translate::*; + +use std::boxed::Box as Box_; +use std::pin::Pin; +use std::ptr; + +pub trait PromptExtManual: 'static { + #[doc(alias = "secret_prompt_perform")] + fn perform<P: FnOnce(Result<glib::Variant, glib::Error>) + 'static>( + &self, + window_id: Option<&str>, + return_type: &glib::VariantTy, + cancellable: Option<&impl IsA<gio::Cancellable>>, + callback: P, + ); + + fn perform_future( + &self, + window_id: Option<&str>, + return_type: &glib::VariantTy, + ) -> Pin<Box_<dyn std::future::Future<Output = Result<glib::Variant, glib::Error>> + 'static>>; +} + +impl<O: IsA<Prompt>> PromptExtManual for O { + fn perform<P: FnOnce(Result<glib::Variant, glib::Error>) + 'static>( + &self, + window_id: Option<&str>, + return_type: &glib::VariantTy, + cancellable: Option<&impl IsA<gio::Cancellable>>, + callback: P, + ) { + let main_context = glib::MainContext::ref_thread_default(); + let is_main_context_owner = main_context.is_owner(); + let has_acquired_main_context = (!is_main_context_owner) + .then(|| main_context.acquire().ok()) + .flatten(); + assert!( + is_main_context_owner || has_acquired_main_context.is_some(), + "Async operations only allowed if the thread is owning the MainContext" + ); + + let user_data: Box_<glib::thread_guard::ThreadGuard<P>> = + Box_::new(glib::thread_guard::ThreadGuard::new(callback)); + unsafe extern "C" fn perform_trampoline< + P: FnOnce(Result<glib::Variant, 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_prompt_perform_finish(_source_object as *mut _, res, &mut error); + let result = if error.is_null() { + Ok(from_glib_full(ret)) + } else { + Err(from_glib_full(error)) + }; + 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 = perform_trampoline::<P>; + unsafe { + ffi::secret_prompt_perform( + self.as_ref().to_glib_none().0, + window_id.to_glib_none().0, + return_type.to_glib_none().0, + cancellable.map(|p| p.as_ref()).to_glib_none().0, + Some(callback), + Box_::into_raw(user_data) as *mut _, + ); + } + } + + fn perform_future( + &self, + window_id: Option<&str>, + return_type: &glib::VariantTy, + ) -> Pin<Box_<dyn std::future::Future<Output = Result<glib::Variant, glib::Error>> + 'static>> + { + let window_id = window_id.map(ToOwned::to_owned); + let return_type = return_type.to_owned(); + Box_::pin(gio::GioFuture::new(self, move |obj, cancellable, send| { + obj.perform( + window_id.as_ref().map(::std::borrow::Borrow::borrow), + &return_type, + Some(cancellable), + move |res| { + send.resolve(res); + }, + ); + })) + } +} diff --git a/libsecret/src/retrievable.rs b/libsecret/src/retrievable.rs new file mode 100644 index 0000000..617d8e3 --- /dev/null +++ b/libsecret/src/retrievable.rs @@ -0,0 +1,20 @@ +use std::collections::HashMap; + +use crate::Retrievable; +use glib::object::IsA; +use glib::translate::*; + +pub trait RetrievableExtManual: 'static { + #[doc(alias = "secret_retrievable_get_attributes")] + #[doc(alias = "get_attributes")] + fn attributes(&self) -> HashMap<String, String>; +} + +impl<O: IsA<Retrievable>> RetrievableExtManual for O { + fn attributes(&self) -> HashMap<String, String> { + unsafe { + let table = ffi::secret_retrievable_get_attributes(self.as_ref().to_glib_none().0); + FromGlibPtrContainer::from_glib_full(table) + } + } +} diff --git a/libsecret/src/schema.rs b/libsecret/src/schema.rs new file mode 100644 index 0000000..b3252e2 --- /dev/null +++ b/libsecret/src/schema.rs @@ -0,0 +1,37 @@ +use crate::{Schema, SchemaAttributeType, SchemaFlags}; +use glib::translate::*; +use std::collections::HashMap; + +impl Schema { + #[doc(alias = "secret_schema_new")] + #[doc(alias = "secret_schema_newv")] + pub fn new( + name: &str, + flags: SchemaFlags, + attribute_names_and_types: HashMap<&str, SchemaAttributeType>, + ) -> Self { + unsafe { + let hash_table = glib::ffi::g_hash_table_new_full( + Some(glib::ffi::g_str_hash), + Some(glib::ffi::g_str_equal), + Some(glib::ffi::g_free), + None, + ); + + for (name, type_) in attribute_names_and_types { + let key_ptr: *mut libc::c_char = name.to_glib_full(); + glib::ffi::g_hash_table_insert( + hash_table, + key_ptr as *mut _, + type_.into_glib() as *mut _, + ); + } + + from_glib_full(ffi::secret_schema_newv( + name.to_glib_none().0, + flags.into_glib(), + hash_table, + )) + } + } +} diff --git a/libsecret/src/schema_attribute.rs b/libsecret/src/schema_attribute.rs new file mode 100644 index 0000000..562381a --- /dev/null +++ b/libsecret/src/schema_attribute.rs @@ -0,0 +1,12 @@ +use crate::{SchemaAttribute, SchemaAttributeType}; +use glib::translate::*; + +impl SchemaAttribute { + pub fn type_(&self) -> SchemaAttributeType { + unsafe { from_glib((*(self.as_ptr())).type_) } + } + + pub fn name(&self) -> glib::GString { + unsafe { from_glib_none((*(self.as_ptr())).name) } + } +} diff --git a/libsecret/src/service.rs b/libsecret/src/service.rs new file mode 100644 index 0000000..2175667 --- /dev/null +++ b/libsecret/src/service.rs @@ -0,0 +1,1147 @@ +// Take a look at the license at the top of the repository in the LICENSE file. + +use crate::{ + hashtable::{attribute_names_and_properties, attribute_names_and_values}, + Service, +}; +use crate::{CollectionCreateFlags, Item, ItemCreateFlags, Schema, SearchFlags, Value}; + +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 ServiceExtManual: 'static { + #[doc(alias = "secret_service_lock")] + fn lock<P: FnOnce(Result<Vec<gio::DBusProxy>, glib::Error>) + 'static>( + &self, + objects: &[gio::DBusProxy], + cancellable: Option<&impl IsA<gio::Cancellable>>, + callback: P, + ); + + fn lock_future( + &self, + objects: &[gio::DBusProxy], + ) -> Pin< + Box_<dyn std::future::Future<Output = Result<Vec<gio::DBusProxy>, glib::Error>> + 'static>, + >; + + #[doc(alias = "secret_service_lock_dbus_paths")] + fn lock_dbus_paths<P: FnOnce(Result<Vec<glib::GString>, glib::Error>) + 'static>( + &self, + paths: &[&str], + cancellable: Option<&impl IsA<gio::Cancellable>>, + callback: P, + ); + + fn lock_dbus_paths_future( + &self, + paths: &[&str], + ) -> Pin< + Box_<dyn std::future::Future<Output = Result<Vec<glib::GString>, glib::Error>> + 'static>, + >; + + #[doc(alias = "secret_service_lock_dbus_paths_sync")] + fn lock_dbus_paths_sync( + &self, + paths: Vec<&str>, + cancellable: Option<&impl IsA<gio::Cancellable>>, + ) -> Result<Vec<glib::GString>, glib::Error>; + + #[doc(alias = "secret_service_unlock")] + fn unlock<P: FnOnce(Result<Vec<gio::DBusProxy>, glib::Error>) + 'static>( + &self, + objects: &[gio::DBusProxy], + cancellable: Option<&impl IsA<gio::Cancellable>>, + callback: P, + ); + + fn unlock_future( + &self, + objects: &[gio::DBusProxy], + ) -> Pin< + Box_<dyn std::future::Future<Output = Result<Vec<gio::DBusProxy>, glib::Error>> + 'static>, + >; + + #[doc(alias = "secret_service_unlock_dbus_paths")] + fn unlock_dbus_paths<P: FnOnce(Result<Vec<glib::GString>, glib::Error>) + 'static>( + &self, + paths: &[&str], + cancellable: Option<&impl IsA<gio::Cancellable>>, + callback: P, + ); + + fn unlock_dbus_paths_future( + &self, + paths: &[&str], + ) -> Pin< + Box_<dyn std::future::Future<Output = Result<Vec<glib::GString>, glib::Error>> + 'static>, + >; + + #[doc(alias = "secret_service_store")] + fn store<P: FnOnce(Result<(), glib::Error>) + 'static>( + &self, + schema: Option<&Schema>, + attributes: HashMap<&str, &str>, + collection: Option<&str>, + label: &str, + value: &Value, + cancellable: Option<&impl IsA<gio::Cancellable>>, + callback: P, + ); + + fn store_future( + &self, + schema: Option<&Schema>, + attributes: HashMap<&str, &str>, + collection: Option<&str>, + label: &str, + value: &Value, + ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>>; + + #[doc(alias = "secret_service_search")] + fn search<P: FnOnce(Result<Vec<Item>, glib::Error>) + 'static>( + &self, + schema: Option<&Schema>, + attributes: HashMap<&str, &str>, + flags: SearchFlags, + cancellable: Option<&impl IsA<gio::Cancellable>>, + callback: P, + ); + + fn search_future( + &self, + schema: Option<&Schema>, + attributes: HashMap<&str, &str>, + flags: SearchFlags, + ) -> Pin<Box_<dyn std::future::Future<Output = Result<Vec<Item>, glib::Error>> + 'static>>; + + #[doc(alias = "secret_service_lookup")] + fn lookup<P: FnOnce(Result<Value, glib::Error>) + 'static>( + &self, + schema: Option<&Schema>, + attributes: HashMap<&str, &str>, + cancellable: Option<&impl IsA<gio::Cancellable>>, + callback: P, + ); + + fn lookup_future( + &self, + schema: Option<&Schema>, + attributes: HashMap<&str, &str>, + ) -> Pin<Box_<dyn std::future::Future<Output = Result<Value, glib::Error>> + 'static>>; + + #[doc(alias = "secret_service_clear")] + fn clear<P: FnOnce(Result<(), glib::Error>) + 'static>( + &self, + schema: Option<&Schema>, + attributes: HashMap<&str, &str>, + cancellable: Option<&impl IsA<gio::Cancellable>>, + callback: P, + ); + + fn clear_future( + &self, + schema: Option<&Schema>, + attributes: HashMap<&str, &str>, + ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>>; + + #[doc(alias = "secret_service_create_item_dbus_path")] + fn create_item_dbus_path<P: FnOnce(Result<glib::GString, glib::Error>) + 'static>( + &self, + collection_path: &str, + properties: HashMap<&str, &glib::Variant>, + value: &Value, + flags: ItemCreateFlags, + cancellable: Option<&impl IsA<gio::Cancellable>>, + callback: P, + ); + + fn create_item_dbus_path_future( + &self, + collection_path: &str, + properties: HashMap<&str, &glib::Variant>, + value: &Value, + flags: ItemCreateFlags, + ) -> Pin<Box_<dyn std::future::Future<Output = Result<glib::GString, glib::Error>> + 'static>>; + + #[doc(alias = "secret_service_create_collection_dbus_path")] + fn create_collection_dbus_path<P: FnOnce(Result<glib::GString, glib::Error>) + 'static>( + &self, + properties: HashMap<&str, &glib::Variant>, + alias: Option<&str>, + flags: CollectionCreateFlags, + cancellable: Option<&impl IsA<gio::Cancellable>>, + callback: P, + ); + + fn create_collection_dbus_path_future( + &self, + properties: HashMap<&str, &glib::Variant>, + alias: Option<&str>, + flags: CollectionCreateFlags, + ) -> Pin<Box_<dyn std::future::Future<Output = Result<glib::GString, glib::Error>> + 'static>>; + + #[doc(alias = "secret_service_get_secrets_for_dbus_paths")] + #[doc(alias = "get_secrets_for_dbus_paths")] + fn secrets_for_dbus_paths<P: FnOnce(Result<HashMap<String, Value>, glib::Error>) + 'static>( + &self, + item_paths: &str, + cancellable: Option<&impl IsA<gio::Cancellable>>, + callback: P, + ); + + fn secrets_for_dbus_paths_future( + &self, + item_paths: &str, + ) -> Pin< + Box_< + dyn std::future::Future<Output = Result<HashMap<String, Value>, glib::Error>> + 'static, + >, + >; + + #[doc(alias = "secret_service_search_for_dbus_paths")] + fn search_for_dbus_paths< + P: FnOnce(Result<(Vec<glib::GString>, Vec<glib::GString>), glib::Error>) + 'static, + >( + &self, + schema: Option<&Schema>, + attributes: HashMap<&str, &str>, + cancellable: Option<&impl IsA<gio::Cancellable>>, + callback: P, + ); + + fn search_for_dbus_paths_future( + &self, + schema: Option<&Schema>, + attributes: HashMap<&str, &str>, + ) -> Pin< + Box_< + dyn std::future::Future< + Output = Result<(Vec<glib::GString>, Vec<glib::GString>), glib::Error>, + > + 'static, + >, + >; +} + +impl<O: IsA<Service>> ServiceExtManual for O { + #[doc(alias = "secret_lock_dbus_paths_sync")] + fn lock_dbus_paths_sync( + &self, + paths: Vec<&str>, + cancellable: Option<&impl IsA<gio::Cancellable>>, + ) -> Result<Vec<glib::GString>, glib::Error> { + unsafe { + let mut locked = ptr::null_mut(); + let mut error = ptr::null_mut(); + let _ = ffi::secret_service_lock_dbus_paths_sync( + self.as_ref().to_glib_none().0, + paths.to_glib_none().0, + cancellable.map(|p| p.as_ref()).to_glib_none().0, + &mut locked, + &mut error, + ); + if error.is_null() { + Ok(FromGlibPtrContainer::from_glib_full(locked)) + } else { + Err(from_glib_full(error)) + } + } + } + + fn unlock_dbus_paths<P: FnOnce(Result<Vec<glib::GString>, glib::Error>) + 'static>( + &self, + paths: &[&str], + cancellable: Option<&impl IsA<gio::Cancellable>>, + callback: P, + ) { + let main_context = glib::MainContext::ref_thread_default(); + let is_main_context_owner = main_context.is_owner(); + let has_acquired_main_context = (!is_main_context_owner) + .then(|| main_context.acquire().ok()) + .flatten(); + assert!( + is_main_context_owner || has_acquired_main_context.is_some(), + "Async operations only allowed if the thread is owning the MainContext" + ); + + let user_data: Box_<glib::thread_guard::ThreadGuard<P>> = + Box_::new(glib::thread_guard::ThreadGuard::new(callback)); + unsafe extern "C" fn unlock_dbus_paths_trampoline< + P: FnOnce(Result<Vec<glib::GString>, 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 mut unlocked = ptr::null_mut(); + let _ = ffi::secret_service_unlock_dbus_paths_finish( + _source_object as *mut _, + res, + &mut unlocked, + &mut error, + ); + let result = if error.is_null() { + Ok(FromGlibPtrContainer::from_glib_full(unlocked)) + } else { + Err(from_glib_full(error)) + }; + 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 = unlock_dbus_paths_trampoline::<P>; + + unsafe { + ffi::secret_service_unlock_dbus_paths( + self.as_ref().to_glib_none().0, + paths.to_glib_none().0, + cancellable.map(|p| p.as_ref()).to_glib_none().0, + Some(callback), + Box_::into_raw(user_data) as *mut _, + ); + } + } + + fn unlock_dbus_paths_future( + &self, + paths: &[&str], + ) -> Pin< + Box_<dyn std::future::Future<Output = Result<Vec<glib::GString>, glib::Error>> + 'static>, + > { + let paths = paths.iter().copied().map(String::from).collect::<Vec<_>>(); + Box_::pin(gio::GioFuture::new(self, move |obj, cancellable, send| { + let paths = paths.iter().map(|s| s.as_str()).collect::<Vec<_>>(); + obj.unlock_dbus_paths(&paths, Some(cancellable), move |res| { + send.resolve(res); + }); + })) + } + + fn unlock<P: FnOnce(Result<Vec<gio::DBusProxy>, glib::Error>) + 'static>( + &self, + objects: &[gio::DBusProxy], + cancellable: Option<&impl IsA<gio::Cancellable>>, + callback: P, + ) { + let main_context = glib::MainContext::ref_thread_default(); + let is_main_context_owner = main_context.is_owner(); + let has_acquired_main_context = (!is_main_context_owner) + .then(|| main_context.acquire().ok()) + .flatten(); + assert!( + is_main_context_owner || has_acquired_main_context.is_some(), + "Async operations only allowed if the thread is owning the MainContext" + ); + + let user_data: Box_<glib::thread_guard::ThreadGuard<P>> = + Box_::new(glib::thread_guard::ThreadGuard::new(callback)); + unsafe extern "C" fn unlock_trampoline< + P: FnOnce(Result<Vec<gio::DBusProxy>, 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 mut unlocked = ptr::null_mut(); + let _ = ffi::secret_service_unlock_finish( + _source_object as *mut _, + res, + &mut unlocked, + &mut error, + ); + let result = if error.is_null() { + Ok(FromGlibPtrContainer::from_glib_full(unlocked)) + } else { + Err(from_glib_full(error)) + }; + 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 = unlock_trampoline::<P>; + unsafe { + ffi::secret_service_unlock( + self.as_ref().to_glib_none().0, + objects.to_glib_none().0, + cancellable.map(|p| p.as_ref()).to_glib_none().0, + Some(callback), + Box_::into_raw(user_data) as *mut _, + ); + } + } + + fn unlock_future( + &self, + objects: &[gio::DBusProxy], + ) -> Pin< + Box_<dyn std::future::Future<Output = Result<Vec<gio::DBusProxy>, glib::Error>> + 'static>, + > { + let objects = objects.to_vec(); + Box_::pin(gio::GioFuture::new(self, move |obj, cancellable, send| { + obj.unlock(&objects, Some(cancellable), move |res| { + send.resolve(res); + }); + })) + } + + fn lock_dbus_paths<P: FnOnce(Result<Vec<glib::GString>, glib::Error>) + 'static>( + &self, + paths: &[&str], + cancellable: Option<&impl IsA<gio::Cancellable>>, + callback: P, + ) { + let main_context = glib::MainContext::ref_thread_default(); + let is_main_context_owner = main_context.is_owner(); + let has_acquired_main_context = (!is_main_context_owner) + .then(|| main_context.acquire().ok()) + .flatten(); + assert!( + is_main_context_owner || has_acquired_main_context.is_some(), + "Async operations only allowed if the thread is owning the MainContext" + ); + + let user_data: Box_<glib::thread_guard::ThreadGuard<P>> = + Box_::new(glib::thread_guard::ThreadGuard::new(callback)); + unsafe extern "C" fn lock_dbus_paths_trampoline< + P: FnOnce(Result<Vec<glib::GString>, 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 mut locked = ptr::null_mut(); + let _ = ffi::secret_service_lock_dbus_paths_finish( + _source_object as *mut _, + res, + &mut locked, + &mut error, + ); + let result = if error.is_null() { + Ok(FromGlibPtrContainer::from_glib_full(locked)) + } else { + Err(from_glib_full(error)) + }; + 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 = lock_dbus_paths_trampoline::<P>; + unsafe { + ffi::secret_service_lock_dbus_paths( + self.as_ref().to_glib_none().0, + paths.to_glib_none().0, + cancellable.map(|p| p.as_ref()).to_glib_none().0, + Some(callback), + Box_::into_raw(user_data) as *mut _, + ); + } + } + + fn lock_dbus_paths_future( + &self, + paths: &[&str], + ) -> Pin< + Box_<dyn std::future::Future<Output = Result<Vec<glib::GString>, glib::Error>> + 'static>, + > { + let paths = paths.iter().copied().map(String::from).collect::<Vec<_>>(); + Box_::pin(gio::GioFuture::new(self, move |obj, cancellable, send| { + let paths = paths.iter().map(|s| s.as_str()).collect::<Vec<_>>(); + obj.lock_dbus_paths(&paths, Some(cancellable), move |res| { + send.resolve(res); + }); + })) + } + + fn lock<P: FnOnce(Result<Vec<gio::DBusProxy>, glib::Error>) + 'static>( + &self, + objects: &[gio::DBusProxy], + cancellable: Option<&impl IsA<gio::Cancellable>>, + callback: P, + ) { + let main_context = glib::MainContext::ref_thread_default(); + let is_main_context_owner = main_context.is_owner(); + let has_acquired_main_context = (!is_main_context_owner) + .then(|| main_context.acquire().ok()) + .flatten(); + assert!( + is_main_context_owner || has_acquired_main_context.is_some(), + "Async operations only allowed if the thread is owning the MainContext" + ); + + let user_data: Box_<glib::thread_guard::ThreadGuard<P>> = + Box_::new(glib::thread_guard::ThreadGuard::new(callback)); + unsafe extern "C" fn lock_trampoline< + P: FnOnce(Result<Vec<gio::DBusProxy>, 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 mut locked = ptr::null_mut(); + let _ = ffi::secret_service_lock_finish( + _source_object as *mut _, + res, + &mut locked, + &mut error, + ); + let result = if error.is_null() { + Ok(FromGlibPtrContainer::from_glib_full(locked)) + } else { + Err(from_glib_full(error)) + }; + 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 = lock_trampoline::<P>; + unsafe { + ffi::secret_service_lock( + self.as_ref().to_glib_none().0, + objects.to_glib_none().0, + cancellable.map(|p| p.as_ref()).to_glib_none().0, + Some(callback), + Box_::into_raw(user_data) as *mut _, + ); + } + } + + fn lock_future( + &self, + objects: &[gio::DBusProxy], + ) -> Pin< + Box_<dyn std::future::Future<Output = Result<Vec<gio::DBusProxy>, glib::Error>> + 'static>, + > { + let objects = objects.to_vec(); + Box_::pin(gio::GioFuture::new(self, move |obj, cancellable, send| { + obj.lock(&objects, Some(cancellable), move |res| { + send.resolve(res); + }); + })) + } + + fn store<P: FnOnce(Result<(), glib::Error>) + 'static>( + &self, + schema: Option<&Schema>, + attributes: HashMap<&str, &str>, + collection: Option<&str>, + label: &str, + value: &Value, + cancellable: Option<&impl IsA<gio::Cancellable>>, + callback: P, + ) { + unsafe { + let user_data: Box_<glib::thread_guard::ThreadGuard<P>> = + Box_::new(glib::thread_guard::ThreadGuard::new(callback)); + unsafe extern "C" fn store_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 _ = ffi::secret_service_store_finish(source_object as *mut _, res, &mut error); + let result = if error.is_null() { + Ok(()) + } else { + Err(from_glib_full(error)) + }; + 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 = store_trampoline::<P>; + + ffi::secret_service_store( + self.as_ref().to_glib_none().0, + 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(|p| p.as_ref()).to_glib_none().0, + Some(callback), + Box_::into_raw(user_data) as *mut _, + ); + } + } + + fn store_future( + &self, + schema: Option<&Schema>, + attributes: HashMap<&str, &str>, + collection: Option<&str>, + label: &str, + value: &Value, + ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> { + let schema = schema.map(ToOwned::to_owned); + let collection = collection.map(ToOwned::to_owned); + let label = String::from(label); + let value = value.clone(); + let owned_map = attributes + .into_iter() + .map(|(k, v)| (k.to_string(), v.to_string())) + .collect::<HashMap<String, String>>(); + + 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::<HashMap<&str, &str>>(); + obj.store( + schema.as_ref().map(::std::borrow::Borrow::borrow), + attributes, + collection.as_ref().map(::std::borrow::Borrow::borrow), + &label, + &value, + Some(cancellable), + move |res| { + send.resolve(res); + }, + ); + })) + } + + fn search<P: FnOnce(Result<Vec<Item>, glib::Error>) + 'static>( + &self, + schema: Option<&Schema>, + attributes: HashMap<&str, &str>, + flags: SearchFlags, + cancellable: Option<&impl IsA<gio::Cancellable>>, + callback: P, + ) { + unsafe { + let user_data: Box_<glib::thread_guard::ThreadGuard<P>> = + Box_::new(glib::thread_guard::ThreadGuard::new(callback)); + unsafe extern "C" fn search_trampoline< + P: FnOnce(Result<Vec<Item>, 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_service_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_<glib::thread_guard::ThreadGuard<P>> = + Box_::from_raw(user_data as *mut _); + let callback: P = callback.into_inner(); + callback(result); + } + let callback = search_trampoline::<P>; + + ffi::secret_service_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<Box_<dyn std::future::Future<Output = Result<Vec<Item>, 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::<HashMap<String, String>>(); + + 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::<HashMap<&str, &str>>(); + obj.search( + schema.as_ref().map(::std::borrow::Borrow::borrow), + attributes, + flags, + Some(cancellable), + move |res| { + send.resolve(res); + }, + ); + })) + } + + fn lookup<P: FnOnce(Result<Value, glib::Error>) + 'static>( + &self, + schema: Option<&Schema>, + attributes: HashMap<&str, &str>, + cancellable: Option<&impl IsA<gio::Cancellable>>, + callback: P, + ) { + unsafe { + let hash_table = attribute_names_and_values(attributes); + + let user_data: Box_<glib::thread_guard::ThreadGuard<P>> = + Box_::new(glib::thread_guard::ThreadGuard::new(callback)); + unsafe extern "C" fn lookup_trampoline< + P: FnOnce(Result<Value, 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_service_lookup_finish(_source_object as *mut _, res, &mut error); + let result = if error.is_null() { + Ok(from_glib_full(ret)) + } else { + Err(from_glib_full(error)) + }; + 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 = lookup_trampoline::<P>; + + ffi::secret_service_lookup( + self.as_ref().to_glib_none().0, + schema.to_glib_none().0, + hash_table, + cancellable.map(|p| p.as_ref()).to_glib_none().0, + Some(callback), + Box_::into_raw(user_data) as *mut _, + ); + } + } + + fn lookup_future( + &self, + schema: Option<&Schema>, + attributes: HashMap<&str, &str>, + ) -> Pin<Box_<dyn std::future::Future<Output = Result<Value, 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::<HashMap<String, String>>(); + + 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::<HashMap<&str, &str>>(); + + obj.lookup( + schema.as_ref().map(::std::borrow::Borrow::borrow), + attributes, + Some(cancellable), + move |res| { + send.resolve(res); + }, + ); + })) + } + + fn clear<P: FnOnce(Result<(), glib::Error>) + 'static>( + &self, + schema: Option<&Schema>, + attributes: HashMap<&str, &str>, + cancellable: Option<&impl IsA<gio::Cancellable>>, + callback: P, + ) { + unsafe { + let hash_table = attribute_names_and_values(attributes); + + let user_data: Box_<glib::thread_guard::ThreadGuard<P>> = + Box_::new(glib::thread_guard::ThreadGuard::new(callback)); + unsafe extern "C" fn clear_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 _ = ffi::secret_service_clear_finish(_source_object as *mut _, res, &mut error); + let result = if error.is_null() { + Ok(()) + } else { + Err(from_glib_full(error)) + }; + 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 = clear_trampoline::<P>; + + ffi::secret_service_clear( + self.as_ref().to_glib_none().0, + schema.to_glib_none().0, + hash_table, + cancellable.map(|p| p.as_ref()).to_glib_none().0, + Some(callback), + Box_::into_raw(user_data) as *mut _, + ); + } + } + + fn clear_future( + &self, + schema: Option<&Schema>, + attributes: HashMap<&str, &str>, + ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), 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::<HashMap<String, String>>(); + + 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::<HashMap<&str, &str>>(); + obj.clear( + schema.as_ref().map(::std::borrow::Borrow::borrow), + attributes, + Some(cancellable), + move |res| { + send.resolve(res); + }, + ); + })) + } + + fn create_item_dbus_path<P: FnOnce(Result<glib::GString, glib::Error>) + 'static>( + &self, + collection_path: &str, + properties: HashMap<&str, &glib::Variant>, + value: &Value, + flags: ItemCreateFlags, + cancellable: Option<&impl IsA<gio::Cancellable>>, + callback: P, + ) { + unsafe { + let hash_table = attribute_names_and_properties(properties); + + let user_data: Box_<glib::thread_guard::ThreadGuard<P>> = + Box_::new(glib::thread_guard::ThreadGuard::new(callback)); + unsafe extern "C" fn create_item_dbus_path_trampoline< + P: FnOnce(Result<glib::GString, 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_service_create_item_dbus_path_finish( + _source_object as *mut _, + res, + &mut error, + ); + let result = if error.is_null() { + Ok(from_glib_full(ret)) + } else { + Err(from_glib_full(error)) + }; + 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 = create_item_dbus_path_trampoline::<P>; + + ffi::secret_service_create_item_dbus_path( + self.as_ref().to_glib_none().0, + collection_path.to_glib_none().0, + hash_table, + value.to_glib_none().0, + flags.into_glib(), + cancellable.map(|p| p.as_ref()).to_glib_none().0, + Some(callback), + Box_::into_raw(user_data) as *mut _, + ); + } + } + + fn create_item_dbus_path_future( + &self, + collection_path: &str, + properties: HashMap<&str, &glib::Variant>, + value: &Value, + flags: ItemCreateFlags, + ) -> Pin<Box_<dyn std::future::Future<Output = Result<glib::GString, glib::Error>> + 'static>> + { + let collection_path = String::from(collection_path); + let value = value.clone(); + let owned_map = properties + .into_iter() + .map(|(k, v)| (k.to_string(), v.to_owned())) + .collect::<HashMap<String, glib::Variant>>(); + + Box_::pin(gio::GioFuture::new(self, move |obj, cancellable, send| { + let properties = owned_map + .iter() + .map(|(k, v)| (k.as_str(), v)) + .collect::<HashMap<&str, &glib::Variant>>(); + obj.create_item_dbus_path( + &collection_path, + properties, + &value, + flags, + Some(cancellable), + move |res| { + send.resolve(res); + }, + ); + })) + } + + fn create_collection_dbus_path<P: FnOnce(Result<glib::GString, glib::Error>) + 'static>( + &self, + properties: HashMap<&str, &glib::Variant>, + alias: Option<&str>, + flags: CollectionCreateFlags, + cancellable: Option<&impl IsA<gio::Cancellable>>, + callback: P, + ) { + unsafe { + let hash_table = attribute_names_and_properties(properties); + + let user_data: Box_<glib::thread_guard::ThreadGuard<P>> = + Box_::new(glib::thread_guard::ThreadGuard::new(callback)); + unsafe extern "C" fn create_collection_dbus_path_trampoline< + P: FnOnce(Result<glib::GString, 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_service_create_collection_dbus_path_finish( + _source_object as *mut _, + res, + &mut error, + ); + let result = if error.is_null() { + Ok(from_glib_full(ret)) + } else { + Err(from_glib_full(error)) + }; + 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 = create_collection_dbus_path_trampoline::<P>; + + ffi::secret_service_create_collection_dbus_path( + self.as_ref().to_glib_none().0, + hash_table, + alias.to_glib_none().0, + flags.into_glib(), + cancellable.map(|p| p.as_ref()).to_glib_none().0, + Some(callback), + Box_::into_raw(user_data) as *mut _, + ); + } + } + + fn create_collection_dbus_path_future( + &self, + properties: HashMap<&str, &glib::Variant>, + alias: Option<&str>, + flags: CollectionCreateFlags, + ) -> Pin<Box_<dyn std::future::Future<Output = Result<glib::GString, glib::Error>> + 'static>> + { + let alias = alias.map(ToOwned::to_owned); + let owned_map = properties + .into_iter() + .map(|(k, v)| (k.to_string(), v.to_owned())) + .collect::<HashMap<String, glib::Variant>>(); + Box_::pin(gio::GioFuture::new(self, move |obj, cancellable, send| { + let properties = owned_map + .iter() + .map(|(k, v)| (k.as_str(), v)) + .collect::<HashMap<&str, &glib::Variant>>(); + obj.create_collection_dbus_path( + properties, + alias.as_ref().map(::std::borrow::Borrow::borrow), + flags, + Some(cancellable), + move |res| { + send.resolve(res); + }, + ); + })) + } + + fn secrets_for_dbus_paths<P: FnOnce(Result<HashMap<String, Value>, glib::Error>) + 'static>( + &self, + item_paths: &str, + cancellable: Option<&impl IsA<gio::Cancellable>>, + callback: P, + ) { + unsafe { + let user_data: Box_<glib::thread_guard::ThreadGuard<P>> = + Box_::new(glib::thread_guard::ThreadGuard::new(callback)); + unsafe extern "C" fn secrets_for_dbus_paths_trampoline< + P: FnOnce(Result<HashMap<String, Value>, 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_service_get_secrets_for_dbus_paths_finish( + _source_object as *mut _, + res, + &mut error, + ); + + let result = if error.is_null() { + Ok(crate::hashtable::hash_map_from_glib_none(ret)) + } else { + Err(from_glib_full(error)) + }; + 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 = secrets_for_dbus_paths_trampoline::<P>; + + let mut item_paths = item_paths.to_string(); + ffi::secret_service_get_secrets_for_dbus_paths( + self.as_ref().to_glib_none().0, + &mut item_paths as *mut _ as *mut *const libc::c_char, + cancellable.map(|p| p.as_ref()).to_glib_none().0, + Some(callback), + Box_::into_raw(user_data) as *mut _, + ); + } + } + + fn secrets_for_dbus_paths_future( + &self, + item_paths: &str, + ) -> Pin< + Box_< + dyn std::future::Future<Output = Result<HashMap<String, Value>, glib::Error>> + 'static, + >, + > { + let item_paths = String::from(item_paths); + Box_::pin(gio::GioFuture::new(self, move |obj, cancellable, send| { + obj.secrets_for_dbus_paths(&item_paths, Some(cancellable), move |res| { + send.resolve(res); + }); + })) + } + + fn search_for_dbus_paths< + P: FnOnce(Result<(Vec<glib::GString>, Vec<glib::GString>), glib::Error>) + 'static, + >( + &self, + schema: Option<&Schema>, + attributes: HashMap<&str, &str>, + cancellable: Option<&impl IsA<gio::Cancellable>>, + callback: P, + ) { + unsafe { + let hash_table = attribute_names_and_values(attributes); + + let user_data: Box_<glib::thread_guard::ThreadGuard<P>> = + Box_::new(glib::thread_guard::ThreadGuard::new(callback)); + unsafe extern "C" fn search_for_dbus_paths_trampoline< + P: FnOnce(Result<(Vec<glib::GString>, Vec<glib::GString>), 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 mut unlocked = ptr::null_mut(); + let mut locked = ptr::null_mut(); + let _ = ffi::secret_service_search_for_dbus_paths_finish( + _source_object as *mut _, + res, + &mut unlocked, + &mut locked, + &mut error, + ); + let result = if error.is_null() { + Ok(( + FromGlibPtrContainer::from_glib_full(unlocked), + FromGlibPtrContainer::from_glib_full(locked), + )) + } else { + Err(from_glib_full(error)) + }; + 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 = search_for_dbus_paths_trampoline::<P>; + + ffi::secret_service_search_for_dbus_paths( + self.as_ref().to_glib_none().0, + schema.to_glib_none().0, + hash_table, + 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_< + dyn std::future::Future< + Output = Result<(Vec<glib::GString>, Vec<glib::GString>), 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::<HashMap<String, String>>(); + 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::<HashMap<&str, &str>>(); + obj.search_for_dbus_paths( + schema.as_ref().map(::std::borrow::Borrow::borrow), + attributes, + Some(cancellable), + move |res| { + send.resolve(res); + }, + ); + })) + } +} diff --git a/libsecret/src/value.rs b/libsecret/src/value.rs new file mode 100644 index 0000000..ef43da8 --- /dev/null +++ b/libsecret/src/value.rs @@ -0,0 +1,67 @@ +use glib::translate::*; +use std::mem; +use std::os::raw::c_void; + +glib::wrapper! { + #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] + pub struct Value(Shared<ffi::SecretValue>); + + match fn { + ref => |ptr| ffi::secret_value_ref(ptr), + // Manual + unref => |ptr| ffi::secret_value_unref(ptr as *mut _ as *mut c_void), + type_ => || ffi::secret_value_get_type(), + } +} + +impl Value { + #[doc(alias = "secret_value_new")] + pub fn new(secret: &str, content_type: &str) -> Value { + let length = secret.len() as isize; + unsafe { + from_glib_full(ffi::secret_value_new( + secret.to_glib_none().0, + length, + content_type.to_glib_none().0, + )) + } + } + + #[doc(alias = "secret_value_get")] + pub fn get(&self) -> Vec<u8> { + unsafe { + let mut length = mem::MaybeUninit::uninit(); + let ret = FromGlibContainer::from_glib_none_num( + ffi::secret_value_get(self.to_glib_none().0, length.as_mut_ptr()), + length.assume_init() as _, + ); + ret + } + } + + #[doc(alias = "secret_value_get_content_type")] + #[doc(alias = "get_content_type")] + pub fn content_type(&self) -> glib::GString { + unsafe { from_glib_none(ffi::secret_value_get_content_type(self.to_glib_none().0)) } + } + + #[doc(alias = "secret_value_get_text")] + #[doc(alias = "get_text")] + pub fn text(&self) -> Option<glib::GString> { + unsafe { from_glib_none(ffi::secret_value_get_text(self.to_glib_none().0)) } + } + + #[cfg(any(feature = "v0_19", feature = "dox"))] + #[cfg_attr(feature = "dox", doc(cfg(feature = "v0_19")))] + #[doc(alias = "secret_value_unref_to_password")] + pub fn unref_to_password(&self) -> glib::GString { + unsafe { + let mut length = std::mem::MaybeUninit::uninit(); + let password = + ffi::secret_value_unref_to_password(self.to_glib_none().0, length.as_mut_ptr()); + length.assume_init(); + + from_glib_full(password) + } + } +} |