Merge pull request #45 from mathstuf/ci-no-warnings

api: make updating a key safer

Author: mathstuf

src/api.rs

@@ -533,12 +533,22 @@ impl Key {
         .map(Self::new_impl)
     }
 
+    /// Determine whether the key is of a specific implementation or not.
+    pub fn is_keytype<K>(&self) -> Result<bool>
+    where
+        K: KeyType,
+    {
+        let desc = self.description()?;
+        Ok(desc.type_ == K::name())
+    }
+
     /// Update the payload in the key.
-    pub fn update<D>(&mut self, data: D) -> Result<()>
+    pub fn update<K, P>(&mut self, payload: P) -> Result<()>
     where
-        D: AsRef<[u8]>,
+        K: KeyType,
+        P: Borrow<K::Payload>,
     {
-        keyctl_update(self.id, data.as_ref())
+        keyctl_update(self.id, &payload.borrow().payload())
     }
 
     /// Revokes the key. Requires `write` permission on the key.

src/tests/keytype.rs

@@ -0,0 +1,50 @@
+// Copyright (c) 2020, Ben Boeckel
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without modification,
+// are permitted provided that the following conditions are met:
+//
+//     * Redistributions of source code must retain the above copyright notice,
+//       this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above copyright notice,
+//       this list of conditions and the following disclaimer in the documentation
+//       and/or other materials provided with the distribution.
+//     * Neither the name of this project nor the names of its contributors
+//       may be used to endorse or promote products derived from this software
+//       without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+// ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+use crate::keytypes::{Keyring, User};
+
+use super::utils;
+
+#[test]
+fn test_keyring_is_keytype() {
+    let keyring = utils::new_test_keyring();
+    let key = utils::keyring_as_key(&keyring);
+
+    assert!(!key.is_keytype::<User>().unwrap());
+    assert!(key.is_keytype::<Keyring>().unwrap());
+}
+
+#[test]
+fn test_key_is_keytype() {
+    let mut keyring = utils::new_test_keyring();
+    let payload = &b"payload"[..];
+    let key = keyring
+        .add_key::<User, _, _>("test_key_is_keytype", payload)
+        .unwrap();
+
+    assert!(key.is_keytype::<User>().unwrap());
+    assert!(!key.is_keytype::<Keyring>().unwrap());
+}

src/tests/mod.rs

@@ -33,6 +33,7 @@ mod clear;
 mod describe;
 mod instantiate;
 mod invalidate;
+mod keytype;
 mod link;
 mod newring;
 mod permitting;

src/tests/update.rs

@@ -34,7 +34,7 @@ fn keyring() {
     let mut key = utils::keyring_as_key(&keyring);
 
     let payload = &b"payload"[..];
-    let err = key.update(payload).unwrap_err();
+    let err = key.update::<User, _>(payload).unwrap_err();
     assert_eq!(err, errno::Errno(libc::EOPNOTSUPP));
 }
 
@@ -43,7 +43,7 @@ fn invalid_key() {
     let mut key = utils::invalid_key();
 
     let payload = &b"payload"[..];
-    let err = key.update(payload).unwrap_err();
+    let err = key.update::<User, _>(payload).unwrap_err();
     assert_eq!(err, errno::Errno(libc::EINVAL));
 }
 
@@ -59,7 +59,7 @@ fn unlinked_key() {
     utils::wait_for_key_gc(&key);
 
     let payload = &b"payload"[..];
-    let err = key.update(payload).unwrap_err();
+    let err = key.update::<User, _>(payload).unwrap_err();
     assert_eq!(err, errno::Errno(libc::ENOKEY));
 }
 
@@ -73,7 +73,7 @@ fn user_key() {
     assert_eq!(payload, actual_payload.as_slice());
 
     let payload = &b"updated_payload"[..];
-    key.update(payload).unwrap();
+    key.update::<User, _>(payload).unwrap();
 
     let actual_payload = key.read().unwrap();
     assert_eq!(payload, actual_payload.as_slice());