Merging upstream version 1.71.1+dfsg1.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

3 files changed, 210 insertions, 0 deletions

diff --git a/src/tools/cargo/credential/cargo-credential-gnome-secret/Cargo.toml b/src/tools/cargo/credential/cargo-credential-gnome-secret/Cargo.toml
new file mode 100644
index 000000000..63b3e95cc
--- /dev/null
+++ b/src/tools/cargo/credential/cargo-credential-gnome-secret/Cargo.toml
@@ -0,0 +1,13 @@
+[package]
+name = "cargo-credential-gnome-secret"
+version = "0.2.0"
+edition = "2021"
+license = "MIT OR Apache-2.0"
+repository = "https://github.com/rust-lang/cargo"
+description = "A Cargo credential process that stores tokens with GNOME libsecret."
+
+[dependencies]
+cargo-credential.workspace = true
+
+[build-dependencies]
+pkg-config.workspace = true
diff --git a/src/tools/cargo/credential/cargo-credential-gnome-secret/build.rs b/src/tools/cargo/credential/cargo-credential-gnome-secret/build.rs
new file mode 100644
index 000000000..9283535af
--- /dev/null
+++ b/src/tools/cargo/credential/cargo-credential-gnome-secret/build.rs
@@ -0,0 +1,3 @@
+fn main() {
+    pkg_config::probe_library("libsecret-1").unwrap();
+}
diff --git a/src/tools/cargo/credential/cargo-credential-gnome-secret/src/main.rs b/src/tools/cargo/credential/cargo-credential-gnome-secret/src/main.rs
new file mode 100644
index 000000000..40972b05d
--- /dev/null
+++ b/src/tools/cargo/credential/cargo-credential-gnome-secret/src/main.rs
@@ -0,0 +1,194 @@
+//! Cargo registry gnome libsecret credential process.
+
+use cargo_credential::{Credential, Error};
+use std::ffi::{CStr, CString};
+use std::os::raw::{c_char, c_int};
+use std::ptr::{null, null_mut};
+
+#[allow(non_camel_case_types)]
+type gchar = c_char;
+
+#[allow(non_camel_case_types)]
+type gboolean = c_int;
+
+type GQuark = u32;
+
+#[repr(C)]
+struct GError {
+    domain: GQuark,
+    code: c_int,
+    message: *mut gchar,
+}
+
+#[repr(C)]
+struct GCancellable {
+    _private: [u8; 0],
+}
+
+#[repr(C)]
+struct SecretSchema {
+    name: *const gchar,
+    flags: SecretSchemaFlags,
+    attributes: [SecretSchemaAttribute; 32],
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+struct SecretSchemaAttribute {
+    name: *const gchar,
+    attr_type: SecretSchemaAttributeType,
+}
+
+#[repr(C)]
+enum SecretSchemaFlags {
+    None = 0,
+}
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+enum SecretSchemaAttributeType {
+    String = 0,
+}
+
+extern "C" {
+    fn secret_password_store_sync(
+        schema: *const SecretSchema,
+        collection: *const gchar,
+        label: *const gchar,
+        password: *const gchar,
+        cancellable: *mut GCancellable,
+        error: *mut *mut GError,
+        ...
+    ) -> gboolean;
+    fn secret_password_clear_sync(
+        schema: *const SecretSchema,
+        cancellable: *mut GCancellable,
+        error: *mut *mut GError,
+        ...
+    ) -> gboolean;
+    fn secret_password_lookup_sync(
+        schema: *const SecretSchema,
+        cancellable: *mut GCancellable,
+        error: *mut *mut GError,
+        ...
+    ) -> *mut gchar;
+}
+
+struct GnomeSecret;
+
+fn label(index_url: &str) -> CString {
+    CString::new(format!("cargo-registry:{}", index_url)).unwrap()
+}
+
+fn schema() -> SecretSchema {
+    let mut attributes = [SecretSchemaAttribute {
+        name: null(),
+        attr_type: SecretSchemaAttributeType::String,
+    }; 32];
+    attributes[0] = SecretSchemaAttribute {
+        name: b"url\0".as_ptr() as *const gchar,
+        attr_type: SecretSchemaAttributeType::String,
+    };
+    SecretSchema {
+        name: b"org.rust-lang.cargo.registry\0".as_ptr() as *const gchar,
+        flags: SecretSchemaFlags::None,
+        attributes,
+    }
+}
+
+impl Credential for GnomeSecret {
+    fn name(&self) -> &'static str {
+        env!("CARGO_PKG_NAME")
+    }
+
+    fn get(&self, index_url: &str) -> Result<String, Error> {
+        let mut error: *mut GError = null_mut();
+        let attr_url = CString::new("url").unwrap();
+        let index_url_c = CString::new(index_url).unwrap();
+        let schema = schema();
+        unsafe {
+            let token_c = secret_password_lookup_sync(
+                &schema,
+                null_mut(),
+                &mut error,
+                attr_url.as_ptr(),
+                index_url_c.as_ptr(),
+                null() as *const gchar,
+            );
+            if !error.is_null() {
+                return Err(format!(
+                    "failed to get token: {}",
+                    CStr::from_ptr((*error).message).to_str()?
+                )
+                .into());
+            }
+            if token_c.is_null() {
+                return Err(format!("cannot find token for {}", index_url).into());
+            }
+            let token = CStr::from_ptr(token_c)
+                .to_str()
+                .map_err(|e| format!("expected utf8 token: {}", e))?
+                .to_string();
+            Ok(token)
+        }
+    }
+
+    fn store(&self, index_url: &str, token: &str, name: Option<&str>) -> Result<(), Error> {
+        let label = label(name.unwrap_or(index_url));
+        let token = CString::new(token).unwrap();
+        let mut error: *mut GError = null_mut();
+        let attr_url = CString::new("url").unwrap();
+        let index_url_c = CString::new(index_url).unwrap();
+        let schema = schema();
+        unsafe {
+            secret_password_store_sync(
+                &schema,
+                b"default\0".as_ptr() as *const gchar,
+                label.as_ptr(),
+                token.as_ptr(),
+                null_mut(),
+                &mut error,
+                attr_url.as_ptr(),
+                index_url_c.as_ptr(),
+                null() as *const gchar,
+            );
+            if !error.is_null() {
+                return Err(format!(
+                    "failed to store token: {}",
+                    CStr::from_ptr((*error).message).to_str()?
+                )
+                .into());
+            }
+        }
+        Ok(())
+    }
+
+    fn erase(&self, index_url: &str) -> Result<(), Error> {
+        let schema = schema();
+        let mut error: *mut GError = null_mut();
+        let attr_url = CString::new("url").unwrap();
+        let index_url_c = CString::new(index_url).unwrap();
+        unsafe {
+            secret_password_clear_sync(
+                &schema,
+                null_mut(),
+                &mut error,
+                attr_url.as_ptr(),
+                index_url_c.as_ptr(),
+                null() as *const gchar,
+            );
+            if !error.is_null() {
+                return Err(format!(
+                    "failed to erase token: {}",
+                    CStr::from_ptr((*error).message).to_str()?
+                )
+                .into());
+            }
+        }
+        Ok(())
+    }
+}
+
+fn main() {
+    cargo_credential::main(GnomeSecret);
+}