wip: gobject

Author: bilelmoussaoui

Cargo.lock

@@ -5,6 +5,7 @@ members = [
  "cargo-credential",
   "client",
   "cli",
+  "gobject",
   "pam",
   "portal",
   "python",

Cargo.toml

@@ -0,0 +1,24 @@
+[package]
+name = "oo7-gobject"
+version.workspace = true
+edition.workspace = true
+authors.workspace = true
+keywords.workspace = true
+categories.workspace = true
+repository.workspace = true
+homepage.workspace = true
+license.workspace = true
+rust-version.workspace = true
+description = "GObject bindings for oo7"
+
+[lib]
+name = "oo7"
+crate-type = ["staticlib", "cdylib"]
+
+[dependencies]
+oo7_rs = { package = "oo7", path = "../client", version = "0.6", default-features = false, features = ["async-std", "native_crypto"] }
+gobject-ffi = { git = "https://github.com/bilelmoussaoui/gobject-ffi", version = "0.1" }
+glib = "0.21"
+gio = "0.21"
+futures-util = "0.3"
+

gobject/Cargo.toml

@@ -0,0 +1,73 @@
+project('oo7-gobject', ['c', 'rust'],
+  version: '0.6.0',
+  license: 'MIT',
+  meson_version: '>= 1.7',
+)
+
+prefix = get_option('prefix')
+libdir = get_option('libdir')
+includedir = get_option('includedir')
+
+# Dependencies
+glib_dep = dependency('glib-2.0', version: '>= 2.56')
+gobject_dep = dependency('gobject-2.0', version: '>= 2.56')
+gio_dep = dependency('gio-2.0', version: '>= 2.56')
+
+# Cargo build
+cargo = find_program('cargo')
+
+cargo_options = ['--target-dir', meson.project_build_root()]
+
+if get_option('buildtype') == 'release'
+  cargo_options += ['--release']
+  rust_target = 'release'
+else
+  rust_target = 'debug'
+endif
+
+# Build the Rust library
+rust_lib = custom_target(
+  'cargo-build',
+  build_by_default: true,
+  build_always_stale: true,
+  output: 'liboo7.so',
+  console: true,
+  install: true,
+  install_dir: libdir,
+  command: [
+    cargo, 'build',
+    cargo_options,
+    '&&',
+    'cp', rust_target / 'liboo7.so', '@OUTPUT@',
+  ]
+)
+
+# Headers
+headers = [
+  'src/oo7.h',
+]
+
+install_headers(headers, subdir: 'oo7-1.0')
+
+# pkg-config
+pkg = import('pkgconfig')
+pkg.generate(
+  name: 'oo7-1.0',
+  description: 'GObject bindings for oo7 - Linux Secret Service API',
+  version: meson.project_version(),
+  libraries: ['-L${libdir}', '-loo7'],
+  requires: ['glib-2.0', 'gobject-2.0', 'gio-2.0'],
+  subdirs: 'oo7-1.0',
+)
+
+# Tests
+test_keyring = executable(
+  'test-keyring',
+  'tests/test_keyring.c',
+  dependencies: [glib_dep, gobject_dep, gio_dep],
+  link_with: rust_lib,
+  include_directories: include_directories('src'),
+)
+
+test('keyring', test_keyring)
+

gobject/meson.build

@@ -0,0 +1,181 @@
+use glib::{
+    Quark,
+    error::ErrorDomain,
+    translate::{FromGlib, IntoGlib, TryFromGlib},
+};
+
+/// Error codes for the Oo7 error domain
+#[repr(i32)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Oo7ErrorCode {
+    // File backend errors
+    FileHeaderMismatch = 1,
+    VersionMismatch = 2,
+    NoData = 3,
+    NoParentDir = 4,
+    GVariantDeserialization = 5,
+    SaltSizeMismatch = 6,
+    WeakKey = 7,
+    Io = 8,
+    MacError = 9,
+    ChecksumMismatch = 10,
+    HashedAttributeMac = 11,
+    NoDataDir = 12,
+    TargetFileChanged = 13,
+    Portal = 14,
+    InvalidItemIndex = 15,
+    Utf8 = 16,
+    AlgorithmMismatch = 17,
+    IncorrectSecret = 18,
+    PartiallyCorruptedKeyring = 19,
+    Crypto = 20,
+    Locked = 21,
+
+    // DBus backend errors
+    ZBus = 100,
+    ServiceError = 101,
+    Deleted = 102,
+    Dismissed = 103,
+    NotFound = 104,
+    IsLocked = 105,
+    NoSession = 106,
+    NoSuchObject = 107,
+
+    // Generic/unknown error
+    Unknown = 999,
+}
+
+impl IntoGlib for Oo7ErrorCode {
+    type GlibType = i32;
+
+    fn into_glib(self) -> i32 {
+        self as i32
+    }
+}
+
+impl TryFromGlib<i32> for Oo7ErrorCode {
+    type Error = glib::value::ValueTypeMismatchError;
+
+    unsafe fn try_from_glib(value: i32) -> Result<Self, Self::Error> {
+        match value {
+            1 => Ok(Self::FileHeaderMismatch),
+            2 => Ok(Self::VersionMismatch),
+            3 => Ok(Self::NoData),
+            4 => Ok(Self::NoParentDir),
+            5 => Ok(Self::GVariantDeserialization),
+            6 => Ok(Self::SaltSizeMismatch),
+            7 => Ok(Self::WeakKey),
+            8 => Ok(Self::Io),
+            9 => Ok(Self::MacError),
+            10 => Ok(Self::ChecksumMismatch),
+            11 => Ok(Self::HashedAttributeMac),
+            12 => Ok(Self::NoDataDir),
+            13 => Ok(Self::TargetFileChanged),
+            14 => Ok(Self::Portal),
+            15 => Ok(Self::InvalidItemIndex),
+            16 => Ok(Self::Utf8),
+            17 => Ok(Self::AlgorithmMismatch),
+            18 => Ok(Self::IncorrectSecret),
+            19 => Ok(Self::PartiallyCorruptedKeyring),
+            20 => Ok(Self::Crypto),
+            21 => Ok(Self::Locked),
+            100 => Ok(Self::ZBus),
+            101 => Ok(Self::ServiceError),
+            102 => Ok(Self::Deleted),
+            103 => Ok(Self::Dismissed),
+            104 => Ok(Self::NotFound),
+            105 => Ok(Self::IsLocked),
+            106 => Ok(Self::NoSession),
+            107 => Ok(Self::NoSuchObject),
+            999 => Ok(Self::Unknown),
+            _ => Ok(Self::Unknown),
+        }
+    }
+}
+
+impl ErrorDomain for Oo7ErrorCode {
+    fn domain() -> Quark {
+        unsafe { Quark::from_glib(oo7_error_quark()) }
+    }
+
+    fn code(self) -> i32 {
+        self.into_glib()
+    }
+
+    fn from(code: i32) -> Option<Self>
+    where
+        Self: Sized,
+    {
+        unsafe { Self::try_from_glib(code).ok() }
+    }
+}
+
+/// Custom GError domain for oo7 errors
+#[unsafe(no_mangle)]
+pub extern "C" fn oo7_error_quark() -> glib::ffi::GQuark {
+    Quark::from_str("oo7-error-quark").into_glib()
+}
+
+/// Convert an oo7_rs::Error to a glib::Error with proper error codes and
+/// messages
+pub fn to_glib_error(error: oo7_rs::Error) -> glib::Error {
+    match error {
+        oo7_rs::Error::File(e) => file_error_to_glib(e),
+        oo7_rs::Error::DBus(e) => dbus_error_to_glib(e),
+    }
+}
+
+fn file_error_to_glib(error: oo7_rs::file::Error) -> glib::Error {
+    use oo7_rs::file::Error;
+
+    let (code, message) = match error {
+        Error::FileHeaderMismatch(_) => (Oo7ErrorCode::FileHeaderMismatch, error.to_string()),
+        Error::VersionMismatch(_) => (Oo7ErrorCode::VersionMismatch, error.to_string()),
+        Error::NoData => (Oo7ErrorCode::NoData, error.to_string()),
+        Error::NoParentDir(_) => (Oo7ErrorCode::NoParentDir, error.to_string()),
+        Error::GVariantDeserialization(_) => {
+            (Oo7ErrorCode::GVariantDeserialization, error.to_string())
+        }
+        Error::SaltSizeMismatch(_, _) => (Oo7ErrorCode::SaltSizeMismatch, error.to_string()),
+        Error::WeakKey(_) => (Oo7ErrorCode::WeakKey, error.to_string()),
+        Error::Io(_) => (Oo7ErrorCode::Io, error.to_string()),
+        Error::MacError => (Oo7ErrorCode::MacError, error.to_string()),
+        Error::ChecksumMismatch => (Oo7ErrorCode::ChecksumMismatch, error.to_string()),
+        Error::HashedAttributeMac(_) => (Oo7ErrorCode::HashedAttributeMac, error.to_string()),
+        Error::NoDataDir => (Oo7ErrorCode::NoDataDir, error.to_string()),
+        Error::TargetFileChanged(_) => (Oo7ErrorCode::TargetFileChanged, error.to_string()),
+        Error::Portal(_) => (Oo7ErrorCode::Portal, error.to_string()),
+        Error::InvalidItemIndex(_) => (Oo7ErrorCode::InvalidItemIndex, error.to_string()),
+        Error::Utf8(_) => (Oo7ErrorCode::Utf8, error.to_string()),
+        Error::AlgorithmMismatch(_) => (Oo7ErrorCode::AlgorithmMismatch, error.to_string()),
+        Error::IncorrectSecret => (Oo7ErrorCode::IncorrectSecret, error.to_string()),
+        Error::PartiallyCorruptedKeyring { .. } => {
+            (Oo7ErrorCode::PartiallyCorruptedKeyring, error.to_string())
+        }
+        Error::Crypto(_) => (Oo7ErrorCode::Crypto, error.to_string()),
+        Error::Locked => (Oo7ErrorCode::Locked, error.to_string()),
+    };
+
+    glib::Error::new(code, &message)
+}
+
+fn dbus_error_to_glib(error: oo7_rs::dbus::Error) -> glib::Error {
+    use oo7_rs::dbus::{Error, ServiceError};
+
+    let (code, message) = match error {
+        Error::ZBus(_) => (Oo7ErrorCode::ZBus, error.to_string()),
+        Error::Service(ref service_err) => match service_err {
+            ServiceError::ZBus(_) => (Oo7ErrorCode::ZBus, error.to_string()),
+            ServiceError::IsLocked(_) => (Oo7ErrorCode::IsLocked, error.to_string()),
+            ServiceError::NoSession(_) => (Oo7ErrorCode::NoSession, error.to_string()),
+            ServiceError::NoSuchObject(_) => (Oo7ErrorCode::NoSuchObject, error.to_string()),
+        },
+        Error::Deleted => (Oo7ErrorCode::Deleted, error.to_string()),
+        Error::Dismissed => (Oo7ErrorCode::Dismissed, error.to_string()),
+        Error::NotFound(_) => (Oo7ErrorCode::NotFound, error.to_string()),
+        Error::IO(_) => (Oo7ErrorCode::Io, error.to_string()),
+        Error::Crypto(_) => (Oo7ErrorCode::Crypto, error.to_string()),
+    };
+
+    glib::Error::new(code, &message)
+}

