diff --git a/src/base.rs b/src/base.rs new file mode 100644 index 0000000..a2d756d --- /dev/null +++ b/src/base.rs @@ -0,0 +1,409 @@ +use std::io::{Error as IOError, Result as IOResult}; +use std::ffi::{CStr, CString}; +use std::ptr::read; +use std::str::from_utf8_unchecked; +use std::sync::Arc; + + +use libc::{uid_t, gid_t, c_int}; + +#[cfg(any(target_os = "macos", target_os = "freebsd", target_os = "dragonfly"))] +use libc::{c_char, time_t}; + +#[cfg(target_os = "linux")] +use libc::c_char; + + +#[cfg(any(target_os = "macos", target_os = "freebsd", target_os = "dragonfly"))] +#[repr(C)] +struct c_passwd { + pw_name: *const c_char, // user name + pw_passwd: *const c_char, // password field + pw_uid: uid_t, // user ID + pw_gid: gid_t, // group ID + pw_change: time_t, // password change time + pw_class: *const c_char, + pw_gecos: *const c_char, + pw_dir: *const c_char, // user's home directory + pw_shell: *const c_char, // user's shell + pw_expire: time_t, // password expiry time +} + +#[cfg(target_os = "linux")] +#[repr(C)] +struct c_passwd { + pw_name: *const c_char, // user name + pw_passwd: *const c_char, // password field + pw_uid: uid_t, // user ID + pw_gid: gid_t, // group ID + pw_gecos: *const c_char, + pw_dir: *const c_char, // user's home directory + pw_shell: *const c_char, // user's shell +} + +#[repr(C)] +struct c_group { + gr_name: *const c_char, // group name + gr_passwd: *const c_char, // password + gr_gid: gid_t, // group id + gr_mem: *const *const c_char, // names of users in the group +} + +extern { + fn getpwuid(uid: uid_t) -> *const c_passwd; + fn getpwnam(user_name: *const c_char) -> *const c_passwd; + + fn getgrgid(gid: gid_t) -> *const c_group; + fn getgrnam(group_name: *const c_char) -> *const c_group; + + fn getuid() -> uid_t; + fn geteuid() -> uid_t; + + fn setuid(uid: uid_t) -> c_int; + fn seteuid(uid: uid_t) -> c_int; + + fn getgid() -> gid_t; + fn getegid() -> gid_t; + + fn setgid(gid: gid_t) -> c_int; + fn setegid(gid: gid_t) -> c_int; + + fn setreuid(ruid: uid_t, euid: uid_t) -> c_int; + fn setregid(rgid: gid_t, egid: gid_t) -> c_int; +} + +/// Information about a particular user. +#[derive(Clone)] +pub struct User { + + /// This user's ID + pub uid: uid_t, + + /// This user's name + pub name: Arc, + + /// The ID of this user's primary group + pub primary_group: gid_t, + + /// This user's home directory + pub home_dir: String, + + /// This user's shell + pub shell: String, +} + +/// Information about a particular group. +#[derive(Clone)] +pub struct Group { + + /// This group's ID + pub gid: uid_t, + + /// This group's name + pub name: Arc, + + /// Vector of the names of the users who belong to this group as a non-primary member + pub members: Vec, +} + +unsafe fn from_raw_buf(p: *const i8) -> String { + from_utf8_unchecked(CStr::from_ptr(p).to_bytes()).to_string() +} + +unsafe fn passwd_to_user(pointer: *const c_passwd) -> Option { + if !pointer.is_null() { + let pw = read(pointer); + Some(User { + uid: pw.pw_uid as uid_t, + name: Arc::new(from_raw_buf(pw.pw_name as *const i8)), + primary_group: pw.pw_gid as gid_t, + home_dir: from_raw_buf(pw.pw_dir as *const i8), + shell: from_raw_buf(pw.pw_shell as *const i8) + }) + } + else { + None + } +} + +unsafe fn struct_to_group(pointer: *const c_group) -> Option { + if !pointer.is_null() { + let gr = read(pointer); + let name = from_raw_buf(gr.gr_name as *const i8); + let members = members(gr.gr_mem); + Some(Group { gid: gr.gr_gid, name: Arc::new(name), members: members }) + } + else { + None + } +} + +unsafe fn members(groups: *const *const c_char) -> Vec { + let mut i = 0; + let mut members = vec![]; + + // The list of members is a pointer to a pointer of characters, terminated + // by a null pointer. + loop { + let username = groups.offset(i); + + // The first null check here should be unnecessary, but if libc sends + // us bad data, it's probably better to continue on than crashing... + if username.is_null() || (*username).is_null() { + return members; + } + + members.push(from_raw_buf(*username)); + i += 1; + } +} + + +/// Searches for a `User` with the given ID in the system’s user database. +/// Returns it if one is found, otherwise returns `None`. +pub fn get_user_by_uid(uid: uid_t) -> Option { + unsafe { passwd_to_user(getpwuid(uid)) } +} + +/// Searches for a `User` with the given username in the system’s user database. +/// Returns it if one is found, otherwise returns `None`. +pub fn get_user_by_name(username: &str) -> Option { + let username_c = CString::new(username); + + if !username_c.is_ok() { + // This usually means the given username contained a '\0' already + // It is debatable what to do here + return None; + } + + unsafe { passwd_to_user(getpwnam(username_c.unwrap().as_ptr())) } +} + +/// Searches for a `Group` with the given ID in the system’s group database. +/// Returns it if one is found, otherwise returns `None`. +pub fn get_group_by_gid(gid: gid_t) -> Option { + unsafe { struct_to_group(getgrgid(gid)) } +} + +/// Searches for a `Group` with the given group name in the system‘s group database. +/// Returns it if one is found, otherwise returns `None`. +pub fn get_group_by_name(group_name: &str) -> Option { + let group_name_c = CString::new(group_name); + + if !group_name_c.is_ok() { + // This usually means the given username contained a '\0' already + // It is debatable what to do here + return None; + } + + unsafe { struct_to_group(getgrnam(group_name_c.unwrap().as_ptr())) } +} + +/// Returns the user ID for the user running the process. +pub fn get_current_uid() -> uid_t { + unsafe { getuid() } +} + +/// Returns the username of the user running the process. +pub fn get_current_username() -> Option { + let uid = get_current_uid(); + get_user_by_uid(uid).map(|u| Arc::try_unwrap(u.name).unwrap()) +} + +/// Returns the user ID for the effective user running the process. +pub fn get_effective_uid() -> uid_t { + unsafe { geteuid() } +} + +/// Returns the username of the effective user running the process. +pub fn get_effective_username() -> Option { + let uid = get_effective_uid(); + get_user_by_uid(uid).map(|u| Arc::try_unwrap(u.name).unwrap()) +} + +/// Returns the group ID for the user running the process. +pub fn get_current_gid() -> gid_t { + unsafe { getgid() } +} + +/// Returns the groupname of the user running the process. +pub fn get_current_groupname() -> Option { + let gid = get_current_gid(); + get_group_by_gid(gid).map(|g| Arc::try_unwrap(g.name).unwrap()) +} + +/// Returns the group ID for the effective user running the process. +pub fn get_effective_gid() -> gid_t { + unsafe { getegid() } +} + +/// Returns the groupname of the effective user running the process. +pub fn get_effective_groupname() -> Option { + let gid = get_effective_gid(); + get_group_by_gid(gid).map(|g| Arc::try_unwrap(g.name).unwrap()) +} + +/// Sets current user for the running process, requires root priviledges. +pub fn set_current_uid(uid: uid_t) -> IOResult<()> { + match unsafe { setuid(uid) } { + 0 => Ok(()), + -1 => Err(IOError::last_os_error()), + _ => unreachable!() + } +} + +/// Set current group for the running process, requires root priviledges. +pub fn set_current_gid(gid: gid_t) -> IOResult<()> { + match unsafe { setgid(gid) } { + 0 => Ok(()), + -1 => Err(IOError::last_os_error()), + _ => unreachable!() + } +} + +/// Set effective user for the running process, requires root priviledges. +pub fn set_effective_uid(uid: uid_t) -> IOResult<()> { + match unsafe { seteuid(uid) } { + 0 => Ok(()), + -1 => Err(IOError::last_os_error()), + _ => unreachable!() + } +} + +/// Set effective user for the running process, requires root priviledges. +pub fn set_effective_gid(gid: gid_t) -> IOResult<()> { + match unsafe { setegid(gid) } { + 0 => Ok(()), + -1 => Err(IOError::last_os_error()), + _ => unreachable!() + } +} + +/// Atomically set current and effective user for the running process, requires root priviledges. +pub fn set_both_uid(ruid: uid_t, euid: uid_t) -> IOResult<()> { + match unsafe { setreuid(ruid, euid) } { + 0 => Ok(()), + -1 => Err(IOError::last_os_error()), + _ => unreachable!() + } +} + +/// Atomically set current and effective group for the running process, requires root priviledges. +pub fn set_both_gid(rgid: gid_t, egid: gid_t) -> IOResult<()> { + match unsafe { setregid(rgid, egid) } { + 0 => Ok(()), + -1 => Err(IOError::last_os_error()), + _ => unreachable!() + } +} + +pub struct SwitchUserGuard { + uid: uid_t, + gid: gid_t, +} + +impl Drop for SwitchUserGuard { + fn drop(&mut self) { + // Panic on error here, as failing to set values back + // is a possible security breach. + set_effective_uid(self.uid).unwrap(); + set_effective_gid(self.gid).unwrap(); + } +} + +/// Safely switch user and group for the current scope. +/// Requires root access. +/// +/// ```ignore +/// { +/// let _guard = switch_user_group(1001, 1001); +/// // current and effective user and group ids are 1001 +/// } +/// // back to the old values +/// ``` +/// +/// Use with care! Possible security issues can happen, as Rust doesn't +/// guarantee running the destructor! If in doubt run `drop()` method +/// on the guard value manually! +pub fn switch_user_group(uid: uid_t, gid: gid_t) -> Result { + let current_state = SwitchUserGuard { + uid: get_effective_uid(), + gid: get_effective_gid(), + }; + + try!(set_effective_uid(uid)); + try!(set_effective_gid(gid)); + Ok(current_state) +} + + +#[cfg(test)] +mod test { + use super::*; + + #[test] + fn uid() { + get_current_uid(); + } + + #[test] + fn username() { + let uid = get_current_uid(); + assert_eq!(&*get_current_username().unwrap(), &*get_user_by_uid(uid).unwrap().name); + } + + #[test] + fn uid_for_username() { + let uid = get_current_uid(); + let user = get_user_by_uid(uid).unwrap(); + assert_eq!(user.uid, uid); + } + + #[test] + fn username_for_uid_for_username() { + let uid = get_current_uid(); + let user = get_user_by_uid(uid).unwrap(); + let user2 = get_user_by_uid(user.uid).unwrap(); + assert_eq!(user2.uid, uid); + } + + #[test] + fn user_info() { + let uid = get_current_uid(); + let user = get_user_by_uid(uid).unwrap(); + // Not a real test but can be used to verify correct results + // Use with --nocapture on test executable to show output + println!("HOME={}, SHELL={}", user.home_dir, user.shell); + } + + #[test] + fn user_by_name() { + // We cannot really test for arbitrary user as they might not exist on the machine + // Instead the name of the current user is used + let name = get_current_username().unwrap(); + let user_by_name = get_user_by_name(&name); + assert!(user_by_name.is_some()); + assert_eq!(&**user_by_name.unwrap().name, &*name); + + // User names containing '\0' cannot be used (for now) + let user = get_user_by_name("user\0"); + assert!(user.is_none()); + } + + #[test] + fn group_by_name() { + // We cannot really test for arbitrary groups as they might not exist on the machine + // Instead the primary group of the current user is used + let cur_uid = get_current_uid(); + let cur_user = get_user_by_uid(cur_uid).unwrap(); + let cur_group = get_group_by_gid(cur_user.primary_group).unwrap(); + let group_by_name = get_group_by_name(&cur_group.name); + + assert!(group_by_name.is_some()); + assert_eq!(group_by_name.unwrap().name, cur_group.name); + + // Group names containing '\0' cannot be used (for now) + let group = get_group_by_name("users\0"); + assert!(group.is_none()); + } +} diff --git a/src/lib.rs b/src/lib.rs index d749d41..5de5a6f 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -108,20 +108,11 @@ //! Use the mocking module to create custom tables to test your code for these //! edge cases. -use std::ffi::{CStr, CString}; -use std::io::{Error as IOError, Result as IOResult}; -use std::ptr::read; -use std::str::from_utf8_unchecked; -use std::sync::Arc; - extern crate libc; pub use libc::{uid_t, gid_t, c_int}; -#[cfg(any(target_os = "macos", target_os = "freebsd", target_os = "dragonfly"))] -use libc::{c_char, time_t}; - -#[cfg(target_os = "linux")] -use libc::c_char; +mod base; +pub use base::*; pub mod mock; pub mod os; @@ -129,397 +120,3 @@ pub use os::OSUsers; mod traits; pub use traits::{Users, Groups}; - -#[cfg(any(target_os = "macos", target_os = "freebsd", target_os = "dragonfly"))] -#[repr(C)] -struct c_passwd { - pw_name: *const c_char, // user name - pw_passwd: *const c_char, // password field - pw_uid: uid_t, // user ID - pw_gid: gid_t, // group ID - pw_change: time_t, // password change time - pw_class: *const c_char, - pw_gecos: *const c_char, - pw_dir: *const c_char, // user's home directory - pw_shell: *const c_char, // user's shell - pw_expire: time_t, // password expiry time -} - -#[cfg(target_os = "linux")] -#[repr(C)] -struct c_passwd { - pw_name: *const c_char, // user name - pw_passwd: *const c_char, // password field - pw_uid: uid_t, // user ID - pw_gid: gid_t, // group ID - pw_gecos: *const c_char, - pw_dir: *const c_char, // user's home directory - pw_shell: *const c_char, // user's shell -} - -#[repr(C)] -struct c_group { - gr_name: *const c_char, // group name - gr_passwd: *const c_char, // password - gr_gid: gid_t, // group id - gr_mem: *const *const c_char, // names of users in the group -} - -extern { - fn getpwuid(uid: uid_t) -> *const c_passwd; - fn getpwnam(user_name: *const c_char) -> *const c_passwd; - - fn getgrgid(gid: gid_t) -> *const c_group; - fn getgrnam(group_name: *const c_char) -> *const c_group; - - fn getuid() -> uid_t; - fn geteuid() -> uid_t; - - fn setuid(uid: uid_t) -> c_int; - fn seteuid(uid: uid_t) -> c_int; - - fn getgid() -> gid_t; - fn getegid() -> gid_t; - - fn setgid(gid: gid_t) -> c_int; - fn setegid(gid: gid_t) -> c_int; - - fn setreuid(ruid: uid_t, euid: uid_t) -> c_int; - fn setregid(rgid: gid_t, egid: gid_t) -> c_int; -} - -/// Information about a particular user. -#[derive(Clone)] -pub struct User { - - /// This user's ID - pub uid: uid_t, - - /// This user's name - pub name: Arc, - - /// The ID of this user's primary group - pub primary_group: gid_t, - - /// This user's home directory - pub home_dir: String, - - /// This user's shell - pub shell: String, -} - -/// Information about a particular group. -#[derive(Clone)] -pub struct Group { - - /// This group's ID - pub gid: uid_t, - - /// This group's name - pub name: Arc, - - /// Vector of the names of the users who belong to this group as a non-primary member - pub members: Vec, -} - -unsafe fn from_raw_buf(p: *const i8) -> String { - from_utf8_unchecked(CStr::from_ptr(p).to_bytes()).to_string() -} - -unsafe fn passwd_to_user(pointer: *const c_passwd) -> Option { - if !pointer.is_null() { - let pw = read(pointer); - Some(User { - uid: pw.pw_uid as uid_t, - name: Arc::new(from_raw_buf(pw.pw_name as *const i8)), - primary_group: pw.pw_gid as gid_t, - home_dir: from_raw_buf(pw.pw_dir as *const i8), - shell: from_raw_buf(pw.pw_shell as *const i8) - }) - } - else { - None - } -} - -unsafe fn struct_to_group(pointer: *const c_group) -> Option { - if !pointer.is_null() { - let gr = read(pointer); - let name = from_raw_buf(gr.gr_name as *const i8); - let members = members(gr.gr_mem); - Some(Group { gid: gr.gr_gid, name: Arc::new(name), members: members }) - } - else { - None - } -} - -unsafe fn members(groups: *const *const c_char) -> Vec { - let mut i = 0; - let mut members = vec![]; - - // The list of members is a pointer to a pointer of characters, terminated - // by a null pointer. - loop { - let username = groups.offset(i); - - // The first null check here should be unnecessary, but if libc sends - // us bad data, it's probably better to continue on than crashing... - if username.is_null() || (*username).is_null() { - return members; - } - - members.push(from_raw_buf(*username)); - i += 1; - } -} - - -/// Searches for a `User` with the given ID in the system’s user database. -/// Returns it if one is found, otherwise returns `None`. -pub fn get_user_by_uid(uid: uid_t) -> Option { - unsafe { passwd_to_user(getpwuid(uid)) } -} - -/// Searches for a `User` with the given username in the system’s user database. -/// Returns it if one is found, otherwise returns `None`. -pub fn get_user_by_name(username: &str) -> Option { - let username_c = CString::new(username); - - if !username_c.is_ok() { - // This usually means the given username contained a '\0' already - // It is debatable what to do here - return None; - } - - unsafe { passwd_to_user(getpwnam(username_c.unwrap().as_ptr())) } -} - -/// Searches for a `Group` with the given ID in the system’s group database. -/// Returns it if one is found, otherwise returns `None`. -pub fn get_group_by_gid(gid: gid_t) -> Option { - unsafe { struct_to_group(getgrgid(gid)) } -} - -/// Searches for a `Group` with the given group name in the system‘s group database. -/// Returns it if one is found, otherwise returns `None`. -pub fn get_group_by_name(group_name: &str) -> Option { - let group_name_c = CString::new(group_name); - - if !group_name_c.is_ok() { - // This usually means the given username contained a '\0' already - // It is debatable what to do here - return None; - } - - unsafe { struct_to_group(getgrnam(group_name_c.unwrap().as_ptr())) } -} - -/// Returns the user ID for the user running the process. -pub fn get_current_uid() -> uid_t { - unsafe { getuid() } -} - -/// Returns the username of the user running the process. -pub fn get_current_username() -> Option { - let uid = get_current_uid(); - get_user_by_uid(uid).map(|u| Arc::try_unwrap(u.name).unwrap()) -} - -/// Returns the user ID for the effective user running the process. -pub fn get_effective_uid() -> uid_t { - unsafe { geteuid() } -} - -/// Returns the username of the effective user running the process. -pub fn get_effective_username() -> Option { - let uid = get_effective_uid(); - get_user_by_uid(uid).map(|u| Arc::try_unwrap(u.name).unwrap()) -} - -/// Returns the group ID for the user running the process. -pub fn get_current_gid() -> gid_t { - unsafe { getgid() } -} - -/// Returns the groupname of the user running the process. -pub fn get_current_groupname() -> Option { - let gid = get_current_gid(); - get_group_by_gid(gid).map(|g| Arc::try_unwrap(g.name).unwrap()) -} - -/// Returns the group ID for the effective user running the process. -pub fn get_effective_gid() -> gid_t { - unsafe { getegid() } -} - -/// Returns the groupname of the effective user running the process. -pub fn get_effective_groupname() -> Option { - let gid = get_effective_gid(); - get_group_by_gid(gid).map(|g| Arc::try_unwrap(g.name).unwrap()) -} - -/// Sets current user for the running process, requires root priviledges. -pub fn set_current_uid(uid: uid_t) -> IOResult<()> { - match unsafe { setuid(uid) } { - 0 => Ok(()), - -1 => Err(IOError::last_os_error()), - _ => unreachable!() - } -} - -/// Set current group for the running process, requires root priviledges. -pub fn set_current_gid(gid: gid_t) -> IOResult<()> { - match unsafe { setgid(gid) } { - 0 => Ok(()), - -1 => Err(IOError::last_os_error()), - _ => unreachable!() - } -} - -/// Set effective user for the running process, requires root priviledges. -pub fn set_effective_uid(uid: uid_t) -> IOResult<()> { - match unsafe { seteuid(uid) } { - 0 => Ok(()), - -1 => Err(IOError::last_os_error()), - _ => unreachable!() - } -} - -/// Set effective user for the running process, requires root priviledges. -pub fn set_effective_gid(gid: gid_t) -> IOResult<()> { - match unsafe { setegid(gid) } { - 0 => Ok(()), - -1 => Err(IOError::last_os_error()), - _ => unreachable!() - } -} - -/// Atomically set current and effective user for the running process, requires root priviledges. -pub fn set_both_uid(ruid: uid_t, euid: uid_t) -> IOResult<()> { - match unsafe { setreuid(ruid, euid) } { - 0 => Ok(()), - -1 => Err(IOError::last_os_error()), - _ => unreachable!() - } -} - -/// Atomically set current and effective group for the running process, requires root priviledges. -pub fn set_both_gid(rgid: gid_t, egid: gid_t) -> IOResult<()> { - match unsafe { setregid(rgid, egid) } { - 0 => Ok(()), - -1 => Err(IOError::last_os_error()), - _ => unreachable!() - } -} - -pub struct SwitchUserGuard { - uid: uid_t, - gid: gid_t, -} - -impl Drop for SwitchUserGuard { - fn drop(&mut self) { - // Panic on error here, as failing to set values back - // is a possible security breach. - set_effective_uid(self.uid).unwrap(); - set_effective_gid(self.gid).unwrap(); - } -} - -/// Safely switch user and group for the current scope. -/// Requires root access. -/// -/// ```ignore -/// { -/// let _guard = switch_user_group(1001, 1001); -/// // current and effective user and group ids are 1001 -/// } -/// // back to the old values -/// ``` -/// -/// Use with care! Possible security issues can happen, as Rust doesn't -/// guarantee running the destructor! If in doubt run `drop()` method -/// on the guard value manually! -pub fn switch_user_group(uid: uid_t, gid: gid_t) -> Result { - let current_state = SwitchUserGuard { - uid: get_effective_uid(), - gid: get_effective_gid(), - }; - - try!(set_effective_uid(uid)); - try!(set_effective_gid(gid)); - Ok(current_state) -} - - -#[cfg(test)] -mod test { - use super::*; - - #[test] - fn uid() { - get_current_uid(); - } - - #[test] - fn username() { - let uid = get_current_uid(); - assert_eq!(&*get_current_username().unwrap(), &*get_user_by_uid(uid).unwrap().name); - } - - #[test] - fn uid_for_username() { - let uid = get_current_uid(); - let user = get_user_by_uid(uid).unwrap(); - assert_eq!(user.uid, uid); - } - - #[test] - fn username_for_uid_for_username() { - let uid = get_current_uid(); - let user = get_user_by_uid(uid).unwrap(); - let user2 = get_user_by_uid(user.uid).unwrap(); - assert_eq!(user2.uid, uid); - } - - #[test] - fn user_info() { - let uid = get_current_uid(); - let user = get_user_by_uid(uid).unwrap(); - // Not a real test but can be used to verify correct results - // Use with --nocapture on test executable to show output - println!("HOME={}, SHELL={}", user.home_dir, user.shell); - } - - #[test] - fn user_by_name() { - // We cannot really test for arbitrary user as they might not exist on the machine - // Instead the name of the current user is used - let name = get_current_username().unwrap(); - let user_by_name = get_user_by_name(&name); - assert!(user_by_name.is_some()); - assert_eq!(&**user_by_name.unwrap().name, &*name); - - // User names containing '\0' cannot be used (for now) - let user = get_user_by_name("user\0"); - assert!(user.is_none()); - } - - #[test] - fn group_by_name() { - // We cannot really test for arbitrary groups as they might not exist on the machine - // Instead the primary group of the current user is used - let cur_uid = get_current_uid(); - let cur_user = get_user_by_uid(cur_uid).unwrap(); - let cur_group = get_group_by_gid(cur_user.primary_group).unwrap(); - let group_by_name = get_group_by_name(&cur_group.name); - - assert!(group_by_name.is_some()); - assert_eq!(group_by_name.unwrap().name, cur_group.name); - - // Group names containing '\0' cannot be used (for now) - let group = get_group_by_name("users\0"); - assert!(group.is_none()); - } -} diff --git a/src/mock.rs b/src/mock.rs index 5480b02..23f9fd2 100644 --- a/src/mock.rs +++ b/src/mock.rs @@ -53,10 +53,13 @@ //! print_current_username(&mut actual_users); //! ``` -pub use super::{Users, Groups, User, Group}; use std::collections::HashMap; use std::sync::Arc; -use libc::{uid_t, gid_t}; + +pub use libc::{uid_t, gid_t}; +pub use base::{User, Group}; +pub use traits::{Users, Groups}; + /// A mocking users object that you can add your own users and groups to. pub struct MockUsers { @@ -141,7 +144,9 @@ impl Groups for MockUsers { #[cfg(test)] mod test { - use super::{Users, Groups, User, Group, MockUsers}; + use super::{MockUsers}; + use base::{User, Group}; + use traits::{Users, Groups}; use std::sync::Arc; #[test] diff --git a/src/os.rs b/src/os.rs index dd92427..7870fca 100644 --- a/src/os.rs +++ b/src/os.rs @@ -68,7 +68,8 @@ use std::collections::hash_map::Entry::{Occupied, Vacant}; use std::collections::HashMap; use std::sync::Arc; -use super::{User, Groups, Group, Users}; +use base::{User, Group}; +use traits::{Users, Groups}; /// A producer of user and group instances that caches every result.