tyler/proxmox-backup
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

authid: make Tokenname(Ref) derive Eq

Browse Source 
it's needed to derive Hash, and we always compare Authids or their
Userid components, never just the Tokenname part anyway..

Signed-off-by: Fabian Grünbichler <f.gruenbichler@proxmox.com>
This commit is contained in:
Fabian Grünbichler
2021-01-25 14:42:56 +01:00
committed by Wolfgang Bumiller
parent 72064fd0df
commit f4e52bb27d
1 changed files with 6 additions and 44 deletions
Download Patch File Download Diff File Expand all files Collapse all files

50
src/api2/types/userid.rs
View File

@ -16,10 +16,10 @@
//! * [`Authid`]: an owned Authentication ID (a `Userid` with an optional `Tokenname`). //! * [`Authid`]: an owned Authentication ID (a `Userid` with an optional `Tokenname`).
//! Note that `Userid` and `Authid` do not have a separate borrowed type. //! Note that `Userid` and `Authid` do not have a separate borrowed type.
//! //!
//! Note that `Username`s and `Tokenname`s are not unique, therefore they do not implement `Eq` and cannot be //! Note that `Username`s are not unique, therefore they do not implement `Eq` and cannot be
//! compared directly. If a direct comparison is really required, they can be compared as strings //! compared directly. If a direct comparison is really required, they can be compared as strings
//! via the `as_str()` method. [`Realm`]s, [`Userid`]s and [`Authid`]s on the other //! via the `as_str()` method. [`Realm`]s, [`Userid`]s and [`Authid`]s on the other hand can be
//! hand can be compared with each other, as in those cases the comparison has meaning. //! compared with each other, as in those cases the comparison has meaning.
use std::borrow::Borrow; use std::borrow::Borrow;
use std::convert::TryFrom; use std::convert::TryFrom;
@ -299,16 +299,8 @@ impl PartialEq<Realm> for &RealmRef {
)] )]
/// The token ID part of an API token authentication id. /// The token ID part of an API token authentication id.
/// ///
/// This alone does NOT uniquely identify the API token and therefore does not implement `Eq`. In /// This alone does NOT uniquely identify the API token - use a full `Authid` for such use cases.
/// order to compare token IDs directly, they need to be explicitly compared as strings by calling #[derive(Clone, Debug, Eq, Hash, PartialEq, Deserialize, Serialize)]
/// `.as_str()`.
///
/// ```compile_fail
/// fn test(a: Tokenname, b: Tokenname) -> bool {
/// a == b // illegal and does not compile
/// }
/// ```
#[derive(Clone, Debug, Hash, Deserialize, Serialize)]
pub struct Tokenname(String); pub struct Tokenname(String);
/// A reference to a token name part of an authentication id. This alone does NOT uniquely identify /// A reference to a token name part of an authentication id. This alone does NOT uniquely identify
@ -336,24 +328,6 @@ pub struct TokennameRef(str);
/// let b: &UsernameRef = unsafe { std::mem::zeroed() }; /// let b: &UsernameRef = unsafe { std::mem::zeroed() };
/// let _ = <&UsernameRef as PartialEq>::eq(&a, &b); /// let _ = <&UsernameRef as PartialEq>::eq(&a, &b);
/// ``` /// ```
///
/// ```compile_fail
/// let a: Tokenname = unsafe { std::mem::zeroed() };
/// let b: Tokenname = unsafe { std::mem::zeroed() };
/// let _ = <Tokenname as PartialEq>::eq(&a, &b);
/// ```
///
/// ```compile_fail
/// let a: &TokennameRef = unsafe { std::mem::zeroed() };
/// let b: &TokennameRef = unsafe { std::mem::zeroed() };
/// let _ = <&TokennameRef as PartialEq>::eq(a, b);
/// ```
///
/// ```compile_fail
/// let a: &TokennameRef = unsafe { std::mem::zeroed() };
/// let b: &TokennameRef = unsafe { std::mem::zeroed() };
/// let _ = <&TokennameRef as PartialEq>::eq(&a, &b);
/// ```
struct _AssertNoEqImpl; struct _AssertNoEqImpl;
impl TokennameRef { impl TokennameRef {
@ -548,7 +522,7 @@ impl PartialEq<String> for Userid {
} }
/// A complete authentication id consisting of a user id and an optional token name. /// A complete authentication id consisting of a user id and an optional token name.
#[derive(Clone, Debug, Hash)] #[derive(Clone, Debug, Eq, PartialEq, Hash)]
pub struct Authid { pub struct Authid {
user: Userid, user: Userid,
tokenname: Option<Tokenname> tokenname: Option<Tokenname>
@ -590,18 +564,6 @@ lazy_static! {
pub static ref ROOT_AUTHID: Authid = Authid::from(Userid::new("root@pam".to_string(), 4)); pub static ref ROOT_AUTHID: Authid = Authid::from(Userid::new("root@pam".to_string(), 4));
} }
impl Eq for Authid {}
impl PartialEq for Authid {
fn eq(&self, rhs: &Self) -> bool {
self.user == rhs.user && match (&self.tokenname, &rhs.tokenname) {
(Some(ours), Some(theirs)) => ours.as_str() == theirs.as_str(),
(None, None) => true,
_ => false,
}
}
}
impl From<Userid> for Authid { impl From<Userid> for Authid {
fn from(parts: Userid) -> Self { fn from(parts: Userid) -> Self {
Self::new(parts, None) Self::new(parts, None)