Don't short circuit diagnostics on error

Signed-off-by: Marcel Guzik <marcel.guzik@cumulocity.com>

Author: Bravo555

crates/extensions/tedge-p11-server/src/pkcs11/mod.rs

@@ -36,6 +36,7 @@ use rustls::SignatureScheme;
 use serde::Deserialize;
 use serde::Serialize;
 use tracing::debug;
+use tracing::error;
 use tracing::trace;
 use tracing::warn;
 
@@ -204,8 +205,8 @@ impl Cryptoki {
             Err(e) => e.into_inner(),
         };
 
-        debug!(slots = ?get_all_slots_info(&context)?);
-        debug!(tokens = ?get_all_token_info(&context)?);
+        debug!(slots = ?get_all_slots_info(&context));
+        debug!(tokens = ?get_all_token_info(&context));
 
         let slots_with_tokens = context.get_slots_with_token()?;
         let tokens: Result<Vec<_>, _> = slots_with_tokens
@@ -249,13 +250,25 @@ impl Cryptoki {
             uri_attributes,
         };
 
-        let objects = session
-            .session
-            .find_objects(&[])?
-            .into_iter()
-            .map(|o| session.export_object_uri(o))
-            .collect::<Result<Vec<_>, _>>()?;
-        trace!(?objects, "Objects found in the token");
+        let template = [];
+        let objects = session.session.find_objects(&template);
+        match objects {
+            Err(err) => {
+                error!(?template, ?err, "failed to find objects");
+            }
+            Ok(objects) => {
+                let objects = objects
+                    .into_iter()
+                    .flat_map(|o| {
+                        let uri = session.export_object_uri(o).inspect_err(
+                            |err| error!(?err, object = ?o, "failed to read properties of object"),
+                        );
+                        uri.map(|u| (o, u)).ok()
+                    })
+                    .collect::<Vec<_>>();
+                trace!(?objects, "Objects found in the token");
+            }
+        }
 
         Ok(session)
     }
@@ -282,24 +295,47 @@ impl Cryptoki {
     }
 }
 
-fn get_all_slots_info(cryptoki: &Pkcs11) -> anyhow::Result<Vec<SlotInfo>> {
-    let slotinfos = cryptoki
-        .get_all_slots()?
+fn get_all_slots_info(cryptoki: &Pkcs11) -> Vec<SlotInfo> {
+    let slots = match cryptoki.get_all_slots() {
+        Ok(slots) => slots,
+        Err(err) => {
+            error!(?err, "failed to get slots");
+            return vec![];
+        }
+    };
+    let slotinfos = slots
         .into_iter()
-        .map(|s| cryptoki.get_slot_info(s))
-        .collect::<Result<Vec<_>, _>>()?;
+        .flat_map(|s| {
+            cryptoki
+                .get_slot_info(s)
+                .inspect_err(|err| error!(slot = ?s, ?err, "failed to read slot info from slot"))
+                .ok()
+        })
+        .collect::<Vec<_>>();
 
-    Ok(slotinfos)
+    slotinfos
 }
 
-fn get_all_token_info(cryptoki: &Pkcs11) -> anyhow::Result<Vec<TokenInfo>> {
-    let slots = cryptoki.get_slots_with_token()?;
+fn get_all_token_info(cryptoki: &Pkcs11) -> Vec<TokenInfo> {
+    let slots = match cryptoki.get_slots_with_token() {
+        Ok(slots) => slots,
+        Err(err) => {
+            error!(?err, "failed to get slots");
+            return vec![];
+        }
+    };
+
     let tokeninfos = slots
         .into_iter()
-        .map(|s| cryptoki.get_token_info(s))
-        .collect::<Result<Vec<_>, _>>()?;
+        .flat_map(|s| {
+            cryptoki
+                .get_token_info(s)
+                .inspect_err(|err| error!(slot = ?s, ?err, "failed to read token info from slot"))
+                .ok()
+        })
+        .collect::<Vec<_>>();
 
-    Ok(tokeninfos)
+    tokeninfos
 }
 
 /// A cryptoki session opened with a token.
@@ -478,38 +514,33 @@ impl<'a> CryptokiSession<'a> {
     }
 
     fn export_object_uri(&self, object: ObjectHandle) -> anyhow::Result<String> {
-        let mut attrs = self
-            .session
-            .get_attributes(object, &[AttributeType::Id, AttributeType::Label])?
-            .into_iter();
-
-        let id = attrs.next().context("No id")?;
-        let Attribute::Id(id) = id else {
-            anyhow::bail!("Not id");
-        };
-
-        let label = attrs.next().context("No label")?;
-        let Attribute::Label(label) = label else {
-            anyhow::bail!("Not label");
-        };
-        let label = std::str::from_utf8(&label).context("label should be utf-8")?;
+        let template = &[AttributeType::Id, AttributeType::Label];
+        let attrs = self.session.get_attributes(object, template)?.into_iter();
 
         let mut key_uri = export_session_uri(&self.token_info);
 
-        // id, object, type
-        key_uri.push(';');
-        key_uri.push_str("id=");
-        // from RFC section 2.3: Note that the value of the "id" attribute SHOULD NOT be encoded as UTF-8 because it can
-        // contain non-textual data, instead it SHOULD be entirely percent-encoded
-        for byte in &id {
-            key_uri.push_str(percent_encoding::percent_encode_byte(*byte));
+        for attr in attrs {
+            match attr {
+                Attribute::Id(id) => {
+                    key_uri.push(';');
+                    key_uri.push_str("id=");
+                    // from RFC section 2.3: Note that the value of the "id" attribute SHOULD NOT be encoded as UTF-8 because it can
+                    // contain non-textual data, instead it SHOULD be entirely percent-encoded
+                    for byte in &id {
+                        key_uri.push_str(percent_encoding::percent_encode_byte(*byte));
+                    }
+                }
+                Attribute::Label(label) => {
+                    let label = std::str::from_utf8(&label).context("label should be utf-8")?;
+                    key_uri.push(';');
+                    key_uri.push_str("object=");
+                    let label = uri::percent_encode(label);
+                    key_uri.push_str(&label);
+                }
+                other => warn!(asked = ?template, got= ?other, "Got invalid attribute"),
+            }
         }
 
-        key_uri.push(';');
-        key_uri.push_str("object=");
-        let label = uri::percent_encode(label);
-        key_uri.push_str(&label);
-
         // omit the "type" attribute since its not relevant when used as device.key_uri, which is intended use for this produced value
 
         anyhow::ensure!(key_uri.starts_with("pkcs11:"));