Mercurial > crates > nonstick

comparison pam/src/module.rs @ 19:d654aa0655e5

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Making PamHandle a struct with methods
author Anthony Nowell <anthony@algorithmia.com>
date Mon, 25 Sep 2017 23:42:35 -0600
parents 27730595f1ea
children 4263c1d83d5b
comparison
equal deleted inserted replaced
18:0f5e9e8963ae 19:d654aa0655e5
10 /// 10 ///
11 /// A module is invoked via an external function such as `pam_sm_authenticate`. 11 /// A module is invoked via an external function such as `pam_sm_authenticate`.
12 /// Such a call provides a pam handle pointer. The same pointer should be given 12 /// Such a call provides a pam handle pointer. The same pointer should be given
13 /// as an argument when making API calls. 13 /// as an argument when making API calls.
14 #[allow(missing_copy_implementations)] 14 #[allow(missing_copy_implementations)]
15 pub enum PamHandleT {} 15 pub enum PamHandle {}
16 16
17 #[allow(missing_copy_implementations)] 17 #[allow(missing_copy_implementations)]
18 enum PamItemT {} 18 enum PamItemT {}
19 19
20 #[allow(missing_copy_implementations)] 20 #[allow(missing_copy_implementations)]
21 pub enum PamDataT {} 21 pub enum PamDataT {}
22 22
23 #[link(name = "pam")] 23 #[link(name = "pam")]
24 extern "C" { 24 extern "C" {
25 fn pam_get_data(pamh: *const PamHandleT, 25 fn pam_get_data(pamh: *const PamHandle,
26 module_data_name: *const c_char, 26 module_data_name: *const c_char,
27 data: &mut *const PamDataT) 27 data: &mut *const PamDataT)
28 -> PamResultCode; 28 -> PamResultCode;
29 29
30 fn pam_set_data(pamh: *const PamHandleT, 30 fn pam_set_data(pamh: *const PamHandle,
31 module_data_name: *const c_char, 31 module_data_name: *const c_char,
32 data: Box<PamDataT>, 32 data: Box<PamDataT>,
33 cleanup: extern "C" fn(pamh: *const PamHandleT, 33 cleanup: extern "C" fn(pamh: *const PamHandle,
34 data: Box<PamDataT>, 34 data: Box<PamDataT>,
35 error_status: PamResultCode)) 35 error_status: PamResultCode))
36 -> PamResultCode; 36 -> PamResultCode;
37 37
38 fn pam_get_item(pamh: *const PamHandleT, 38 fn pam_get_item(pamh: *const PamHandle,
39 item_type: PamItemType, 39 item_type: PamItemType,
40 item: &mut *const PamItemT) 40 item: &mut *const PamItemT)
41 -> PamResultCode; 41 -> PamResultCode;
42 42
43 fn pam_set_item(pamh: *mut PamHandleT, 43 fn pam_set_item(pamh: *mut PamHandle,
44 item_type: PamItemType, 44 item_type: PamItemType,
45 item: &PamItemT) 45 item: &PamItemT)
46 -> PamResultCode; 46 -> PamResultCode;
47 47
48 fn pam_get_user(pamh: *const PamHandleT, 48 fn pam_get_user(pamh: *const PamHandle,
49 user: &*mut c_char, 49 user: &*mut c_char,
50 prompt: *const c_char) 50 prompt: *const c_char)
51 -> PamResultCode; 51 -> PamResultCode;
52 }
53
54 #[no_mangle]
55 pub extern "C" fn cleanup<T>(_: *const PamHandle, c_data: Box<PamDataT>, _: PamResultCode) {
56 unsafe {
57 let data: Box<T> = mem::transmute(c_data);
58 mem::drop(data);
59 }
52 } 60 }
53 61
54 pub type PamResult<T> = Result<T, PamResultCode>; 62 pub type PamResult<T> = Result<T, PamResultCode>;
55 63
56 /// Type-level mapping for safely retrieving values with `get_item`. 64 /// Type-level mapping for safely retrieving values with `get_item`.
65 /// called with the constant PAM_CONV, it will return a value of type 73 /// called with the constant PAM_CONV, it will return a value of type
66 /// `PamConv`. 74 /// `PamConv`.
67 fn item_type() -> PamItemType; 75 fn item_type() -> PamItemType;
68 } 76 }
69 77
70 /// Gets some value, identified by `key`, that has been set by the module 78
71 /// previously. 79 impl PamHandle {
72 /// 80 /// Gets some value, identified by `key`, that has been set by the module
73 /// See `pam_get_data` in 81 /// previously.
74 /// http://www.linux-pam.org/Linux-PAM-html/mwg-expected-by-module-item.html 82 ///
75 pub unsafe fn get_data<'a, T>(pamh: &'a PamHandleT, key: &str) -> PamResult<&'a T> { 83 /// See `pam_get_data` in
76 let c_key = CString::new(key).unwrap().as_ptr(); 84 /// http://www.linux-pam.org/Linux-PAM-html/mwg-expected-by-module-item.html
77 let mut ptr: *const PamDataT = ptr::null(); 85 pub unsafe fn get_data<'a, T>(&'a self, key: &str) -> PamResult<&'a T> {
78 let res = pam_get_data(pamh, c_key, &mut ptr); 86 let c_key = CString::new(key).unwrap().as_ptr();
79 if PamResultCode::PAM_SUCCESS == res && !ptr.is_null() { 87 let mut ptr: *const PamDataT = ptr::null();
80 let typed_ptr: *const T = mem::transmute(ptr); 88 let res = pam_get_data(self, c_key, &mut ptr);
81 let data: &T = &*typed_ptr; 89 if PamResultCode::PAM_SUCCESS == res && !ptr.is_null() {
82 Ok(data) 90 let typed_ptr: *const T = mem::transmute(ptr);
83 } else { 91 let data: &T = &*typed_ptr;
84 Err(res) 92 Ok(data)
93 } else {
94 Err(res)
95 }
96 }
97
98 /// Stores a value that can be retrieved later with `get_data`. The value lives
99 /// as long as the current pam cycle.
100 ///
101 /// See `pam_set_data` in
102 /// http://www.linux-pam.org/Linux-PAM-html/mwg-expected-by-module-item.html
103 pub fn set_data<T>(&self, key: &str, data: Box<T>) -> PamResult<()> {
104 let c_key = CString::new(key).unwrap().as_ptr();
105 let res = unsafe {
106 let c_data: Box<PamDataT> = mem::transmute(data);
107 pam_set_data(self, c_key, c_data, cleanup::<T>)
108 };
109 if PamResultCode::PAM_SUCCESS == res {
110 Ok(())
111 } else {
112 Err(res)
113 }
114 }
115
116
117
118 /// Retrieves a value that has been set, possibly by the pam client. This is
119 /// particularly useful for getting a `PamConv` reference.
120 ///
121 /// See `pam_get_item` in
122 /// http://www.linux-pam.org/Linux-PAM-html/mwg-expected-by-module-item.html
123 pub fn get_item<'a, T: PamItem>(&self) -> PamResult<&'a T> {
124 let mut ptr: *const PamItemT = ptr::null();
125 let (res, item) = unsafe {
126 let r = pam_get_item(self, T::item_type(), &mut ptr);
127 let typed_ptr: *const T = mem::transmute(ptr);
128 let t: &T = &*typed_ptr;
129 (r, t)
130 };
131 if PamResultCode::PAM_SUCCESS == res {
132 Ok(item)
133 } else {
134 Err(res)
135 }
136 }
137
138 /// Sets a value in the pam context. The value can be retrieved using
139 /// `get_item`.
140 ///
141 /// Note that all items are strings, except `PAM_CONV` and `PAM_FAIL_DELAY`.
142 ///
143 /// See `pam_set_item` in
144 /// http://www.linux-pam.org/Linux-PAM-html/mwg-expected-by-module-item.html
145 pub fn set_item_str<T: PamItem>(&mut self, item: &str) -> PamResult<()> {
146 let c_item = CString::new(item).unwrap().as_ptr();
147
148 let res = unsafe {
149 pam_set_item(self,
150 T::item_type(),
151
152 // unwrapping is okay here, as c_item will not be a NULL
153 // pointer
154 (c_item as *const PamItemT).as_ref().unwrap())
155 };
156 if PamResultCode::PAM_SUCCESS == res {
157 Ok(())
158 } else {
159 Err(res)
160 }
161 }
162
163 /// Retrieves the name of the user who is authenticating or logging in.
164 ///
165 /// This is really a specialization of `get_item`.
166 ///
167 /// See `pam_get_user` in
168 /// http://www.linux-pam.org/Linux-PAM-html/mwg-expected-by-module-item.html
169 pub fn get_user(&self, prompt: Option<&str>) -> PamResult<String> {
170 let ptr: *mut c_char = ptr::null_mut();
171 let c_prompt = match prompt {
172 Some(p) => CString::new(p).unwrap().as_ptr(),
173 None => ptr::null(),
174 };
175 let res = unsafe { pam_get_user(self, &ptr, c_prompt) };
176 if PamResultCode::PAM_SUCCESS == res && !ptr.is_null() {
177 let const_ptr = ptr as *const c_char;
178 let bytes = unsafe { CStr::from_ptr(const_ptr).to_bytes() };
179 String::from_utf8(bytes.to_vec()).map_err(|_| PamResultCode::PAM_CONV_ERR)
180 } else {
181 Err(res)
182 }
85 } 183 }
86 } 184 }
87
88 /// Stores a value that can be retrieved later with `get_data`. The value lives
89 /// as long as the current pam cycle.
90 ///
91 /// See `pam_set_data` in
92 /// http://www.linux-pam.org/Linux-PAM-html/mwg-expected-by-module-item.html
93 pub fn set_data<T>(pamh: &PamHandleT, key: &str, data: Box<T>) -> PamResult<()> {
94 let c_key = CString::new(key).unwrap().as_ptr();
95 let res = unsafe {
96 let c_data: Box<PamDataT> = mem::transmute(data);
97 pam_set_data(pamh, c_key, c_data, cleanup::<T>)
98 };
99 if PamResultCode::PAM_SUCCESS == res {
100 Ok(())
101 } else {
102 Err(res)
103 }
104 }
105
106 #[no_mangle]
107 pub extern "C" fn cleanup<T>(_: *const PamHandleT, c_data: Box<PamDataT>, _: PamResultCode) {
108 unsafe {
109 let data: Box<T> = mem::transmute(c_data);
110 mem::drop(data);
111 }
112 }
113
114 /// Retrieves a value that has been set, possibly by the pam client. This is
115 /// particularly useful for getting a `PamConv` reference.
116 ///
117 /// See `pam_get_item` in
118 /// http://www.linux-pam.org/Linux-PAM-html/mwg-expected-by-module-item.html
119 pub fn get_item<'a, T: PamItem>(pamh: &'a PamHandleT) -> PamResult<&'a T> {
120 let mut ptr: *const PamItemT = ptr::null();
121 let (res, item) = unsafe {
122 let r = pam_get_item(pamh, T::item_type(), &mut ptr);
123 let typed_ptr: *const T = mem::transmute(ptr);
124 let t: &T = &*typed_ptr;
125 (r, t)
126 };
127 if PamResultCode::PAM_SUCCESS == res {
128 Ok(item)
129 } else {
130 Err(res)
131 }
132 }
133
134 /// Sets a value in the pam context. The value can be retrieved using
135 /// `get_item`.
136 ///
137 /// Note that all items are strings, except `PAM_CONV` and `PAM_FAIL_DELAY`.
138 ///
139 /// See `pam_set_item` in
140 /// http://www.linux-pam.org/Linux-PAM-html/mwg-expected-by-module-item.html
141 pub fn set_item_str<'a, T: PamItem>(pamh: &'a mut PamHandleT, item: &str) -> PamResult<()> {
142 let c_item = CString::new(item).unwrap().as_ptr();
143
144 let res = unsafe {
145 pam_set_item(pamh,
146 T::item_type(),
147
148 // unwrapping is okay here, as c_item will not be a NULL
149 // pointer
150 (c_item as *const PamItemT).as_ref().unwrap())
151 };
152 if PamResultCode::PAM_SUCCESS == res {
153 Ok(())
154 } else {
155 Err(res)
156 }
157 }
158
159 /// Retrieves the name of the user who is authenticating or logging in.
160 ///
161 /// This is really a specialization of `get_item`.
162 ///
163 /// See `pam_get_user` in
164 /// http://www.linux-pam.org/Linux-PAM-html/mwg-expected-by-module-item.html
165 pub fn get_user<'a>(pamh: &'a PamHandleT, prompt: Option<&str>) -> PamResult<String> {
166 let ptr: *mut c_char = ptr::null_mut();
167 let c_prompt = match prompt {
168 Some(p) => CString::new(p).unwrap().as_ptr(),
169 None => ptr::null(),
170 };
171 let res = unsafe { pam_get_user(pamh, &ptr, c_prompt) };
172 if PamResultCode::PAM_SUCCESS == res && !ptr.is_null() {
173 let const_ptr = ptr as *const c_char;
174 let bytes = unsafe { CStr::from_ptr(const_ptr).to_bytes() };
175 String::from_utf8(bytes.to_vec()).map_err(|_| PamResultCode::PAM_CONV_ERR)
176 } else {
177 Err(res)
178 }
179 }