pwd-grp 1.0.2

Access Unix passwords and groups
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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157

//! Conversions and types (internal module)
//!
//! Mainly, this is implementations of `TryConvertFrom`.

use super::*;

//---------- conversions from the uninhabited NoError ----------

impl From<NoError> for io::Error {
    fn from(n: NoError) -> io::Error {
        match n {}
    }
}
impl From<NoError> for NonUtf8Error {
    fn from(n: NoError) -> NonUtf8Error {
        match n {}
    }
}

//---------- "string" type conversions - TryConvertFrom impls ----------

// Manual implementations

impl TryConvertFrom<Box<[u8]>> for String {
    type Error = NonUtf8Error;
    fn try_convert_from(v: Box<[u8]>, f: &str) -> Result<Self, Self::Error> {
        let v: Vec<u8> = v.into();
        let v = String::from_utf8(v)
            .map_err(|_| NonUtf8Error { field: f.into() })?;
        Ok(v)
    }
}
impl TryConvertFrom<Box<[u8]>> for Box<str> {
    type Error = NonUtf8Error;
    fn try_convert_from(v: Box<[u8]>, f: &str) -> Result<Self, Self::Error> {
        let v: String = TryConvertFrom::try_convert_from(v, f)?;
        Ok(v.into())
    }
}
impl TryConvertFrom<Box<str>> for Box<[u8]> {
    type Error = NoError;
    fn try_convert_from(v: Box<str>, _f: &str) -> Result<Self, Self::Error> {
        let v: String = v.into();
        let v = v.into_bytes();
        Ok(v.into())
    }
}

impl<T, U> TryConvertFrom<Box<[T]>> for Box<[U]>
where
    U: TryConvertFrom<T>,
{
    type Error = U::Error;
    fn try_convert_from(v: Box<[T]>, f: &str) -> Result<Self, Self::Error> {
        let v: Vec<_> = v.into();
        IntoIterator::into_iter(v)
            .map(|v| U::try_convert_from(v, f))
            .collect()
    }
}

// Conversions that can be derived by converting each field

define_derive_deftly! {
    /// Define `TryConvert` in terms of individual field conversions
    TryConvertFrom for struct, expect items:

    impl<T, S> TryConvertFrom<$tname<T>> for $tname<S>
    where S: TryConvertFrom<T>,
    {
        type Error = S::Error;
        fn try_convert_from(v: $tname<T>, _f: &str)
                            -> Result<Self, Self::Error>
        {
            Ok($tname { $( ${select1 fmeta(dummy) {
                $fname: NonExhaustive {},
            } else {
                $fname: TryConvertFrom::try_convert_from(
                    v.$fname,
                    stringify!(${paste ${tmeta(abbrev) as str} _ $fname}),
                )?,
            }}) })
        }
    }
}

// Infallible conversions that can use `Into`

macro_rules! impl_try_convert_from_via_into { { $T:ty, $U:ty } => {
    impl TryConvertFrom<$T> for $U {
        type Error = NoError;
        fn try_convert_from(v: $T, _f: &str) -> Result<Self, Self::Error> {
            Ok(v.into())
        }
    }
} }
macro_rules! impl_infallible_std_from_into { { $T:ty, $U:ty
                                               $(, via $VIA:ty )? } => {
    impl From<Passwd<$T>> for Passwd<$U> {
        fn from(v: Passwd<$T>) -> Passwd<$U> {
            $( let v: Passwd<$VIA> = v.into(); )?
            TryConvertFrom::try_convert_from(v, "")
                .unwrap_or_else(|e | match e { })
        }
    }

    impl From<Group<$T>> for Group<$U> {
        fn from(v: Group<$T>) -> Group<$U> {
            $( let v: Group<$VIA> = v.into(); )?
            TryConvertFrom::try_convert_from(v, "")
                .unwrap_or_else(|e | match e { })
        }
    }
} }
macro_rules! impl_infallible_conversions { { $T:ty, $U:ty } => {
    impl_try_convert_from_via_into!($T, $U);
    impl_infallible_std_from_into!($T, $U);
} }

impl_try_convert_from_via_into!(Id, Id);
impl_try_convert_from_via_into!(Box<[u8]>, Box<[u8]>);

impl_infallible_conversions!(Box<[u8]>, Vec<u8>); // make growable
impl_infallible_conversions!(Vec<u8>, Box<[u8]>); // make fixed-len
impl_infallible_conversions!(Box<str>, String); // make growable
impl_infallible_conversions!(String, Box<str>); // make fixed-len
impl_infallible_conversions!(String, Vec<u8>); // to bytes (growable)
impl_infallible_std_from_into!(Box<str>, Box<[u8]>); // to bytes (fixed)
impl_infallible_std_from_into!(String, Box<[u8]>, via Box<str>); // for mocks

// fallible From/Into between various Passwd and Group

macro_rules! impl_std_try_from_into { { $P:ident, $T:ty, $U:ty } => {
    impl TryFrom<$P<$T>> for $P<$U> {
        type Error = NonUtf8Error;
        fn try_from(v: $P<$T>) -> Result<$P<$U>, Self::Error> {
            let v: $P<RawSafe> = v.into();
            let v: $P<Box<str>> = TryConvertFrom::try_convert_from(v, "")?;
            Ok(v.into())
        }
    }
} }

impl_std_try_from_into!(Passwd, Vec<u8>, String); // growable
impl_std_try_from_into!(Passwd, Box<[u8]>, Box<str>); // fixed-len
impl_std_try_from_into!(Group, Vec<u8>, String); // growable
impl_std_try_from_into!(Group, Box<[u8]>, Box<str>); // fixed-len

//---------- helper types and functions ----------

pub(crate) fn handle_nul_in_name_as_io(e: NulError) -> io::Error {
    io::Error::new(InvalidInput, e)
}

pub(crate) fn cstring_from(name: &[u8]) -> io::Result<CString> {
    CString::new(name).map_err(handle_nul_in_name_as_io)
}