yash-env 0.13.2

Yash shell execution environment interface
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

// This file is part of yash, an extended POSIX shell.
// Copyright (C) 2025 WATANABE Yuki
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <https://www.gnu.org/licenses/>.

//! Items for user management

use super::Result;
use crate::path::PathBuf;
use std::ffi::CStr;
use std::rc::Rc;

#[cfg(unix)]
type RawUidDef = libc::uid_t;
#[cfg(not(unix))]
type RawUidDef = u32;

/// Raw user ID type
///
/// This is a type alias for the raw user ID type `uid_t` declared in the
/// [`libc`] crate. The exact representation of this type is platform-dependent
/// while POSIX requires the type to be an integer. On non-Unix platforms, this
/// type is hard-coded to `u32`.
///
/// User IDs are usually wrapped in the [`Uid`] type for better type safety, so
/// this type is not used directly in most cases.
pub type RawUid = RawUidDef;

/// User ID
///
/// This type implements the new type pattern for the raw user ID type
/// [`RawUid`]. The advantage of using this type is that it is more type-safe
/// than using the raw integer value directly.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(transparent)]
pub struct Uid(pub RawUid);

#[cfg(unix)]
type RawGidDef = libc::gid_t;
#[cfg(not(unix))]
type RawGidDef = u32;

/// Raw group ID type
///
/// This is a type alias for the raw group ID type `gid_t` declared in the
/// [`libc`] crate. The exact representation of this type is platform-dependent
/// while POSIX requires the type to be an integer. On non-Unix platforms, this
/// type is hard-coded to `u32`.
///
/// Group IDs are usually wrapped in the [`Gid`] type for better type safety, so
/// this type is not used directly in most cases.
pub type RawGid = RawGidDef;

/// Group ID
///
/// This type implements the new type pattern for the raw group ID type
/// [`RawGid`]. The advantage of using this type is that it is more type-safe
/// than using the raw integer value directly.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(transparent)]
pub struct Gid(pub RawGid);

/// Trait for getting user and group IDs
pub trait GetUid {
    /// Returns the real user ID of the current process.
    fn getuid(&self) -> Uid;

    /// Returns the effective user ID of the current process.
    fn geteuid(&self) -> Uid;

    /// Returns the real group ID of the current process.
    fn getgid(&self) -> Gid;

    /// Returns the effective group ID of the current process.
    fn getegid(&self) -> Gid;
}

/// Delegates the `GetUid` trait to the contained instance of `S`
impl<S: GetUid> GetUid for Rc<S> {
    #[inline]
    fn getuid(&self) -> Uid {
        (self as &S).getuid()
    }
    #[inline]
    fn geteuid(&self) -> Uid {
        (self as &S).geteuid()
    }
    #[inline]
    fn getgid(&self) -> Gid {
        (self as &S).getgid()
    }
    #[inline]
    fn getegid(&self) -> Gid {
        (self as &S).getegid()
    }
}

/// Trait for getting user information
///
/// This trait declares methods for getting user information. `Pw` in the trait
/// name stands for "password", referring to the traditional Unix password
/// file that stores user account information.
pub trait GetPw {
    /// Returns the home directory path of the given user.
    ///
    /// Returns `Ok(None)` if the user is not found.
    fn getpwnam_dir(&self, name: &CStr) -> Result<Option<PathBuf>>;
}

/// Delegates the `GetPw` trait to the contained instance of `S`
impl<S: GetPw> GetPw for Rc<S> {
    #[inline]
    fn getpwnam_dir(&self, name: &CStr) -> Result<Option<PathBuf>> {
        (self as &S).getpwnam_dir(name)
    }
}