gobject/src/error.rs

@@ -0,0 +1,97 @@
+use std::collections::HashMap;
+
+use glib::translate::*;
+use gobject_ffi::FfiConvert;
+
+#[derive(Clone, glib::Boxed)]
+#[boxed_type(name = "Oo7Attributes")]
+pub struct Attributes(pub(crate) HashMap<String, String>);
+
+impl Attributes {
+    pub fn into_inner(self) -> HashMap<String, String> {
+        self.0
+    }
+}
+
+impl ToGlibPtr<'_, *mut glib::ffi::GHashTable> for Attributes {
+    type Storage = HashMap<String, String>;
+
+    fn to_glib_none(&self) -> Stash<'_, *mut glib::ffi::GHashTable, Self> {
+        let ptr = self.0.to_glib_full();
+        Stash(ptr, self.0.clone())
+    }
+
+    fn to_glib_full(&self) -> *mut glib::ffi::GHashTable {
+        self.0.to_glib_full()
+    }
+}
+
+impl FromGlibPtrNone<*mut glib::ffi::GHashTable> for Attributes {
+    unsafe fn from_glib_none(ptr: *mut glib::ffi::GHashTable) -> Self {
+        let map = unsafe { HashMap::<String, String>::from_glib_none(ptr) };
+        Self(map)
+    }
+}
+
+impl FfiConvert for Attributes {
+    type CType = *mut glib::ffi::GHashTable;
+
+    unsafe fn from_c_borrowed(value: Self::CType) -> Self {
+        unsafe { FromGlibPtrNone::from_glib_none(value) }
+    }
+
+    fn to_c_owned(self) -> Self::CType {
+        ToGlibPtr::to_glib_full(&self)
+    }
+
+    fn c_error_value() -> Self::CType {
+        std::ptr::null_mut()
+    }
+}
+
+#[derive(Clone, glib::Boxed)]
+#[boxed_type(name = "Oo7ItemVec")]
+pub struct ItemVec(pub(crate) std::sync::Arc<Vec<std::sync::Arc<oo7_rs::Item>>>);
+
+impl ToGlibPtr<'_, *mut glib::ffi::GList> for ItemVec {
+    type Storage = std::ptr::NonNull<glib::ffi::GList>;
+
+    fn to_glib_none(&self) -> Stash<'_, *mut glib::ffi::GList, Self> {
+        let glist = items_vec_to_glist(&self.0);
+        Stash(glist, std::ptr::NonNull::new(glist).unwrap())
+    }
+
+    fn to_glib_full(&self) -> *mut glib::ffi::GList {
+        items_vec_to_glist(&self.0)
+    }
+}
+
+fn items_vec_to_glist(
+    items: &std::sync::Arc<Vec<std::sync::Arc<oo7_rs::Item>>>,
+) -> *mut glib::ffi::GList {
+    let mut list: *mut glib::ffi::GList = std::ptr::null_mut();
+    for item_arc in items.iter() {
+        let gobject_item = crate::Item::from_arc(std::sync::Arc::clone(item_arc));
+        let ptr: *mut crate::item::ffi::Item = gobject_item.into_glib_ptr();
+        unsafe {
+            list = glib::ffi::g_list_append(list, ptr as glib::ffi::gpointer);
+        }
+    }
+    list
+}
+
+impl FfiConvert for ItemVec {
+    type CType = *mut glib::ffi::GList;
+
+    unsafe fn from_c_borrowed(_value: Self::CType) -> Self {
+        unimplemented!("ItemVec::from_c_borrowed is not implemented")
+    }
+
+    fn to_c_owned(self) -> Self::CType {
+        ToGlibPtr::to_glib_full(&self)
+    }
+
+    fn c_error_value() -> Self::CType {
+        std::ptr::null_mut()
+    }
+}