1 | //! Safe wrappers around functions found in libc "unistd.h" header |
2 | |
3 | use crate::errno::{self, Errno}; |
4 | #[cfg (not(target_os = "redox" ))] |
5 | #[cfg (feature = "fs" )] |
6 | use crate::fcntl::{at_rawfd, AtFlags}; |
7 | #[cfg (feature = "fs" )] |
8 | use crate::fcntl::{fcntl, FcntlArg::F_SETFD, FdFlag, OFlag}; |
9 | #[cfg (all( |
10 | feature = "fs" , |
11 | any( |
12 | target_os = "openbsd" , |
13 | target_os = "netbsd" , |
14 | target_os = "freebsd" , |
15 | target_os = "dragonfly" , |
16 | target_os = "macos" , |
17 | target_os = "ios" |
18 | ) |
19 | ))] |
20 | use crate::sys::stat::FileFlag; |
21 | #[cfg (feature = "fs" )] |
22 | use crate::sys::stat::Mode; |
23 | use crate::{Error, NixPath, Result}; |
24 | #[cfg (not(target_os = "redox" ))] |
25 | use cfg_if::cfg_if; |
26 | use libc::{ |
27 | self, c_char, c_int, c_long, c_uint, c_void, gid_t, mode_t, off_t, pid_t, |
28 | size_t, uid_t, PATH_MAX, |
29 | }; |
30 | use std::convert::Infallible; |
31 | use std::ffi::{CStr, OsString}; |
32 | #[cfg (not(target_os = "redox" ))] |
33 | use std::ffi::{CString, OsStr}; |
34 | #[cfg (not(target_os = "redox" ))] |
35 | use std::os::unix::ffi::OsStrExt; |
36 | use std::os::unix::ffi::OsStringExt; |
37 | use std::os::unix::io::RawFd; |
38 | use std::os::unix::io::{AsFd, AsRawFd}; |
39 | use std::path::PathBuf; |
40 | use std::{fmt, mem, ptr}; |
41 | |
42 | feature! { |
43 | #![feature = "fs" ] |
44 | #[cfg (any(target_os = "android" , target_os = "linux" ))] |
45 | pub use self::pivot_root::*; |
46 | } |
47 | |
48 | #[cfg (any( |
49 | target_os = "android" , |
50 | target_os = "dragonfly" , |
51 | target_os = "freebsd" , |
52 | target_os = "linux" , |
53 | target_os = "openbsd" |
54 | ))] |
55 | pub use self::setres::*; |
56 | |
57 | #[cfg (any( |
58 | target_os = "android" , |
59 | target_os = "dragonfly" , |
60 | target_os = "freebsd" , |
61 | target_os = "linux" , |
62 | target_os = "openbsd" |
63 | ))] |
64 | pub use self::getres::*; |
65 | |
66 | feature! { |
67 | #![feature = "user" ] |
68 | |
69 | /// User identifier |
70 | /// |
71 | /// Newtype pattern around `uid_t` (which is just alias). It prevents bugs caused by accidentally |
72 | /// passing wrong value. |
73 | #[derive (Debug, Copy, Clone, Eq, PartialEq, Hash)] |
74 | pub struct Uid(uid_t); |
75 | |
76 | impl Uid { |
77 | /// Creates `Uid` from raw `uid_t`. |
78 | pub const fn from_raw(uid: uid_t) -> Self { |
79 | Uid(uid) |
80 | } |
81 | |
82 | /// Returns Uid of calling process. This is practically a more Rusty alias for `getuid`. |
83 | #[doc (alias("getuid" ))] |
84 | pub fn current() -> Self { |
85 | getuid() |
86 | } |
87 | |
88 | /// Returns effective Uid of calling process. This is practically a more Rusty alias for `geteuid`. |
89 | #[doc (alias("geteuid" ))] |
90 | pub fn effective() -> Self { |
91 | geteuid() |
92 | } |
93 | |
94 | /// Returns true if the `Uid` represents privileged user - root. (If it equals zero.) |
95 | pub const fn is_root(self) -> bool { |
96 | self.0 == ROOT.0 |
97 | } |
98 | |
99 | /// Get the raw `uid_t` wrapped by `self`. |
100 | pub const fn as_raw(self) -> uid_t { |
101 | self.0 |
102 | } |
103 | } |
104 | |
105 | impl From<Uid> for uid_t { |
106 | fn from(uid: Uid) -> Self { |
107 | uid.0 |
108 | } |
109 | } |
110 | |
111 | impl From<uid_t> for Uid { |
112 | fn from(uid: uid_t) -> Self { |
113 | Uid(uid) |
114 | } |
115 | } |
116 | |
117 | impl fmt::Display for Uid { |
118 | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { |
119 | fmt::Display::fmt(&self.0, f) |
120 | } |
121 | } |
122 | |
123 | /// Constant for UID = 0 |
124 | pub const ROOT: Uid = Uid(0); |
125 | |
126 | /// Group identifier |
127 | /// |
128 | /// Newtype pattern around `gid_t` (which is just alias). It prevents bugs caused by accidentally |
129 | /// passing wrong value. |
130 | #[derive (Debug, Copy, Clone, Eq, PartialEq, Hash)] |
131 | pub struct Gid(gid_t); |
132 | |
133 | impl Gid { |
134 | /// Creates `Gid` from raw `gid_t`. |
135 | pub const fn from_raw(gid: gid_t) -> Self { |
136 | Gid(gid) |
137 | } |
138 | |
139 | /// Returns Gid of calling process. This is practically a more Rusty alias for `getgid`. |
140 | #[doc (alias("getgid" ))] |
141 | pub fn current() -> Self { |
142 | getgid() |
143 | } |
144 | |
145 | /// Returns effective Gid of calling process. This is practically a more Rusty alias for `getegid`. |
146 | #[doc (alias("getegid" ))] |
147 | pub fn effective() -> Self { |
148 | getegid() |
149 | } |
150 | |
151 | /// Get the raw `gid_t` wrapped by `self`. |
152 | pub const fn as_raw(self) -> gid_t { |
153 | self.0 |
154 | } |
155 | } |
156 | |
157 | impl From<Gid> for gid_t { |
158 | fn from(gid: Gid) -> Self { |
159 | gid.0 |
160 | } |
161 | } |
162 | |
163 | impl From<gid_t> for Gid { |
164 | fn from(gid: gid_t) -> Self { |
165 | Gid(gid) |
166 | } |
167 | } |
168 | |
169 | impl fmt::Display for Gid { |
170 | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { |
171 | fmt::Display::fmt(&self.0, f) |
172 | } |
173 | } |
174 | } |
175 | |
176 | feature! { |
177 | #![feature = "process" ] |
178 | /// Process identifier |
179 | /// |
180 | /// Newtype pattern around `pid_t` (which is just alias). It prevents bugs caused by accidentally |
181 | /// passing wrong value. |
182 | #[derive (Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)] |
183 | pub struct Pid(pid_t); |
184 | |
185 | impl Pid { |
186 | /// Creates `Pid` from raw `pid_t`. |
187 | pub const fn from_raw(pid: pid_t) -> Self { |
188 | Pid(pid) |
189 | } |
190 | |
191 | /// Returns PID of calling process |
192 | #[doc (alias("getpid" ))] |
193 | pub fn this() -> Self { |
194 | getpid() |
195 | } |
196 | |
197 | /// Returns PID of parent of calling process |
198 | #[doc (alias("getppid" ))] |
199 | pub fn parent() -> Self { |
200 | getppid() |
201 | } |
202 | |
203 | /// Get the raw `pid_t` wrapped by `self`. |
204 | pub const fn as_raw(self) -> pid_t { |
205 | self.0 |
206 | } |
207 | } |
208 | |
209 | impl From<Pid> for pid_t { |
210 | fn from(pid: Pid) -> Self { |
211 | pid.0 |
212 | } |
213 | } |
214 | |
215 | impl fmt::Display for Pid { |
216 | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { |
217 | fmt::Display::fmt(&self.0, f) |
218 | } |
219 | } |
220 | |
221 | /// Represents the successful result of calling `fork` |
222 | /// |
223 | /// When `fork` is called, the process continues execution in the parent process |
224 | /// and in the new child. This return type can be examined to determine whether |
225 | /// you are now executing in the parent process or in the child. |
226 | #[derive (Clone, Copy, Debug)] |
227 | pub enum ForkResult { |
228 | Parent { child: Pid }, |
229 | Child, |
230 | } |
231 | |
232 | impl ForkResult { |
233 | /// Return `true` if this is the child process of the `fork()` |
234 | #[inline ] |
235 | pub fn is_child(self) -> bool { |
236 | matches!(self, ForkResult::Child) |
237 | } |
238 | |
239 | /// Returns `true` if this is the parent process of the `fork()` |
240 | #[inline ] |
241 | pub fn is_parent(self) -> bool { |
242 | !self.is_child() |
243 | } |
244 | } |
245 | |
246 | /// Create a new child process duplicating the parent process ([see |
247 | /// fork(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/fork.html)). |
248 | /// |
249 | /// After successfully calling the fork system call, a second process will |
250 | /// be created which is identical to the original except for the pid and the |
251 | /// return value of this function. As an example: |
252 | /// |
253 | /// ``` |
254 | /// use nix::{sys::wait::waitpid,unistd::{fork, ForkResult, write}}; |
255 | /// |
256 | /// match unsafe{fork()} { |
257 | /// Ok(ForkResult::Parent { child, .. }) => { |
258 | /// println!("Continuing execution in parent process, new child has pid: {}", child); |
259 | /// waitpid(child, None).unwrap(); |
260 | /// } |
261 | /// Ok(ForkResult::Child) => { |
262 | /// // Unsafe to use `println!` (or `unwrap`) here. See Safety. |
263 | /// write(libc::STDOUT_FILENO, "I'm a new child process\n".as_bytes()).ok(); |
264 | /// unsafe { libc::_exit(0) }; |
265 | /// } |
266 | /// Err(_) => println!("Fork failed"), |
267 | /// } |
268 | /// ``` |
269 | /// |
270 | /// This will print something like the following (order nondeterministic). The |
271 | /// thing to note is that you end up with two processes continuing execution |
272 | /// immediately after the fork call but with different match arms. |
273 | /// |
274 | /// ```text |
275 | /// Continuing execution in parent process, new child has pid: 1234 |
276 | /// I'm a new child process |
277 | /// ``` |
278 | /// |
279 | /// # Safety |
280 | /// |
281 | /// In a multithreaded program, only [async-signal-safe] functions like `pause` |
282 | /// and `_exit` may be called by the child (the parent isn't restricted). Note |
283 | /// that memory allocation may **not** be async-signal-safe and thus must be |
284 | /// prevented. |
285 | /// |
286 | /// Those functions are only a small subset of your operating system's API, so |
287 | /// special care must be taken to only invoke code you can control and audit. |
288 | /// |
289 | /// [async-signal-safe]: https://man7.org/linux/man-pages/man7/signal-safety.7.html |
290 | #[inline ] |
291 | pub unsafe fn fork() -> Result<ForkResult> { |
292 | use self::ForkResult::*; |
293 | let res = libc::fork(); |
294 | |
295 | Errno::result(res).map(|res| match res { |
296 | 0 => Child, |
297 | res => Parent { child: Pid(res) }, |
298 | }) |
299 | } |
300 | |
301 | /// Get the pid of this process (see |
302 | /// [getpid(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/getpid.html)). |
303 | /// |
304 | /// Since you are running code, there is always a pid to return, so there |
305 | /// is no error case that needs to be handled. |
306 | #[inline ] |
307 | pub fn getpid() -> Pid { |
308 | Pid(unsafe { libc::getpid() }) |
309 | } |
310 | |
311 | /// Get the pid of this processes' parent (see |
312 | /// [getpid(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/getppid.html)). |
313 | /// |
314 | /// There is always a parent pid to return, so there is no error case that needs |
315 | /// to be handled. |
316 | #[inline ] |
317 | pub fn getppid() -> Pid { |
318 | Pid(unsafe { libc::getppid() }) // no error handling, according to man page: "These functions are always successful." |
319 | } |
320 | |
321 | /// Set a process group ID (see |
322 | /// [setpgid(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/setpgid.html)). |
323 | /// |
324 | /// Set the process group id (PGID) of a particular process. If a pid of zero |
325 | /// is specified, then the pid of the calling process is used. Process groups |
326 | /// may be used to group together a set of processes in order for the OS to |
327 | /// apply some operations across the group. |
328 | /// |
329 | /// `setsid()` may be used to create a new process group. |
330 | #[inline ] |
331 | pub fn setpgid(pid: Pid, pgid: Pid) -> Result<()> { |
332 | let res = unsafe { libc::setpgid(pid.into(), pgid.into()) }; |
333 | Errno::result(res).map(drop) |
334 | } |
335 | #[inline ] |
336 | pub fn getpgid(pid: Option<Pid>) -> Result<Pid> { |
337 | let res = unsafe { libc::getpgid(pid.unwrap_or(Pid(0)).into()) }; |
338 | Errno::result(res).map(Pid) |
339 | } |
340 | |
341 | /// Create new session and set process group id (see |
342 | /// [setsid(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/setsid.html)). |
343 | #[inline ] |
344 | pub fn setsid() -> Result<Pid> { |
345 | Errno::result(unsafe { libc::setsid() }).map(Pid) |
346 | } |
347 | |
348 | /// Get the process group ID of a session leader |
349 | /// [getsid(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/getsid.html). |
350 | /// |
351 | /// Obtain the process group ID of the process that is the session leader of the process specified |
352 | /// by pid. If pid is zero, it specifies the calling process. |
353 | #[inline ] |
354 | #[cfg (not(target_os = "redox" ))] |
355 | pub fn getsid(pid: Option<Pid>) -> Result<Pid> { |
356 | let res = unsafe { libc::getsid(pid.unwrap_or(Pid(0)).into()) }; |
357 | Errno::result(res).map(Pid) |
358 | } |
359 | } |
360 | |
361 | feature! { |
362 | #![all(feature = "process" , feature = "term" )] |
363 | /// Get the terminal foreground process group (see |
364 | /// [tcgetpgrp(3)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/tcgetpgrp.html)). |
365 | /// |
366 | /// Get the group process id (GPID) of the foreground process group on the |
367 | /// terminal associated to file descriptor (FD). |
368 | #[inline ] |
369 | pub fn tcgetpgrp(fd: c_int) -> Result<Pid> { |
370 | let res = unsafe { libc::tcgetpgrp(fd) }; |
371 | Errno::result(res).map(Pid) |
372 | } |
373 | /// Set the terminal foreground process group (see |
374 | /// [tcgetpgrp(3)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/tcsetpgrp.html)). |
375 | /// |
376 | /// Get the group process id (PGID) to the foreground process group on the |
377 | /// terminal associated to file descriptor (FD). |
378 | #[inline ] |
379 | pub fn tcsetpgrp(fd: c_int, pgrp: Pid) -> Result<()> { |
380 | let res = unsafe { libc::tcsetpgrp(fd, pgrp.into()) }; |
381 | Errno::result(res).map(drop) |
382 | } |
383 | } |
384 | |
385 | feature! { |
386 | #![feature = "process" ] |
387 | /// Get the group id of the calling process (see |
388 | ///[getpgrp(3)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/getpgrp.html)). |
389 | /// |
390 | /// Get the process group id (PGID) of the calling process. |
391 | /// According to the man page it is always successful. |
392 | #[inline ] |
393 | pub fn getpgrp() -> Pid { |
394 | Pid(unsafe { libc::getpgrp() }) |
395 | } |
396 | |
397 | /// Get the caller's thread ID (see |
398 | /// [gettid(2)](https://man7.org/linux/man-pages/man2/gettid.2.html). |
399 | /// |
400 | /// This function is only available on Linux based systems. In a single |
401 | /// threaded process, the main thread will have the same ID as the process. In |
402 | /// a multithreaded process, each thread will have a unique thread id but the |
403 | /// same process ID. |
404 | /// |
405 | /// No error handling is required as a thread id should always exist for any |
406 | /// process, even if threads are not being used. |
407 | #[cfg (any(target_os = "linux" , target_os = "android" ))] |
408 | #[inline ] |
409 | pub fn gettid() -> Pid { |
410 | Pid(unsafe { libc::syscall(libc::SYS_gettid) as pid_t }) |
411 | } |
412 | } |
413 | |
414 | feature! { |
415 | #![feature = "fs" ] |
416 | /// Create a copy of the specified file descriptor (see |
417 | /// [dup(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/dup.html)). |
418 | /// |
419 | /// The new file descriptor will have a new index but refer to the same |
420 | /// resource as the old file descriptor and the old and new file descriptors may |
421 | /// be used interchangeably. The new and old file descriptor share the same |
422 | /// underlying resource, offset, and file status flags. The actual index used |
423 | /// for the file descriptor will be the lowest fd index that is available. |
424 | /// |
425 | /// The two file descriptors do not share file descriptor flags (e.g. `OFlag::FD_CLOEXEC`). |
426 | #[inline ] |
427 | pub fn dup(oldfd: RawFd) -> Result<RawFd> { |
428 | let res = unsafe { libc::dup(oldfd) }; |
429 | |
430 | Errno::result(res) |
431 | } |
432 | |
433 | /// Create a copy of the specified file descriptor using the specified fd (see |
434 | /// [dup(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/dup.html)). |
435 | /// |
436 | /// This function behaves similar to `dup()` except that it will try to use the |
437 | /// specified fd instead of allocating a new one. See the man pages for more |
438 | /// detail on the exact behavior of this function. |
439 | #[inline ] |
440 | pub fn dup2(oldfd: RawFd, newfd: RawFd) -> Result<RawFd> { |
441 | let res = unsafe { libc::dup2(oldfd, newfd) }; |
442 | |
443 | Errno::result(res) |
444 | } |
445 | |
446 | /// Create a new copy of the specified file descriptor using the specified fd |
447 | /// and flags (see [dup(2)](https://man7.org/linux/man-pages/man2/dup.2.html)). |
448 | /// |
449 | /// This function behaves similar to `dup2()` but allows for flags to be |
450 | /// specified. |
451 | pub fn dup3(oldfd: RawFd, newfd: RawFd, flags: OFlag) -> Result<RawFd> { |
452 | dup3_polyfill(oldfd, newfd, flags) |
453 | } |
454 | |
455 | #[inline ] |
456 | fn dup3_polyfill(oldfd: RawFd, newfd: RawFd, flags: OFlag) -> Result<RawFd> { |
457 | if oldfd == newfd { |
458 | return Err(Errno::EINVAL); |
459 | } |
460 | |
461 | let fd = dup2(oldfd, newfd)?; |
462 | |
463 | if flags.contains(OFlag::O_CLOEXEC) { |
464 | if let Err(e) = fcntl(fd, F_SETFD(FdFlag::FD_CLOEXEC)) { |
465 | let _ = close(fd); |
466 | return Err(e); |
467 | } |
468 | } |
469 | |
470 | Ok(fd) |
471 | } |
472 | |
473 | /// Change the current working directory of the calling process (see |
474 | /// [chdir(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/chdir.html)). |
475 | /// |
476 | /// This function may fail in a number of different scenarios. See the man |
477 | /// pages for additional details on possible failure cases. |
478 | #[inline ] |
479 | pub fn chdir<P: ?Sized + NixPath>(path: &P) -> Result<()> { |
480 | let res = |
481 | path.with_nix_path(|cstr| unsafe { libc::chdir(cstr.as_ptr()) })?; |
482 | |
483 | Errno::result(res).map(drop) |
484 | } |
485 | |
486 | /// Change the current working directory of the process to the one |
487 | /// given as an open file descriptor (see |
488 | /// [fchdir(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/fchdir.html)). |
489 | /// |
490 | /// This function may fail in a number of different scenarios. See the man |
491 | /// pages for additional details on possible failure cases. |
492 | #[inline ] |
493 | #[cfg (not(target_os = "fuchsia" ))] |
494 | pub fn fchdir(dirfd: RawFd) -> Result<()> { |
495 | let res = unsafe { libc::fchdir(dirfd) }; |
496 | |
497 | Errno::result(res).map(drop) |
498 | } |
499 | |
500 | /// Creates new directory `path` with access rights `mode`. (see [mkdir(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/mkdir.html)) |
501 | /// |
502 | /// # Errors |
503 | /// |
504 | /// There are several situations where mkdir might fail: |
505 | /// |
506 | /// - current user has insufficient rights in the parent directory |
507 | /// - the path already exists |
508 | /// - the path name is too long (longer than `PATH_MAX`, usually 4096 on linux, 1024 on OS X) |
509 | /// |
510 | /// # Example |
511 | /// |
512 | /// ```rust |
513 | /// use nix::unistd; |
514 | /// use nix::sys::stat; |
515 | /// use tempfile::tempdir; |
516 | /// |
517 | /// let tmp_dir1 = tempdir().unwrap(); |
518 | /// let tmp_dir2 = tmp_dir1.path().join("new_dir"); |
519 | /// |
520 | /// // create new directory and give read, write and execute rights to the owner |
521 | /// match unistd::mkdir(&tmp_dir2, stat::Mode::S_IRWXU) { |
522 | /// Ok(_) => println!("created {:?}", tmp_dir2), |
523 | /// Err(err) => println!("Error creating directory: {}", err), |
524 | /// } |
525 | /// ``` |
526 | #[inline ] |
527 | pub fn mkdir<P: ?Sized + NixPath>(path: &P, mode: Mode) -> Result<()> { |
528 | let res = path.with_nix_path(|cstr| unsafe { |
529 | libc::mkdir(cstr.as_ptr(), mode.bits() as mode_t) |
530 | })?; |
531 | |
532 | Errno::result(res).map(drop) |
533 | } |
534 | |
535 | /// Creates new fifo special file (named pipe) with path `path` and access rights `mode`. |
536 | /// |
537 | /// # Errors |
538 | /// |
539 | /// There are several situations where mkfifo might fail: |
540 | /// |
541 | /// - current user has insufficient rights in the parent directory |
542 | /// - the path already exists |
543 | /// - the path name is too long (longer than `PATH_MAX`, usually 4096 on linux, 1024 on OS X) |
544 | /// |
545 | /// For a full list consult |
546 | /// [posix specification](https://pubs.opengroup.org/onlinepubs/9699919799/functions/mkfifo.html) |
547 | /// |
548 | /// # Example |
549 | /// |
550 | /// ```rust |
551 | /// use nix::unistd; |
552 | /// use nix::sys::stat; |
553 | /// use tempfile::tempdir; |
554 | /// |
555 | /// let tmp_dir = tempdir().unwrap(); |
556 | /// let fifo_path = tmp_dir.path().join("foo.pipe"); |
557 | /// |
558 | /// // create new fifo and give read, write and execute rights to the owner |
559 | /// match unistd::mkfifo(&fifo_path, stat::Mode::S_IRWXU) { |
560 | /// Ok(_) => println!("created {:?}", fifo_path), |
561 | /// Err(err) => println!("Error creating fifo: {}", err), |
562 | /// } |
563 | /// ``` |
564 | #[inline ] |
565 | #[cfg (not(target_os = "redox" ))] // RedoxFS does not support fifo yet |
566 | pub fn mkfifo<P: ?Sized + NixPath>(path: &P, mode: Mode) -> Result<()> { |
567 | let res = path.with_nix_path(|cstr| unsafe { |
568 | libc::mkfifo(cstr.as_ptr(), mode.bits() as mode_t) |
569 | })?; |
570 | |
571 | Errno::result(res).map(drop) |
572 | } |
573 | |
574 | /// Creates new fifo special file (named pipe) with path `path` and access rights `mode`. |
575 | /// |
576 | /// If `dirfd` has a value, then `path` is relative to directory associated with the file descriptor. |
577 | /// |
578 | /// If `dirfd` is `None`, then `path` is relative to the current working directory. |
579 | /// |
580 | /// # References |
581 | /// |
582 | /// [mkfifoat(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/mkfifoat.html). |
583 | // mkfifoat is not implemented in OSX or android |
584 | #[inline ] |
585 | #[cfg (not(any( |
586 | target_os = "macos" , |
587 | target_os = "ios" , |
588 | target_os = "haiku" , |
589 | target_os = "android" , |
590 | target_os = "redox" |
591 | )))] |
592 | pub fn mkfifoat<P: ?Sized + NixPath>( |
593 | dirfd: Option<RawFd>, |
594 | path: &P, |
595 | mode: Mode, |
596 | ) -> Result<()> { |
597 | let res = path.with_nix_path(|cstr| unsafe { |
598 | libc::mkfifoat(at_rawfd(dirfd), cstr.as_ptr(), mode.bits() as mode_t) |
599 | })?; |
600 | |
601 | Errno::result(res).map(drop) |
602 | } |
603 | |
604 | /// Creates a symbolic link at `path2` which points to `path1`. |
605 | /// |
606 | /// If `dirfd` has a value, then `path2` is relative to directory associated |
607 | /// with the file descriptor. |
608 | /// |
609 | /// If `dirfd` is `None`, then `path2` is relative to the current working |
610 | /// directory. This is identical to `libc::symlink(path1, path2)`. |
611 | /// |
612 | /// See also [symlinkat(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/symlinkat.html). |
613 | #[cfg (not(target_os = "redox" ))] |
614 | pub fn symlinkat<P1: ?Sized + NixPath, P2: ?Sized + NixPath>( |
615 | path1: &P1, |
616 | dirfd: Option<RawFd>, |
617 | path2: &P2, |
618 | ) -> Result<()> { |
619 | let res = path1.with_nix_path(|path1| { |
620 | path2.with_nix_path(|path2| unsafe { |
621 | libc::symlinkat( |
622 | path1.as_ptr(), |
623 | dirfd.unwrap_or(libc::AT_FDCWD), |
624 | path2.as_ptr(), |
625 | ) |
626 | }) |
627 | })??; |
628 | Errno::result(res).map(drop) |
629 | } |
630 | } |
631 | |
632 | // Double the buffer capacity up to limit. In case it already has |
633 | // reached the limit, return Errno::ERANGE. |
634 | #[cfg (any(feature = "fs" , feature = "user" ))] |
635 | fn reserve_double_buffer_size<T>(buf: &mut Vec<T>, limit: usize) -> Result<()> { |
636 | use std::cmp::min; |
637 | |
638 | if buf.capacity() >= limit { |
639 | return Err(Errno::ERANGE); |
640 | } |
641 | |
642 | let capacity: usize = min(v1:buf.capacity() * 2, v2:limit); |
643 | buf.reserve(additional:capacity); |
644 | |
645 | Ok(()) |
646 | } |
647 | |
648 | feature! { |
649 | #![feature = "fs" ] |
650 | |
651 | /// Returns the current directory as a `PathBuf` |
652 | /// |
653 | /// Err is returned if the current user doesn't have the permission to read or search a component |
654 | /// of the current path. |
655 | /// |
656 | /// # Example |
657 | /// |
658 | /// ```rust |
659 | /// use nix::unistd; |
660 | /// |
661 | /// // assume that we are allowed to get current directory |
662 | /// let dir = unistd::getcwd().unwrap(); |
663 | /// println!("The current directory is {:?}", dir); |
664 | /// ``` |
665 | #[inline ] |
666 | pub fn getcwd() -> Result<PathBuf> { |
667 | let mut buf = Vec::with_capacity(512); |
668 | loop { |
669 | unsafe { |
670 | let ptr = buf.as_mut_ptr() as *mut c_char; |
671 | |
672 | // The buffer must be large enough to store the absolute pathname plus |
673 | // a terminating null byte, or else null is returned. |
674 | // To safely handle this we start with a reasonable size (512 bytes) |
675 | // and double the buffer size upon every error |
676 | if !libc::getcwd(ptr, buf.capacity()).is_null() { |
677 | let len = CStr::from_ptr(buf.as_ptr() as *const c_char) |
678 | .to_bytes() |
679 | .len(); |
680 | buf.set_len(len); |
681 | buf.shrink_to_fit(); |
682 | return Ok(PathBuf::from(OsString::from_vec(buf))); |
683 | } else { |
684 | let error = Errno::last(); |
685 | // ERANGE means buffer was too small to store directory name |
686 | if error != Errno::ERANGE { |
687 | return Err(error); |
688 | } |
689 | } |
690 | |
691 | // Trigger the internal buffer resizing logic. |
692 | reserve_double_buffer_size(&mut buf, PATH_MAX as usize)?; |
693 | } |
694 | } |
695 | } |
696 | } |
697 | |
698 | feature! { |
699 | #![all(feature = "user" , feature = "fs" )] |
700 | |
701 | /// Computes the raw UID and GID values to pass to a `*chown` call. |
702 | // The cast is not unnecessary on all platforms. |
703 | #[allow (clippy::unnecessary_cast)] |
704 | fn chown_raw_ids(owner: Option<Uid>, group: Option<Gid>) -> (uid_t, gid_t) { |
705 | // According to the POSIX specification, -1 is used to indicate that owner and group |
706 | // are not to be changed. Since uid_t and gid_t are unsigned types, we have to wrap |
707 | // around to get -1. |
708 | let uid = owner |
709 | .map(Into::into) |
710 | .unwrap_or_else(|| (0 as uid_t).wrapping_sub(1)); |
711 | let gid = group |
712 | .map(Into::into) |
713 | .unwrap_or_else(|| (0 as gid_t).wrapping_sub(1)); |
714 | (uid, gid) |
715 | } |
716 | |
717 | /// Change the ownership of the file at `path` to be owned by the specified |
718 | /// `owner` (user) and `group` (see |
719 | /// [chown(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/chown.html)). |
720 | /// |
721 | /// The owner/group for the provided path name will not be modified if `None` is |
722 | /// provided for that argument. Ownership change will be attempted for the path |
723 | /// only if `Some` owner/group is provided. |
724 | #[inline ] |
725 | pub fn chown<P: ?Sized + NixPath>( |
726 | path: &P, |
727 | owner: Option<Uid>, |
728 | group: Option<Gid>, |
729 | ) -> Result<()> { |
730 | let res = path.with_nix_path(|cstr| { |
731 | let (uid, gid) = chown_raw_ids(owner, group); |
732 | unsafe { libc::chown(cstr.as_ptr(), uid, gid) } |
733 | })?; |
734 | |
735 | Errno::result(res).map(drop) |
736 | } |
737 | |
738 | /// Change the ownership of the file referred to by the open file descriptor `fd` to be owned by |
739 | /// the specified `owner` (user) and `group` (see |
740 | /// [fchown(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/fchown.html)). |
741 | /// |
742 | /// The owner/group for the provided file will not be modified if `None` is |
743 | /// provided for that argument. Ownership change will be attempted for the path |
744 | /// only if `Some` owner/group is provided. |
745 | #[inline ] |
746 | pub fn fchown(fd: RawFd, owner: Option<Uid>, group: Option<Gid>) -> Result<()> { |
747 | let (uid, gid) = chown_raw_ids(owner, group); |
748 | let res = unsafe { libc::fchown(fd, uid, gid) }; |
749 | Errno::result(res).map(drop) |
750 | } |
751 | |
752 | /// Flags for `fchownat` function. |
753 | #[derive (Clone, Copy, Debug)] |
754 | pub enum FchownatFlags { |
755 | FollowSymlink, |
756 | NoFollowSymlink, |
757 | } |
758 | |
759 | /// Change the ownership of the file at `path` to be owned by the specified |
760 | /// `owner` (user) and `group`. |
761 | /// |
762 | /// The owner/group for the provided path name will not be modified if `None` is |
763 | /// provided for that argument. Ownership change will be attempted for the path |
764 | /// only if `Some` owner/group is provided. |
765 | /// |
766 | /// The file to be changed is determined relative to the directory associated |
767 | /// with the file descriptor `dirfd` or the current working directory |
768 | /// if `dirfd` is `None`. |
769 | /// |
770 | /// If `flag` is `FchownatFlags::NoFollowSymlink` and `path` names a symbolic link, |
771 | /// then the mode of the symbolic link is changed. |
772 | /// |
773 | /// `fchownat(None, path, owner, group, FchownatFlags::NoFollowSymlink)` is identical to |
774 | /// a call `libc::lchown(path, owner, group)`. That's why `lchown` is unimplemented in |
775 | /// the `nix` crate. |
776 | /// |
777 | /// # References |
778 | /// |
779 | /// [fchownat(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/fchownat.html). |
780 | #[cfg (not(target_os = "redox" ))] |
781 | pub fn fchownat<P: ?Sized + NixPath>( |
782 | dirfd: Option<RawFd>, |
783 | path: &P, |
784 | owner: Option<Uid>, |
785 | group: Option<Gid>, |
786 | flag: FchownatFlags, |
787 | ) -> Result<()> { |
788 | let atflag = match flag { |
789 | FchownatFlags::FollowSymlink => AtFlags::empty(), |
790 | FchownatFlags::NoFollowSymlink => AtFlags::AT_SYMLINK_NOFOLLOW, |
791 | }; |
792 | let res = path.with_nix_path(|cstr| unsafe { |
793 | let (uid, gid) = chown_raw_ids(owner, group); |
794 | libc::fchownat( |
795 | at_rawfd(dirfd), |
796 | cstr.as_ptr(), |
797 | uid, |
798 | gid, |
799 | atflag.bits() as libc::c_int, |
800 | ) |
801 | })?; |
802 | |
803 | Errno::result(res).map(drop) |
804 | } |
805 | } |
806 | |
807 | feature! { |
808 | #![feature = "process" ] |
809 | fn to_exec_array<S: AsRef<CStr>>(args: &[S]) -> Vec<*const c_char> { |
810 | use std::iter::once; |
811 | args.iter() |
812 | .map(|s| s.as_ref().as_ptr()) |
813 | .chain(once(ptr::null())) |
814 | .collect() |
815 | } |
816 | |
817 | /// Replace the current process image with a new one (see |
818 | /// [exec(3)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/exec.html)). |
819 | /// |
820 | /// See the `::nix::unistd::execve` system call for additional details. `execv` |
821 | /// performs the same action but does not allow for customization of the |
822 | /// environment for the new process. |
823 | #[inline ] |
824 | pub fn execv<S: AsRef<CStr>>(path: &CStr, argv: &[S]) -> Result<Infallible> { |
825 | let args_p = to_exec_array(argv); |
826 | |
827 | unsafe { libc::execv(path.as_ptr(), args_p.as_ptr()) }; |
828 | |
829 | Err(Errno::last()) |
830 | } |
831 | |
832 | /// Replace the current process image with a new one (see |
833 | /// [execve(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/exec.html)). |
834 | /// |
835 | /// The execve system call allows for another process to be "called" which will |
836 | /// replace the current process image. That is, this process becomes the new |
837 | /// command that is run. On success, this function will not return. Instead, |
838 | /// the new program will run until it exits. |
839 | /// |
840 | /// `::nix::unistd::execv` and `::nix::unistd::execve` take as arguments a slice |
841 | /// of `::std::ffi::CString`s for `args` and `env` (for `execve`). Each element |
842 | /// in the `args` list is an argument to the new process. Each element in the |
843 | /// `env` list should be a string in the form "key=value". |
844 | #[inline ] |
845 | pub fn execve<SA: AsRef<CStr>, SE: AsRef<CStr>>( |
846 | path: &CStr, |
847 | args: &[SA], |
848 | env: &[SE], |
849 | ) -> Result<Infallible> { |
850 | let args_p = to_exec_array(args); |
851 | let env_p = to_exec_array(env); |
852 | |
853 | unsafe { libc::execve(path.as_ptr(), args_p.as_ptr(), env_p.as_ptr()) }; |
854 | |
855 | Err(Errno::last()) |
856 | } |
857 | |
858 | /// Replace the current process image with a new one and replicate shell `PATH` |
859 | /// searching behavior (see |
860 | /// [exec(3)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/exec.html)). |
861 | /// |
862 | /// See `::nix::unistd::execve` for additional details. `execvp` behaves the |
863 | /// same as execv except that it will examine the `PATH` environment variables |
864 | /// for file names not specified with a leading slash. For example, `execv` |
865 | /// would not work if "bash" was specified for the path argument, but `execvp` |
866 | /// would assuming that a bash executable was on the system `PATH`. |
867 | #[inline ] |
868 | pub fn execvp<S: AsRef<CStr>>( |
869 | filename: &CStr, |
870 | args: &[S], |
871 | ) -> Result<Infallible> { |
872 | let args_p = to_exec_array(args); |
873 | |
874 | unsafe { libc::execvp(filename.as_ptr(), args_p.as_ptr()) }; |
875 | |
876 | Err(Errno::last()) |
877 | } |
878 | |
879 | /// Replace the current process image with a new one and replicate shell `PATH` |
880 | /// searching behavior (see |
881 | /// [`execvpe(3)`](https://man7.org/linux/man-pages/man3/exec.3.html)). |
882 | /// |
883 | /// This functions like a combination of `execvp(2)` and `execve(2)` to pass an |
884 | /// environment and have a search path. See these two for additional |
885 | /// information. |
886 | #[cfg (any(target_os = "haiku" , target_os = "linux" , target_os = "openbsd" ))] |
887 | pub fn execvpe<SA: AsRef<CStr>, SE: AsRef<CStr>>( |
888 | filename: &CStr, |
889 | args: &[SA], |
890 | env: &[SE], |
891 | ) -> Result<Infallible> { |
892 | let args_p = to_exec_array(args); |
893 | let env_p = to_exec_array(env); |
894 | |
895 | unsafe { |
896 | libc::execvpe(filename.as_ptr(), args_p.as_ptr(), env_p.as_ptr()) |
897 | }; |
898 | |
899 | Err(Errno::last()) |
900 | } |
901 | |
902 | /// Replace the current process image with a new one (see |
903 | /// [fexecve(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/fexecve.html)). |
904 | /// |
905 | /// The `fexecve` function allows for another process to be "called" which will |
906 | /// replace the current process image. That is, this process becomes the new |
907 | /// command that is run. On success, this function will not return. Instead, |
908 | /// the new program will run until it exits. |
909 | /// |
910 | /// This function is similar to `execve`, except that the program to be executed |
911 | /// is referenced as a file descriptor instead of a path. |
912 | #[cfg (any( |
913 | target_os = "android" , |
914 | target_os = "linux" , |
915 | target_os = "dragonfly" , |
916 | target_os = "freebsd" |
917 | ))] |
918 | #[inline ] |
919 | pub fn fexecve<SA: AsRef<CStr>, SE: AsRef<CStr>>( |
920 | fd: RawFd, |
921 | args: &[SA], |
922 | env: &[SE], |
923 | ) -> Result<Infallible> { |
924 | let args_p = to_exec_array(args); |
925 | let env_p = to_exec_array(env); |
926 | |
927 | unsafe { libc::fexecve(fd, args_p.as_ptr(), env_p.as_ptr()) }; |
928 | |
929 | Err(Errno::last()) |
930 | } |
931 | |
932 | /// Execute program relative to a directory file descriptor (see |
933 | /// [execveat(2)](https://man7.org/linux/man-pages/man2/execveat.2.html)). |
934 | /// |
935 | /// The `execveat` function allows for another process to be "called" which will |
936 | /// replace the current process image. That is, this process becomes the new |
937 | /// command that is run. On success, this function will not return. Instead, |
938 | /// the new program will run until it exits. |
939 | /// |
940 | /// This function is similar to `execve`, except that the program to be executed |
941 | /// is referenced as a file descriptor to the base directory plus a path. |
942 | #[cfg (any(target_os = "android" , target_os = "linux" ))] |
943 | #[inline ] |
944 | pub fn execveat<SA: AsRef<CStr>, SE: AsRef<CStr>>( |
945 | dirfd: RawFd, |
946 | pathname: &CStr, |
947 | args: &[SA], |
948 | env: &[SE], |
949 | flags: super::fcntl::AtFlags, |
950 | ) -> Result<Infallible> { |
951 | let args_p = to_exec_array(args); |
952 | let env_p = to_exec_array(env); |
953 | |
954 | unsafe { |
955 | libc::syscall( |
956 | libc::SYS_execveat, |
957 | dirfd, |
958 | pathname.as_ptr(), |
959 | args_p.as_ptr(), |
960 | env_p.as_ptr(), |
961 | flags, |
962 | ); |
963 | }; |
964 | |
965 | Err(Errno::last()) |
966 | } |
967 | |
968 | /// Daemonize this process by detaching from the controlling terminal (see |
969 | /// [daemon(3)](https://man7.org/linux/man-pages/man3/daemon.3.html)). |
970 | /// |
971 | /// When a process is launched it is typically associated with a parent and it, |
972 | /// in turn, by its controlling terminal/process. In order for a process to run |
973 | /// in the "background" it must daemonize itself by detaching itself. Under |
974 | /// posix, this is done by doing the following: |
975 | /// |
976 | /// 1. Parent process (this one) forks |
977 | /// 2. Parent process exits |
978 | /// 3. Child process continues to run. |
979 | /// |
980 | /// `nochdir`: |
981 | /// |
982 | /// * `nochdir = true`: The current working directory after daemonizing will |
983 | /// be the current working directory. |
984 | /// * `nochdir = false`: The current working directory after daemonizing will |
985 | /// be the root direcory, `/`. |
986 | /// |
987 | /// `noclose`: |
988 | /// |
989 | /// * `noclose = true`: The process' current stdin, stdout, and stderr file |
990 | /// descriptors will remain identical after daemonizing. |
991 | /// * `noclose = false`: The process' stdin, stdout, and stderr will point to |
992 | /// `/dev/null` after daemonizing. |
993 | #[cfg (any( |
994 | target_os = "android" , |
995 | target_os = "dragonfly" , |
996 | target_os = "freebsd" , |
997 | target_os = "illumos" , |
998 | target_os = "linux" , |
999 | target_os = "netbsd" , |
1000 | target_os = "openbsd" , |
1001 | target_os = "solaris" |
1002 | ))] |
1003 | pub fn daemon(nochdir: bool, noclose: bool) -> Result<()> { |
1004 | let res = unsafe { libc::daemon(nochdir as c_int, noclose as c_int) }; |
1005 | Errno::result(res).map(drop) |
1006 | } |
1007 | } |
1008 | |
1009 | feature! { |
1010 | #![feature = "hostname" ] |
1011 | |
1012 | /// Set the system host name (see |
1013 | /// [sethostname(2)](https://man7.org/linux/man-pages/man2/gethostname.2.html)). |
1014 | /// |
1015 | /// Given a name, attempt to update the system host name to the given string. |
1016 | /// On some systems, the host name is limited to as few as 64 bytes. An error |
1017 | /// will be returned if the name is not valid or the current process does not |
1018 | /// have permissions to update the host name. |
1019 | #[cfg (not(target_os = "redox" ))] |
1020 | pub fn sethostname<S: AsRef<OsStr>>(name: S) -> Result<()> { |
1021 | // Handle some differences in type of the len arg across platforms. |
1022 | cfg_if! { |
1023 | if #[cfg(any(target_os = "dragonfly" , |
1024 | target_os = "freebsd" , |
1025 | target_os = "illumos" , |
1026 | target_os = "ios" , |
1027 | target_os = "macos" , |
1028 | target_os = "aix" , |
1029 | target_os = "solaris" , ))] { |
1030 | type sethostname_len_t = c_int; |
1031 | } else { |
1032 | type sethostname_len_t = size_t; |
1033 | } |
1034 | } |
1035 | let ptr = name.as_ref().as_bytes().as_ptr() as *const c_char; |
1036 | let len = name.as_ref().len() as sethostname_len_t; |
1037 | |
1038 | let res = unsafe { libc::sethostname(ptr, len) }; |
1039 | Errno::result(res).map(drop) |
1040 | } |
1041 | |
1042 | /// Get the host name and store it in an internally allocated buffer, returning an |
1043 | /// `OsString` on success (see |
1044 | /// [gethostname(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/gethostname.html)). |
1045 | /// |
1046 | /// This function call attempts to get the host name for the running system and |
1047 | /// store it in an internal buffer, returning it as an `OsString` if successful. |
1048 | /// |
1049 | /// ```no_run |
1050 | /// use nix::unistd; |
1051 | /// |
1052 | /// let hostname = unistd::gethostname().expect("Failed getting hostname"); |
1053 | /// let hostname = hostname.into_string().expect("Hostname wasn't valid UTF-8"); |
1054 | /// println!("Hostname: {}", hostname); |
1055 | /// ``` |
1056 | pub fn gethostname() -> Result<OsString> { |
1057 | // The capacity is the max length of a hostname plus the NUL terminator. |
1058 | let mut buffer: Vec<u8> = Vec::with_capacity(256); |
1059 | let ptr = buffer.as_mut_ptr() as *mut c_char; |
1060 | let len = buffer.capacity() as size_t; |
1061 | |
1062 | let res = unsafe { libc::gethostname(ptr, len) }; |
1063 | Errno::result(res).map(|_| { |
1064 | unsafe { |
1065 | buffer.as_mut_ptr().wrapping_add(len - 1).write(0); // ensure always null-terminated |
1066 | let len = CStr::from_ptr(buffer.as_ptr() as *const c_char).len(); |
1067 | buffer.set_len(len); |
1068 | } |
1069 | OsString::from_vec(buffer) |
1070 | }) |
1071 | } |
1072 | } |
1073 | |
1074 | /// Close a raw file descriptor |
1075 | /// |
1076 | /// Be aware that many Rust types implicitly close-on-drop, including |
1077 | /// `std::fs::File`. Explicitly closing them with this method too can result in |
1078 | /// a double-close condition, which can cause confusing `EBADF` errors in |
1079 | /// seemingly unrelated code. Caveat programmer. See also |
1080 | /// [close(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/close.html). |
1081 | /// |
1082 | /// # Examples |
1083 | /// |
1084 | /// ```no_run |
1085 | /// use std::os::unix::io::AsRawFd; |
1086 | /// use nix::unistd::close; |
1087 | /// |
1088 | /// let f = tempfile::tempfile().unwrap(); |
1089 | /// close(f.as_raw_fd()).unwrap(); // Bad! f will also close on drop! |
1090 | /// ``` |
1091 | /// |
1092 | /// ```rust |
1093 | /// use std::os::unix::io::IntoRawFd; |
1094 | /// use nix::unistd::close; |
1095 | /// |
1096 | /// let f = tempfile::tempfile().unwrap(); |
1097 | /// close(f.into_raw_fd()).unwrap(); // Good. into_raw_fd consumes f |
1098 | /// ``` |
1099 | pub fn close(fd: RawFd) -> Result<()> { |
1100 | let res: i32 = unsafe { libc::close(fd) }; |
1101 | Errno::result(res).map(op:drop) |
1102 | } |
1103 | |
1104 | /// Read from a raw file descriptor. |
1105 | /// |
1106 | /// See also [read(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/read.html) |
1107 | pub fn read(fd: RawFd, buf: &mut [u8]) -> Result<usize> { |
1108 | let res: isize = unsafe { |
1109 | libc::read(fd, buf:buf.as_mut_ptr() as *mut c_void, count:buf.len() as size_t) |
1110 | }; |
1111 | |
1112 | Errno::result(res).map(|r: isize| r as usize) |
1113 | } |
1114 | |
1115 | /// Write to a raw file descriptor. |
1116 | /// |
1117 | /// See also [write(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/write.html) |
1118 | pub fn write(fd: RawFd, buf: &[u8]) -> Result<usize> { |
1119 | let res: isize = unsafe { |
1120 | libc::write(fd, buf:buf.as_ptr() as *const c_void, count:buf.len() as size_t) |
1121 | }; |
1122 | |
1123 | Errno::result(res).map(|r: isize| r as usize) |
1124 | } |
1125 | |
1126 | feature! { |
1127 | #![feature = "fs" ] |
1128 | |
1129 | /// Directive that tells [`lseek`] and [`lseek64`] what the offset is relative to. |
1130 | /// |
1131 | /// [`lseek`]: ./fn.lseek.html |
1132 | /// [`lseek64`]: ./fn.lseek64.html |
1133 | #[repr (i32)] |
1134 | #[derive (Clone, Copy, Debug)] |
1135 | pub enum Whence { |
1136 | /// Specify an offset relative to the start of the file. |
1137 | SeekSet = libc::SEEK_SET, |
1138 | /// Specify an offset relative to the current file location. |
1139 | SeekCur = libc::SEEK_CUR, |
1140 | /// Specify an offset relative to the end of the file. |
1141 | SeekEnd = libc::SEEK_END, |
1142 | /// Specify an offset relative to the next location in the file greater than or |
1143 | /// equal to offset that contains some data. If offset points to |
1144 | /// some data, then the file offset is set to offset. |
1145 | #[cfg (any( |
1146 | target_os = "dragonfly" , |
1147 | target_os = "freebsd" , |
1148 | target_os = "illumos" , |
1149 | target_os = "linux" , |
1150 | target_os = "solaris" |
1151 | ))] |
1152 | SeekData = libc::SEEK_DATA, |
1153 | /// Specify an offset relative to the next hole in the file greater than |
1154 | /// or equal to offset. If offset points into the middle of a hole, then |
1155 | /// the file offset should be set to offset. If there is no hole past offset, |
1156 | /// then the file offset should be adjusted to the end of the file (i.e., there |
1157 | /// is an implicit hole at the end of any file). |
1158 | #[cfg (any( |
1159 | target_os = "dragonfly" , |
1160 | target_os = "freebsd" , |
1161 | target_os = "illumos" , |
1162 | target_os = "linux" , |
1163 | target_os = "solaris" |
1164 | ))] |
1165 | SeekHole = libc::SEEK_HOLE, |
1166 | } |
1167 | |
1168 | /// Move the read/write file offset. |
1169 | /// |
1170 | /// See also [lseek(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/lseek.html) |
1171 | pub fn lseek(fd: RawFd, offset: off_t, whence: Whence) -> Result<off_t> { |
1172 | let res = unsafe { libc::lseek(fd, offset, whence as i32) }; |
1173 | |
1174 | Errno::result(res).map(|r| r as off_t) |
1175 | } |
1176 | |
1177 | #[cfg (any(target_os = "linux" , target_os = "android" ))] |
1178 | pub fn lseek64( |
1179 | fd: RawFd, |
1180 | offset: libc::off64_t, |
1181 | whence: Whence, |
1182 | ) -> Result<libc::off64_t> { |
1183 | let res = unsafe { libc::lseek64(fd, offset, whence as i32) }; |
1184 | |
1185 | Errno::result(res).map(|r| r as libc::off64_t) |
1186 | } |
1187 | } |
1188 | |
1189 | /// Create an interprocess channel. |
1190 | /// |
1191 | /// See also [pipe(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/pipe.html) |
1192 | pub fn pipe() -> std::result::Result<(RawFd, RawFd), Error> { |
1193 | let mut fds: MaybeUninit<[i32; 2]> = mem::MaybeUninit::<[c_int; 2]>::uninit(); |
1194 | |
1195 | let res: i32 = unsafe { libc::pipe(fds:fds.as_mut_ptr() as *mut c_int) }; |
1196 | |
1197 | Error::result(res)?; |
1198 | |
1199 | unsafe { Ok((fds.assume_init()[0], fds.assume_init()[1])) } |
1200 | } |
1201 | |
1202 | feature! { |
1203 | #![feature = "fs" ] |
1204 | /// Like `pipe`, but allows setting certain file descriptor flags. |
1205 | /// |
1206 | /// The following flags are supported, and will be set atomically as the pipe is |
1207 | /// created: |
1208 | /// |
1209 | /// - `O_CLOEXEC`: Set the close-on-exec flag for the new file descriptors. |
1210 | #[cfg_attr ( |
1211 | target_os = "linux" , |
1212 | doc = "- `O_DIRECT`: Create a pipe that performs I/O in \"packet \" mode." |
1213 | )] |
1214 | #[cfg_attr ( |
1215 | target_os = "netbsd" , |
1216 | doc = "- `O_NOSIGPIPE`: Return `EPIPE` instead of raising `SIGPIPE`." |
1217 | )] |
1218 | /// - `O_NONBLOCK`: Set the non-blocking flag for the ends of the pipe. |
1219 | /// |
1220 | /// See also [pipe(2)](https://man7.org/linux/man-pages/man2/pipe.2.html) |
1221 | #[cfg (any( |
1222 | target_os = "android" , |
1223 | target_os = "dragonfly" , |
1224 | target_os = "emscripten" , |
1225 | target_os = "freebsd" , |
1226 | target_os = "illumos" , |
1227 | target_os = "linux" , |
1228 | target_os = "redox" , |
1229 | target_os = "netbsd" , |
1230 | target_os = "openbsd" , |
1231 | target_os = "solaris" |
1232 | ))] |
1233 | pub fn pipe2(flags: OFlag) -> Result<(RawFd, RawFd)> { |
1234 | let mut fds = mem::MaybeUninit::<[c_int; 2]>::uninit(); |
1235 | |
1236 | let res = |
1237 | unsafe { libc::pipe2(fds.as_mut_ptr() as *mut c_int, flags.bits()) }; |
1238 | |
1239 | Errno::result(res)?; |
1240 | |
1241 | unsafe { Ok((fds.assume_init()[0], fds.assume_init()[1])) } |
1242 | } |
1243 | |
1244 | /// Truncate a file to a specified length |
1245 | /// |
1246 | /// See also |
1247 | /// [truncate(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/truncate.html) |
1248 | #[cfg (not(any(target_os = "redox" , target_os = "fuchsia" )))] |
1249 | pub fn truncate<P: ?Sized + NixPath>(path: &P, len: off_t) -> Result<()> { |
1250 | let res = path |
1251 | .with_nix_path(|cstr| unsafe { libc::truncate(cstr.as_ptr(), len) })?; |
1252 | |
1253 | Errno::result(res).map(drop) |
1254 | } |
1255 | |
1256 | /// Truncate a file to a specified length |
1257 | /// |
1258 | /// See also |
1259 | /// [ftruncate(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/ftruncate.html) |
1260 | pub fn ftruncate<Fd: AsFd>(fd: Fd, len: off_t) -> Result<()> { |
1261 | Errno::result(unsafe { libc::ftruncate(fd.as_fd().as_raw_fd(), len) }).map(drop) |
1262 | } |
1263 | |
1264 | pub fn isatty(fd: RawFd) -> Result<bool> { |
1265 | unsafe { |
1266 | // ENOTTY means `fd` is a valid file descriptor, but not a TTY, so |
1267 | // we return `Ok(false)` |
1268 | if libc::isatty(fd) == 1 { |
1269 | Ok(true) |
1270 | } else { |
1271 | match Errno::last() { |
1272 | Errno::ENOTTY => Ok(false), |
1273 | err => Err(err), |
1274 | } |
1275 | } |
1276 | } |
1277 | } |
1278 | |
1279 | /// Flags for `linkat` function. |
1280 | #[derive (Clone, Copy, Debug)] |
1281 | pub enum LinkatFlags { |
1282 | SymlinkFollow, |
1283 | NoSymlinkFollow, |
1284 | } |
1285 | |
1286 | /// Link one file to another file |
1287 | /// |
1288 | /// Creates a new link (directory entry) at `newpath` for the existing file at `oldpath`. In the |
1289 | /// case of a relative `oldpath`, the path is interpreted relative to the directory associated |
1290 | /// with file descriptor `olddirfd` instead of the current working directory and similiarly for |
1291 | /// `newpath` and file descriptor `newdirfd`. In case `flag` is LinkatFlags::SymlinkFollow and |
1292 | /// `oldpath` names a symoblic link, a new link for the target of the symbolic link is created. |
1293 | /// If either `olddirfd` or `newdirfd` is `None`, `AT_FDCWD` is used respectively where `oldpath` |
1294 | /// and/or `newpath` is then interpreted relative to the current working directory of the calling |
1295 | /// process. If either `oldpath` or `newpath` is absolute, then `dirfd` is ignored. |
1296 | /// |
1297 | /// # References |
1298 | /// See also [linkat(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/linkat.html) |
1299 | #[cfg (not(target_os = "redox" ))] // RedoxFS does not support symlinks yet |
1300 | pub fn linkat<P: ?Sized + NixPath>( |
1301 | olddirfd: Option<RawFd>, |
1302 | oldpath: &P, |
1303 | newdirfd: Option<RawFd>, |
1304 | newpath: &P, |
1305 | flag: LinkatFlags, |
1306 | ) -> Result<()> { |
1307 | let atflag = match flag { |
1308 | LinkatFlags::SymlinkFollow => AtFlags::AT_SYMLINK_FOLLOW, |
1309 | LinkatFlags::NoSymlinkFollow => AtFlags::empty(), |
1310 | }; |
1311 | |
1312 | let res = oldpath.with_nix_path(|oldcstr| { |
1313 | newpath.with_nix_path(|newcstr| unsafe { |
1314 | libc::linkat( |
1315 | at_rawfd(olddirfd), |
1316 | oldcstr.as_ptr(), |
1317 | at_rawfd(newdirfd), |
1318 | newcstr.as_ptr(), |
1319 | atflag.bits() as libc::c_int, |
1320 | ) |
1321 | }) |
1322 | })??; |
1323 | Errno::result(res).map(drop) |
1324 | } |
1325 | |
1326 | /// Remove a directory entry |
1327 | /// |
1328 | /// See also [unlink(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/unlink.html) |
1329 | pub fn unlink<P: ?Sized + NixPath>(path: &P) -> Result<()> { |
1330 | let res = |
1331 | path.with_nix_path(|cstr| unsafe { libc::unlink(cstr.as_ptr()) })?; |
1332 | Errno::result(res).map(drop) |
1333 | } |
1334 | |
1335 | /// Flags for `unlinkat` function. |
1336 | #[derive (Clone, Copy, Debug)] |
1337 | pub enum UnlinkatFlags { |
1338 | RemoveDir, |
1339 | NoRemoveDir, |
1340 | } |
1341 | |
1342 | /// Remove a directory entry |
1343 | /// |
1344 | /// In the case of a relative path, the directory entry to be removed is determined relative to |
1345 | /// the directory associated with the file descriptor `dirfd` or the current working directory |
1346 | /// if `dirfd` is `None`. In the case of an absolute `path` `dirfd` is ignored. If `flag` is |
1347 | /// `UnlinkatFlags::RemoveDir` then removal of the directory entry specified by `dirfd` and `path` |
1348 | /// is performed. |
1349 | /// |
1350 | /// # References |
1351 | /// See also [unlinkat(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/unlinkat.html) |
1352 | #[cfg (not(target_os = "redox" ))] |
1353 | pub fn unlinkat<P: ?Sized + NixPath>( |
1354 | dirfd: Option<RawFd>, |
1355 | path: &P, |
1356 | flag: UnlinkatFlags, |
1357 | ) -> Result<()> { |
1358 | let atflag = match flag { |
1359 | UnlinkatFlags::RemoveDir => AtFlags::AT_REMOVEDIR, |
1360 | UnlinkatFlags::NoRemoveDir => AtFlags::empty(), |
1361 | }; |
1362 | let res = path.with_nix_path(|cstr| unsafe { |
1363 | libc::unlinkat( |
1364 | at_rawfd(dirfd), |
1365 | cstr.as_ptr(), |
1366 | atflag.bits() as libc::c_int, |
1367 | ) |
1368 | })?; |
1369 | Errno::result(res).map(drop) |
1370 | } |
1371 | |
1372 | #[inline ] |
1373 | #[cfg (not(target_os = "fuchsia" ))] |
1374 | pub fn chroot<P: ?Sized + NixPath>(path: &P) -> Result<()> { |
1375 | let res = |
1376 | path.with_nix_path(|cstr| unsafe { libc::chroot(cstr.as_ptr()) })?; |
1377 | |
1378 | Errno::result(res).map(drop) |
1379 | } |
1380 | |
1381 | /// Commit filesystem caches to disk |
1382 | /// |
1383 | /// See also [sync(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/sync.html) |
1384 | #[cfg (any( |
1385 | target_os = "dragonfly" , |
1386 | target_os = "freebsd" , |
1387 | target_os = "linux" , |
1388 | target_os = "netbsd" , |
1389 | target_os = "openbsd" |
1390 | ))] |
1391 | pub fn sync() { |
1392 | unsafe { libc::sync() }; |
1393 | } |
1394 | |
1395 | /// Commit filesystem caches containing file referred to by the open file |
1396 | /// descriptor `fd` to disk |
1397 | /// |
1398 | /// See also [syncfs(2)](https://man7.org/linux/man-pages/man2/sync.2.html) |
1399 | #[cfg (target_os = "linux" )] |
1400 | pub fn syncfs(fd: RawFd) -> Result<()> { |
1401 | let res = unsafe { libc::syncfs(fd) }; |
1402 | |
1403 | Errno::result(res).map(drop) |
1404 | } |
1405 | |
1406 | /// Synchronize changes to a file |
1407 | /// |
1408 | /// See also [fsync(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/fsync.html) |
1409 | #[inline ] |
1410 | pub fn fsync(fd: RawFd) -> Result<()> { |
1411 | let res = unsafe { libc::fsync(fd) }; |
1412 | |
1413 | Errno::result(res).map(drop) |
1414 | } |
1415 | |
1416 | /// Synchronize the data of a file |
1417 | /// |
1418 | /// See also |
1419 | /// [fdatasync(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/fdatasync.html) |
1420 | #[cfg (any( |
1421 | target_os = "linux" , |
1422 | target_os = "android" , |
1423 | target_os = "emscripten" , |
1424 | target_os = "freebsd" , |
1425 | target_os = "fuchsia" , |
1426 | target_os = "netbsd" , |
1427 | target_os = "openbsd" , |
1428 | target_os = "illumos" , |
1429 | target_os = "solaris" |
1430 | ))] |
1431 | #[inline ] |
1432 | pub fn fdatasync(fd: RawFd) -> Result<()> { |
1433 | let res = unsafe { libc::fdatasync(fd) }; |
1434 | |
1435 | Errno::result(res).map(drop) |
1436 | } |
1437 | } |
1438 | |
1439 | feature! { |
1440 | #![feature = "user" ] |
1441 | |
1442 | /// Get a real user ID |
1443 | /// |
1444 | /// See also [getuid(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/getuid.html) |
1445 | // POSIX requires that getuid is always successful, so no need to check return |
1446 | // value or errno. |
1447 | #[inline ] |
1448 | pub fn getuid() -> Uid { |
1449 | Uid(unsafe { libc::getuid() }) |
1450 | } |
1451 | |
1452 | /// Get the effective user ID |
1453 | /// |
1454 | /// See also [geteuid(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/geteuid.html) |
1455 | // POSIX requires that geteuid is always successful, so no need to check return |
1456 | // value or errno. |
1457 | #[inline ] |
1458 | pub fn geteuid() -> Uid { |
1459 | Uid(unsafe { libc::geteuid() }) |
1460 | } |
1461 | |
1462 | /// Get the real group ID |
1463 | /// |
1464 | /// See also [getgid(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/getgid.html) |
1465 | // POSIX requires that getgid is always successful, so no need to check return |
1466 | // value or errno. |
1467 | #[inline ] |
1468 | pub fn getgid() -> Gid { |
1469 | Gid(unsafe { libc::getgid() }) |
1470 | } |
1471 | |
1472 | /// Get the effective group ID |
1473 | /// |
1474 | /// See also [getegid(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/getegid.html) |
1475 | // POSIX requires that getegid is always successful, so no need to check return |
1476 | // value or errno. |
1477 | #[inline ] |
1478 | pub fn getegid() -> Gid { |
1479 | Gid(unsafe { libc::getegid() }) |
1480 | } |
1481 | |
1482 | /// Set the effective user ID |
1483 | /// |
1484 | /// See also [seteuid(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/seteuid.html) |
1485 | #[inline ] |
1486 | pub fn seteuid(euid: Uid) -> Result<()> { |
1487 | let res = unsafe { libc::seteuid(euid.into()) }; |
1488 | |
1489 | Errno::result(res).map(drop) |
1490 | } |
1491 | |
1492 | /// Set the effective group ID |
1493 | /// |
1494 | /// See also [setegid(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/setegid.html) |
1495 | #[inline ] |
1496 | pub fn setegid(egid: Gid) -> Result<()> { |
1497 | let res = unsafe { libc::setegid(egid.into()) }; |
1498 | |
1499 | Errno::result(res).map(drop) |
1500 | } |
1501 | |
1502 | /// Set the user ID |
1503 | /// |
1504 | /// See also [setuid(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/setuid.html) |
1505 | #[inline ] |
1506 | pub fn setuid(uid: Uid) -> Result<()> { |
1507 | let res = unsafe { libc::setuid(uid.into()) }; |
1508 | |
1509 | Errno::result(res).map(drop) |
1510 | } |
1511 | |
1512 | /// Set the group ID |
1513 | /// |
1514 | /// See also [setgid(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/setgid.html) |
1515 | #[inline ] |
1516 | pub fn setgid(gid: Gid) -> Result<()> { |
1517 | let res = unsafe { libc::setgid(gid.into()) }; |
1518 | |
1519 | Errno::result(res).map(drop) |
1520 | } |
1521 | } |
1522 | |
1523 | feature! { |
1524 | #![all(feature = "fs" , feature = "user" )] |
1525 | /// Set the user identity used for filesystem checks per-thread. |
1526 | /// On both success and failure, this call returns the previous filesystem user |
1527 | /// ID of the caller. |
1528 | /// |
1529 | /// See also [setfsuid(2)](https://man7.org/linux/man-pages/man2/setfsuid.2.html) |
1530 | #[cfg (any(target_os = "linux" , target_os = "android" ))] |
1531 | pub fn setfsuid(uid: Uid) -> Uid { |
1532 | let prev_fsuid = unsafe { libc::setfsuid(uid.into()) }; |
1533 | Uid::from_raw(prev_fsuid as uid_t) |
1534 | } |
1535 | |
1536 | /// Set the group identity used for filesystem checks per-thread. |
1537 | /// On both success and failure, this call returns the previous filesystem group |
1538 | /// ID of the caller. |
1539 | /// |
1540 | /// See also [setfsgid(2)](https://man7.org/linux/man-pages/man2/setfsgid.2.html) |
1541 | #[cfg (any(target_os = "linux" , target_os = "android" ))] |
1542 | pub fn setfsgid(gid: Gid) -> Gid { |
1543 | let prev_fsgid = unsafe { libc::setfsgid(gid.into()) }; |
1544 | Gid::from_raw(prev_fsgid as gid_t) |
1545 | } |
1546 | } |
1547 | |
1548 | feature! { |
1549 | #![feature = "user" ] |
1550 | |
1551 | /// Get the list of supplementary group IDs of the calling process. |
1552 | /// |
1553 | /// [Further reading](https://pubs.opengroup.org/onlinepubs/009695399/functions/getgroups.html) |
1554 | /// |
1555 | /// **Note:** This function is not available for Apple platforms. On those |
1556 | /// platforms, checking group membership should be achieved via communication |
1557 | /// with the `opendirectoryd` service. |
1558 | #[cfg (not(any(target_os = "ios" , target_os = "macos" )))] |
1559 | pub fn getgroups() -> Result<Vec<Gid>> { |
1560 | // First get the maximum number of groups. The value returned |
1561 | // shall always be greater than or equal to one and less than or |
1562 | // equal to the value of {NGROUPS_MAX} + 1. |
1563 | let ngroups_max = match sysconf(SysconfVar::NGROUPS_MAX) { |
1564 | Ok(Some(n)) => (n + 1) as usize, |
1565 | Ok(None) | Err(_) => <usize>::max_value(), |
1566 | }; |
1567 | |
1568 | // Next, get the number of groups so we can size our Vec |
1569 | let ngroups = unsafe { libc::getgroups(0, ptr::null_mut()) }; |
1570 | |
1571 | // If there are no supplementary groups, return early. |
1572 | // This prevents a potential buffer over-read if the number of groups |
1573 | // increases from zero before the next call. It would return the total |
1574 | // number of groups beyond the capacity of the buffer. |
1575 | if ngroups == 0 { |
1576 | return Ok(Vec::new()); |
1577 | } |
1578 | |
1579 | // Now actually get the groups. We try multiple times in case the number of |
1580 | // groups has changed since the first call to getgroups() and the buffer is |
1581 | // now too small. |
1582 | let mut groups = |
1583 | Vec::<Gid>::with_capacity(Errno::result(ngroups)? as usize); |
1584 | loop { |
1585 | // FIXME: On the platforms we currently support, the `Gid` struct has |
1586 | // the same representation in memory as a bare `gid_t`. This is not |
1587 | // necessarily the case on all Rust platforms, though. See RFC 1785. |
1588 | let ngroups = unsafe { |
1589 | libc::getgroups( |
1590 | groups.capacity() as c_int, |
1591 | groups.as_mut_ptr() as *mut gid_t, |
1592 | ) |
1593 | }; |
1594 | |
1595 | match Errno::result(ngroups) { |
1596 | Ok(s) => { |
1597 | unsafe { groups.set_len(s as usize) }; |
1598 | return Ok(groups); |
1599 | } |
1600 | Err(Errno::EINVAL) => { |
1601 | // EINVAL indicates that the buffer size was too |
1602 | // small, resize it up to ngroups_max as limit. |
1603 | reserve_double_buffer_size(&mut groups, ngroups_max) |
1604 | .or(Err(Errno::EINVAL))?; |
1605 | } |
1606 | Err(e) => return Err(e), |
1607 | } |
1608 | } |
1609 | } |
1610 | |
1611 | /// Set the list of supplementary group IDs for the calling process. |
1612 | /// |
1613 | /// [Further reading](https://man7.org/linux/man-pages/man2/getgroups.2.html) |
1614 | /// |
1615 | /// **Note:** This function is not available for Apple platforms. On those |
1616 | /// platforms, group membership management should be achieved via communication |
1617 | /// with the `opendirectoryd` service. |
1618 | /// |
1619 | /// # Examples |
1620 | /// |
1621 | /// `setgroups` can be used when dropping privileges from the root user to a |
1622 | /// specific user and group. For example, given the user `www-data` with UID |
1623 | /// `33` and the group `backup` with the GID `34`, one could switch the user as |
1624 | /// follows: |
1625 | /// |
1626 | /// ```rust,no_run |
1627 | /// # use std::error::Error; |
1628 | /// # use nix::unistd::*; |
1629 | /// # |
1630 | /// # fn try_main() -> Result<(), Box<dyn Error>> { |
1631 | /// let uid = Uid::from_raw(33); |
1632 | /// let gid = Gid::from_raw(34); |
1633 | /// setgroups(&[gid])?; |
1634 | /// setgid(gid)?; |
1635 | /// setuid(uid)?; |
1636 | /// # |
1637 | /// # Ok(()) |
1638 | /// # } |
1639 | /// # |
1640 | /// # try_main().unwrap(); |
1641 | /// ``` |
1642 | #[cfg (not(any( |
1643 | target_os = "ios" , |
1644 | target_os = "macos" , |
1645 | target_os = "redox" , |
1646 | target_os = "haiku" |
1647 | )))] |
1648 | pub fn setgroups(groups: &[Gid]) -> Result<()> { |
1649 | cfg_if! { |
1650 | if #[cfg(any(target_os = "aix" , |
1651 | target_os = "dragonfly" , |
1652 | target_os = "freebsd" , |
1653 | target_os = "illumos" , |
1654 | target_os = "ios" , |
1655 | target_os = "macos" , |
1656 | target_os = "netbsd" , |
1657 | target_os = "openbsd" , |
1658 | target_os = "solaris" ))] { |
1659 | type setgroups_ngroups_t = c_int; |
1660 | } else { |
1661 | type setgroups_ngroups_t = size_t; |
1662 | } |
1663 | } |
1664 | // FIXME: On the platforms we currently support, the `Gid` struct has the |
1665 | // same representation in memory as a bare `gid_t`. This is not necessarily |
1666 | // the case on all Rust platforms, though. See RFC 1785. |
1667 | let res = unsafe { |
1668 | libc::setgroups( |
1669 | groups.len() as setgroups_ngroups_t, |
1670 | groups.as_ptr() as *const gid_t, |
1671 | ) |
1672 | }; |
1673 | |
1674 | Errno::result(res).map(drop) |
1675 | } |
1676 | |
1677 | /// Calculate the supplementary group access list. |
1678 | /// |
1679 | /// Gets the group IDs of all groups that `user` is a member of. The additional |
1680 | /// group `group` is also added to the list. |
1681 | /// |
1682 | /// [Further reading](https://man7.org/linux/man-pages/man3/getgrouplist.3.html) |
1683 | /// |
1684 | /// **Note:** This function is not available for Apple platforms. On those |
1685 | /// platforms, checking group membership should be achieved via communication |
1686 | /// with the `opendirectoryd` service. |
1687 | /// |
1688 | /// # Errors |
1689 | /// |
1690 | /// Although the `getgrouplist()` call does not return any specific |
1691 | /// errors on any known platforms, this implementation will return a system |
1692 | /// error of `EINVAL` if the number of groups to be fetched exceeds the |
1693 | /// `NGROUPS_MAX` sysconf value. This mimics the behaviour of `getgroups()` |
1694 | /// and `setgroups()`. Additionally, while some implementations will return a |
1695 | /// partial list of groups when `NGROUPS_MAX` is exceeded, this implementation |
1696 | /// will only ever return the complete list or else an error. |
1697 | #[cfg (not(any( |
1698 | target_os = "aix" , |
1699 | target_os = "illumos" , |
1700 | target_os = "ios" , |
1701 | target_os = "macos" , |
1702 | target_os = "redox" |
1703 | )))] |
1704 | pub fn getgrouplist(user: &CStr, group: Gid) -> Result<Vec<Gid>> { |
1705 | let ngroups_max = match sysconf(SysconfVar::NGROUPS_MAX) { |
1706 | Ok(Some(n)) => n as c_int, |
1707 | Ok(None) | Err(_) => <c_int>::max_value(), |
1708 | }; |
1709 | use std::cmp::min; |
1710 | let mut groups = Vec::<Gid>::with_capacity(min(ngroups_max, 8) as usize); |
1711 | cfg_if! { |
1712 | if #[cfg(any(target_os = "ios" , target_os = "macos" ))] { |
1713 | type getgrouplist_group_t = c_int; |
1714 | } else { |
1715 | type getgrouplist_group_t = gid_t; |
1716 | } |
1717 | } |
1718 | let gid: gid_t = group.into(); |
1719 | loop { |
1720 | let mut ngroups = groups.capacity() as i32; |
1721 | let ret = unsafe { |
1722 | libc::getgrouplist( |
1723 | user.as_ptr(), |
1724 | gid as getgrouplist_group_t, |
1725 | groups.as_mut_ptr() as *mut getgrouplist_group_t, |
1726 | &mut ngroups, |
1727 | ) |
1728 | }; |
1729 | |
1730 | // BSD systems only return 0 or -1, Linux returns ngroups on success. |
1731 | if ret >= 0 { |
1732 | unsafe { groups.set_len(ngroups as usize) }; |
1733 | return Ok(groups); |
1734 | } else if ret == -1 { |
1735 | // Returns -1 if ngroups is too small, but does not set errno. |
1736 | // BSD systems will still fill the groups buffer with as many |
1737 | // groups as possible, but Linux manpages do not mention this |
1738 | // behavior. |
1739 | reserve_double_buffer_size(&mut groups, ngroups_max as usize) |
1740 | .map_err(|_| Errno::EINVAL)?; |
1741 | } |
1742 | } |
1743 | } |
1744 | |
1745 | /// Initialize the supplementary group access list. |
1746 | /// |
1747 | /// Sets the supplementary group IDs for the calling process using all groups |
1748 | /// that `user` is a member of. The additional group `group` is also added to |
1749 | /// the list. |
1750 | /// |
1751 | /// [Further reading](https://man7.org/linux/man-pages/man3/initgroups.3.html) |
1752 | /// |
1753 | /// **Note:** This function is not available for Apple platforms. On those |
1754 | /// platforms, group membership management should be achieved via communication |
1755 | /// with the `opendirectoryd` service. |
1756 | /// |
1757 | /// # Examples |
1758 | /// |
1759 | /// `initgroups` can be used when dropping privileges from the root user to |
1760 | /// another user. For example, given the user `www-data`, we could look up the |
1761 | /// UID and GID for the user in the system's password database (usually found |
1762 | /// in `/etc/passwd`). If the `www-data` user's UID and GID were `33` and `33`, |
1763 | /// respectively, one could switch the user as follows: |
1764 | /// |
1765 | /// ```rust,no_run |
1766 | /// # use std::error::Error; |
1767 | /// # use std::ffi::CString; |
1768 | /// # use nix::unistd::*; |
1769 | /// # |
1770 | /// # fn try_main() -> Result<(), Box<dyn Error>> { |
1771 | /// let user = CString::new("www-data").unwrap(); |
1772 | /// let uid = Uid::from_raw(33); |
1773 | /// let gid = Gid::from_raw(33); |
1774 | /// initgroups(&user, gid)?; |
1775 | /// setgid(gid)?; |
1776 | /// setuid(uid)?; |
1777 | /// # |
1778 | /// # Ok(()) |
1779 | /// # } |
1780 | /// # |
1781 | /// # try_main().unwrap(); |
1782 | /// ``` |
1783 | #[cfg (not(any( |
1784 | target_os = "ios" , |
1785 | target_os = "macos" , |
1786 | target_os = "redox" , |
1787 | target_os = "haiku" |
1788 | )))] |
1789 | pub fn initgroups(user: &CStr, group: Gid) -> Result<()> { |
1790 | cfg_if! { |
1791 | if #[cfg(any(target_os = "ios" , target_os = "macos" ))] { |
1792 | type initgroups_group_t = c_int; |
1793 | } else { |
1794 | type initgroups_group_t = gid_t; |
1795 | } |
1796 | } |
1797 | let gid: gid_t = group.into(); |
1798 | let res = |
1799 | unsafe { libc::initgroups(user.as_ptr(), gid as initgroups_group_t) }; |
1800 | |
1801 | Errno::result(res).map(drop) |
1802 | } |
1803 | } |
1804 | |
1805 | feature! { |
1806 | #![feature = "signal" ] |
1807 | |
1808 | /// Suspend the thread until a signal is received. |
1809 | /// |
1810 | /// See also [pause(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/pause.html). |
1811 | #[inline ] |
1812 | #[cfg (not(target_os = "redox" ))] |
1813 | pub fn pause() { |
1814 | unsafe { libc::pause() }; |
1815 | } |
1816 | |
1817 | pub mod alarm { |
1818 | //! Alarm signal scheduling. |
1819 | //! |
1820 | //! Scheduling an alarm will trigger a `SIGALRM` signal when the time has |
1821 | //! elapsed, which has to be caught, because the default action for the |
1822 | //! signal is to terminate the program. This signal also can't be ignored |
1823 | //! because the system calls like `pause` will not be interrupted, see the |
1824 | //! second example below. |
1825 | //! |
1826 | //! # Examples |
1827 | //! |
1828 | //! Canceling an alarm: |
1829 | //! |
1830 | //! ``` |
1831 | //! use nix::unistd::alarm; |
1832 | //! |
1833 | //! // Set an alarm for 60 seconds from now. |
1834 | //! alarm::set(60); |
1835 | //! |
1836 | //! // Cancel the above set alarm, which returns the number of seconds left |
1837 | //! // of the previously set alarm. |
1838 | //! assert_eq!(alarm::cancel(), Some(60)); |
1839 | //! ``` |
1840 | //! |
1841 | //! Scheduling an alarm and waiting for the signal: |
1842 | //! |
1843 | #![cfg_attr (target_os = "redox" , doc = " ```rust,ignore" )] |
1844 | #![cfg_attr (not(target_os = "redox" ), doc = " ```rust" )] |
1845 | //! use std::time::{Duration, Instant}; |
1846 | //! |
1847 | //! use nix::unistd::{alarm, pause}; |
1848 | //! use nix::sys::signal::*; |
1849 | //! |
1850 | //! // We need to setup an empty signal handler to catch the alarm signal, |
1851 | //! // otherwise the program will be terminated once the signal is delivered. |
1852 | //! extern fn signal_handler(_: nix::libc::c_int) { } |
1853 | //! let sa = SigAction::new( |
1854 | //! SigHandler::Handler(signal_handler), |
1855 | //! SaFlags::SA_RESTART, |
1856 | //! SigSet::empty() |
1857 | //! ); |
1858 | //! unsafe { |
1859 | //! sigaction(Signal::SIGALRM, &sa); |
1860 | //! } |
1861 | //! |
1862 | //! let start = Instant::now(); |
1863 | //! |
1864 | //! // Set an alarm for 1 second from now. |
1865 | //! alarm::set(1); |
1866 | //! |
1867 | //! // Pause the process until the alarm signal is received. |
1868 | //! let mut sigset = SigSet::empty(); |
1869 | //! sigset.add(Signal::SIGALRM); |
1870 | //! sigset.wait(); |
1871 | //! |
1872 | //! assert!(start.elapsed() >= Duration::from_secs(1)); |
1873 | //! ``` |
1874 | //! |
1875 | //! # References |
1876 | //! |
1877 | //! See also [alarm(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/alarm.html). |
1878 | |
1879 | /// Schedule an alarm signal. |
1880 | /// |
1881 | /// This will cause the system to generate a `SIGALRM` signal for the |
1882 | /// process after the specified number of seconds have elapsed. |
1883 | /// |
1884 | /// Returns the leftover time of a previously set alarm if there was one. |
1885 | pub fn set(secs: libc::c_uint) -> Option<libc::c_uint> { |
1886 | assert!(secs != 0, "passing 0 to `alarm::set` is not allowed, to cancel an alarm use `alarm::cancel`" ); |
1887 | alarm(secs) |
1888 | } |
1889 | |
1890 | /// Cancel an previously set alarm signal. |
1891 | /// |
1892 | /// Returns the leftover time of a previously set alarm if there was one. |
1893 | pub fn cancel() -> Option<libc::c_uint> { |
1894 | alarm(0) |
1895 | } |
1896 | |
1897 | fn alarm(secs: libc::c_uint) -> Option<libc::c_uint> { |
1898 | match unsafe { libc::alarm(secs) } { |
1899 | 0 => None, |
1900 | secs => Some(secs), |
1901 | } |
1902 | } |
1903 | } |
1904 | } |
1905 | |
1906 | /// Suspend execution for an interval of time |
1907 | /// |
1908 | /// See also [sleep(2)](https://pubs.opengroup.org/onlinepubs/009695399/functions/sleep.html#tag_03_705_05) |
1909 | // Per POSIX, does not fail |
1910 | #[inline ] |
1911 | pub fn sleep(seconds: c_uint) -> c_uint { |
1912 | unsafe { libc::sleep(secs:seconds) } |
1913 | } |
1914 | |
1915 | feature! { |
1916 | #![feature = "acct" ] |
1917 | |
1918 | #[cfg (not(any(target_os = "redox" , target_os = "haiku" )))] |
1919 | pub mod acct { |
1920 | use crate::errno::Errno; |
1921 | use crate::{NixPath, Result}; |
1922 | use std::ptr; |
1923 | |
1924 | /// Enable process accounting |
1925 | /// |
1926 | /// See also [acct(2)](https://linux.die.net/man/2/acct) |
1927 | pub fn enable<P: ?Sized + NixPath>(filename: &P) -> Result<()> { |
1928 | let res = filename |
1929 | .with_nix_path(|cstr| unsafe { libc::acct(cstr.as_ptr()) })?; |
1930 | |
1931 | Errno::result(res).map(drop) |
1932 | } |
1933 | |
1934 | /// Disable process accounting |
1935 | pub fn disable() -> Result<()> { |
1936 | let res = unsafe { libc::acct(ptr::null()) }; |
1937 | |
1938 | Errno::result(res).map(drop) |
1939 | } |
1940 | } |
1941 | } |
1942 | |
1943 | feature! { |
1944 | #![feature = "fs" ] |
1945 | /// Creates a regular file which persists even after process termination |
1946 | /// |
1947 | /// * `template`: a path whose 6 rightmost characters must be X, e.g. `/tmp/tmpfile_XXXXXX` |
1948 | /// * returns: tuple of file descriptor and filename |
1949 | /// |
1950 | /// Err is returned either if no temporary filename could be created or the template doesn't |
1951 | /// end with XXXXXX |
1952 | /// |
1953 | /// See also [mkstemp(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/mkstemp.html) |
1954 | /// |
1955 | /// # Example |
1956 | /// |
1957 | /// ```rust |
1958 | /// use nix::unistd; |
1959 | /// |
1960 | /// let _ = match unistd::mkstemp("/tmp/tempfile_XXXXXX") { |
1961 | /// Ok((fd, path)) => { |
1962 | /// unistd::unlink(path.as_path()).unwrap(); // flag file to be deleted at app termination |
1963 | /// fd |
1964 | /// } |
1965 | /// Err(e) => panic!("mkstemp failed: {}", e) |
1966 | /// }; |
1967 | /// // do something with fd |
1968 | /// ``` |
1969 | #[inline ] |
1970 | pub fn mkstemp<P: ?Sized + NixPath>(template: &P) -> Result<(RawFd, PathBuf)> { |
1971 | let mut path = |
1972 | template.with_nix_path(|path| path.to_bytes_with_nul().to_owned())?; |
1973 | let p = path.as_mut_ptr() as *mut _; |
1974 | let fd = unsafe { libc::mkstemp(p) }; |
1975 | let last = path.pop(); // drop the trailing nul |
1976 | debug_assert!(last == Some(b' \0' )); |
1977 | let pathname = OsString::from_vec(path); |
1978 | Errno::result(fd)?; |
1979 | Ok((fd, PathBuf::from(pathname))) |
1980 | } |
1981 | } |
1982 | |
1983 | feature! { |
1984 | #![all(feature = "fs" , feature = "feature" )] |
1985 | |
1986 | /// Variable names for `pathconf` |
1987 | /// |
1988 | /// Nix uses the same naming convention for these variables as the |
1989 | /// [getconf(1)](https://pubs.opengroup.org/onlinepubs/9699919799/utilities/getconf.html) utility. |
1990 | /// That is, `PathconfVar` variables have the same name as the abstract |
1991 | /// variables shown in the `pathconf(2)` man page. Usually, it's the same as |
1992 | /// the C variable name without the leading `_PC_`. |
1993 | /// |
1994 | /// POSIX 1003.1-2008 standardizes all of these variables, but some OSes choose |
1995 | /// not to implement variables that cannot change at runtime. |
1996 | /// |
1997 | /// # References |
1998 | /// |
1999 | /// - [pathconf(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/pathconf.html) |
2000 | /// - [limits.h](https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/limits.h.html) |
2001 | /// - [unistd.h](https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/unistd.h.html) |
2002 | #[derive (Clone, Copy, Debug, Eq, Hash, PartialEq)] |
2003 | #[repr (i32)] |
2004 | #[non_exhaustive ] |
2005 | pub enum PathconfVar { |
2006 | #[cfg (any( |
2007 | target_os = "dragonfly" , |
2008 | target_os = "freebsd" , |
2009 | target_os = "linux" , |
2010 | target_os = "netbsd" , |
2011 | target_os = "openbsd" , |
2012 | target_os = "redox" |
2013 | ))] |
2014 | /// Minimum number of bits needed to represent, as a signed integer value, |
2015 | /// the maximum size of a regular file allowed in the specified directory. |
2016 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2017 | FILESIZEBITS = libc::_PC_FILESIZEBITS, |
2018 | /// Maximum number of links to a single file. |
2019 | LINK_MAX = libc::_PC_LINK_MAX, |
2020 | /// Maximum number of bytes in a terminal canonical input line. |
2021 | MAX_CANON = libc::_PC_MAX_CANON, |
2022 | /// Minimum number of bytes for which space is available in a terminal input |
2023 | /// queue; therefore, the maximum number of bytes a conforming application |
2024 | /// may require to be typed as input before reading them. |
2025 | MAX_INPUT = libc::_PC_MAX_INPUT, |
2026 | /// Maximum number of bytes in a filename (not including the terminating |
2027 | /// null of a filename string). |
2028 | NAME_MAX = libc::_PC_NAME_MAX, |
2029 | /// Maximum number of bytes the implementation will store as a pathname in a |
2030 | /// user-supplied buffer of unspecified size, including the terminating null |
2031 | /// character. Minimum number the implementation will accept as the maximum |
2032 | /// number of bytes in a pathname. |
2033 | PATH_MAX = libc::_PC_PATH_MAX, |
2034 | /// Maximum number of bytes that is guaranteed to be atomic when writing to |
2035 | /// a pipe. |
2036 | PIPE_BUF = libc::_PC_PIPE_BUF, |
2037 | #[cfg (any( |
2038 | target_os = "android" , |
2039 | target_os = "dragonfly" , |
2040 | target_os = "illumos" , |
2041 | target_os = "linux" , |
2042 | target_os = "netbsd" , |
2043 | target_os = "openbsd" , |
2044 | target_os = "redox" , |
2045 | target_os = "solaris" |
2046 | ))] |
2047 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2048 | /// Symbolic links can be created. |
2049 | POSIX2_SYMLINKS = libc::_PC_2_SYMLINKS, |
2050 | #[cfg (any( |
2051 | target_os = "android" , |
2052 | target_os = "dragonfly" , |
2053 | target_os = "freebsd" , |
2054 | target_os = "linux" , |
2055 | target_os = "openbsd" , |
2056 | target_os = "redox" |
2057 | ))] |
2058 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2059 | /// Minimum number of bytes of storage actually allocated for any portion of |
2060 | /// a file. |
2061 | POSIX_ALLOC_SIZE_MIN = libc::_PC_ALLOC_SIZE_MIN, |
2062 | #[cfg (any( |
2063 | target_os = "android" , |
2064 | target_os = "dragonfly" , |
2065 | target_os = "freebsd" , |
2066 | target_os = "linux" , |
2067 | target_os = "openbsd" |
2068 | ))] |
2069 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2070 | /// Recommended increment for file transfer sizes between the |
2071 | /// `POSIX_REC_MIN_XFER_SIZE` and `POSIX_REC_MAX_XFER_SIZE` values. |
2072 | POSIX_REC_INCR_XFER_SIZE = libc::_PC_REC_INCR_XFER_SIZE, |
2073 | #[cfg (any( |
2074 | target_os = "android" , |
2075 | target_os = "dragonfly" , |
2076 | target_os = "freebsd" , |
2077 | target_os = "linux" , |
2078 | target_os = "openbsd" , |
2079 | target_os = "redox" |
2080 | ))] |
2081 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2082 | /// Maximum recommended file transfer size. |
2083 | POSIX_REC_MAX_XFER_SIZE = libc::_PC_REC_MAX_XFER_SIZE, |
2084 | #[cfg (any( |
2085 | target_os = "android" , |
2086 | target_os = "dragonfly" , |
2087 | target_os = "freebsd" , |
2088 | target_os = "linux" , |
2089 | target_os = "openbsd" , |
2090 | target_os = "redox" |
2091 | ))] |
2092 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2093 | /// Minimum recommended file transfer size. |
2094 | POSIX_REC_MIN_XFER_SIZE = libc::_PC_REC_MIN_XFER_SIZE, |
2095 | #[cfg (any( |
2096 | target_os = "android" , |
2097 | target_os = "dragonfly" , |
2098 | target_os = "freebsd" , |
2099 | target_os = "linux" , |
2100 | target_os = "openbsd" , |
2101 | target_os = "redox" |
2102 | ))] |
2103 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2104 | /// Recommended file transfer buffer alignment. |
2105 | POSIX_REC_XFER_ALIGN = libc::_PC_REC_XFER_ALIGN, |
2106 | #[cfg (any( |
2107 | target_os = "android" , |
2108 | target_os = "dragonfly" , |
2109 | target_os = "freebsd" , |
2110 | target_os = "illumos" , |
2111 | target_os = "linux" , |
2112 | target_os = "netbsd" , |
2113 | target_os = "openbsd" , |
2114 | target_os = "redox" , |
2115 | target_os = "solaris" |
2116 | ))] |
2117 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2118 | /// Maximum number of bytes in a symbolic link. |
2119 | SYMLINK_MAX = libc::_PC_SYMLINK_MAX, |
2120 | /// The use of `chown` and `fchown` is restricted to a process with |
2121 | /// appropriate privileges, and to changing the group ID of a file only to |
2122 | /// the effective group ID of the process or to one of its supplementary |
2123 | /// group IDs. |
2124 | _POSIX_CHOWN_RESTRICTED = libc::_PC_CHOWN_RESTRICTED, |
2125 | /// Pathname components longer than {NAME_MAX} generate an error. |
2126 | _POSIX_NO_TRUNC = libc::_PC_NO_TRUNC, |
2127 | /// This symbol shall be defined to be the value of a character that shall |
2128 | /// disable terminal special character handling. |
2129 | _POSIX_VDISABLE = libc::_PC_VDISABLE, |
2130 | #[cfg (any( |
2131 | target_os = "android" , |
2132 | target_os = "dragonfly" , |
2133 | target_os = "freebsd" , |
2134 | target_os = "illumos" , |
2135 | target_os = "linux" , |
2136 | target_os = "openbsd" , |
2137 | target_os = "redox" , |
2138 | target_os = "solaris" |
2139 | ))] |
2140 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2141 | /// Asynchronous input or output operations may be performed for the |
2142 | /// associated file. |
2143 | _POSIX_ASYNC_IO = libc::_PC_ASYNC_IO, |
2144 | #[cfg (any( |
2145 | target_os = "android" , |
2146 | target_os = "dragonfly" , |
2147 | target_os = "freebsd" , |
2148 | target_os = "illumos" , |
2149 | target_os = "linux" , |
2150 | target_os = "openbsd" , |
2151 | target_os = "redox" , |
2152 | target_os = "solaris" |
2153 | ))] |
2154 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2155 | /// Prioritized input or output operations may be performed for the |
2156 | /// associated file. |
2157 | _POSIX_PRIO_IO = libc::_PC_PRIO_IO, |
2158 | #[cfg (any( |
2159 | target_os = "android" , |
2160 | target_os = "dragonfly" , |
2161 | target_os = "freebsd" , |
2162 | target_os = "illumos" , |
2163 | target_os = "linux" , |
2164 | target_os = "netbsd" , |
2165 | target_os = "openbsd" , |
2166 | target_os = "redox" , |
2167 | target_os = "solaris" |
2168 | ))] |
2169 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2170 | /// Synchronized input or output operations may be performed for the |
2171 | /// associated file. |
2172 | _POSIX_SYNC_IO = libc::_PC_SYNC_IO, |
2173 | #[cfg (any(target_os = "dragonfly" , target_os = "openbsd" ))] |
2174 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2175 | /// The resolution in nanoseconds for all file timestamps. |
2176 | _POSIX_TIMESTAMP_RESOLUTION = libc::_PC_TIMESTAMP_RESOLUTION, |
2177 | } |
2178 | |
2179 | /// Like `pathconf`, but works with file descriptors instead of paths (see |
2180 | /// [fpathconf(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/pathconf.html)) |
2181 | /// |
2182 | /// # Parameters |
2183 | /// |
2184 | /// - `fd`: The file descriptor whose variable should be interrogated |
2185 | /// - `var`: The pathconf variable to lookup |
2186 | /// |
2187 | /// # Returns |
2188 | /// |
2189 | /// - `Ok(Some(x))`: the variable's limit (for limit variables) or its |
2190 | /// implementation level (for option variables). Implementation levels are |
2191 | /// usually a decimal-coded date, such as 200112 for POSIX 2001.12 |
2192 | /// - `Ok(None)`: the variable has no limit (for limit variables) or is |
2193 | /// unsupported (for option variables) |
2194 | /// - `Err(x)`: an error occurred |
2195 | pub fn fpathconf(fd: RawFd, var: PathconfVar) -> Result<Option<c_long>> { |
2196 | let raw = unsafe { |
2197 | Errno::clear(); |
2198 | libc::fpathconf(fd, var as c_int) |
2199 | }; |
2200 | if raw == -1 { |
2201 | if errno::errno() == 0 { |
2202 | Ok(None) |
2203 | } else { |
2204 | Err(Errno::last()) |
2205 | } |
2206 | } else { |
2207 | Ok(Some(raw)) |
2208 | } |
2209 | } |
2210 | |
2211 | /// Get path-dependent configurable system variables (see |
2212 | /// [pathconf(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/pathconf.html)) |
2213 | /// |
2214 | /// Returns the value of a path-dependent configurable system variable. Most |
2215 | /// supported variables also have associated compile-time constants, but POSIX |
2216 | /// allows their values to change at runtime. There are generally two types of |
2217 | /// `pathconf` variables: options and limits. See [pathconf(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/pathconf.html) for more details. |
2218 | /// |
2219 | /// # Parameters |
2220 | /// |
2221 | /// - `path`: Lookup the value of `var` for this file or directory |
2222 | /// - `var`: The `pathconf` variable to lookup |
2223 | /// |
2224 | /// # Returns |
2225 | /// |
2226 | /// - `Ok(Some(x))`: the variable's limit (for limit variables) or its |
2227 | /// implementation level (for option variables). Implementation levels are |
2228 | /// usually a decimal-coded date, such as 200112 for POSIX 2001.12 |
2229 | /// - `Ok(None)`: the variable has no limit (for limit variables) or is |
2230 | /// unsupported (for option variables) |
2231 | /// - `Err(x)`: an error occurred |
2232 | pub fn pathconf<P: ?Sized + NixPath>( |
2233 | path: &P, |
2234 | var: PathconfVar, |
2235 | ) -> Result<Option<c_long>> { |
2236 | let raw = path.with_nix_path(|cstr| unsafe { |
2237 | Errno::clear(); |
2238 | libc::pathconf(cstr.as_ptr(), var as c_int) |
2239 | })?; |
2240 | if raw == -1 { |
2241 | if errno::errno() == 0 { |
2242 | Ok(None) |
2243 | } else { |
2244 | Err(Errno::last()) |
2245 | } |
2246 | } else { |
2247 | Ok(Some(raw)) |
2248 | } |
2249 | } |
2250 | } |
2251 | |
2252 | feature! { |
2253 | #![feature = "feature" ] |
2254 | |
2255 | /// Variable names for `sysconf` |
2256 | /// |
2257 | /// Nix uses the same naming convention for these variables as the |
2258 | /// [getconf(1)](https://pubs.opengroup.org/onlinepubs/9699919799/utilities/getconf.html) utility. |
2259 | /// That is, `SysconfVar` variables have the same name as the abstract variables |
2260 | /// shown in the `sysconf(3)` man page. Usually, it's the same as the C |
2261 | /// variable name without the leading `_SC_`. |
2262 | /// |
2263 | /// All of these symbols are standardized by POSIX 1003.1-2008, but haven't been |
2264 | /// implemented by all platforms. |
2265 | /// |
2266 | /// # References |
2267 | /// |
2268 | /// - [sysconf(3)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/sysconf.html) |
2269 | /// - [unistd.h](https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/unistd.h.html) |
2270 | /// - [limits.h](https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/limits.h.html) |
2271 | #[derive (Clone, Copy, Debug, Eq, Hash, PartialEq)] |
2272 | #[repr (i32)] |
2273 | #[non_exhaustive ] |
2274 | pub enum SysconfVar { |
2275 | /// Maximum number of I/O operations in a single list I/O call supported by |
2276 | /// the implementation. |
2277 | #[cfg (not(any(target_os = "redox" , target_os = "haiku" )))] |
2278 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2279 | AIO_LISTIO_MAX = libc::_SC_AIO_LISTIO_MAX, |
2280 | /// Maximum number of outstanding asynchronous I/O operations supported by |
2281 | /// the implementation. |
2282 | #[cfg (not(any(target_os = "redox" , target_os = "haiku" )))] |
2283 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2284 | AIO_MAX = libc::_SC_AIO_MAX, |
2285 | #[cfg (any( |
2286 | target_os = "android" , |
2287 | target_os = "dragonfly" , |
2288 | target_os = "freebsd" , |
2289 | target_os = "ios" , |
2290 | target_os = "linux" , |
2291 | target_os = "macos" , |
2292 | target_os = "openbsd" |
2293 | ))] |
2294 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2295 | /// The maximum amount by which a process can decrease its asynchronous I/O |
2296 | /// priority level from its own scheduling priority. |
2297 | AIO_PRIO_DELTA_MAX = libc::_SC_AIO_PRIO_DELTA_MAX, |
2298 | /// Maximum length of argument to the exec functions including environment data. |
2299 | ARG_MAX = libc::_SC_ARG_MAX, |
2300 | /// Maximum number of functions that may be registered with `atexit`. |
2301 | #[cfg (not(target_os = "redox" ))] |
2302 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2303 | ATEXIT_MAX = libc::_SC_ATEXIT_MAX, |
2304 | /// Maximum obase values allowed by the bc utility. |
2305 | #[cfg (not(any(target_os = "redox" , target_os = "haiku" )))] |
2306 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2307 | BC_BASE_MAX = libc::_SC_BC_BASE_MAX, |
2308 | /// Maximum number of elements permitted in an array by the bc utility. |
2309 | #[cfg (not(any(target_os = "redox" , target_os = "haiku" )))] |
2310 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2311 | BC_DIM_MAX = libc::_SC_BC_DIM_MAX, |
2312 | /// Maximum scale value allowed by the bc utility. |
2313 | #[cfg (not(any(target_os = "redox" , target_os = "haiku" )))] |
2314 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2315 | BC_SCALE_MAX = libc::_SC_BC_SCALE_MAX, |
2316 | /// Maximum length of a string constant accepted by the bc utility. |
2317 | #[cfg (not(any(target_os = "redox" , target_os = "haiku" )))] |
2318 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2319 | BC_STRING_MAX = libc::_SC_BC_STRING_MAX, |
2320 | /// Maximum number of simultaneous processes per real user ID. |
2321 | CHILD_MAX = libc::_SC_CHILD_MAX, |
2322 | // The number of clock ticks per second. |
2323 | CLK_TCK = libc::_SC_CLK_TCK, |
2324 | /// Maximum number of weights that can be assigned to an entry of the |
2325 | /// LC_COLLATE order keyword in the locale definition file |
2326 | #[cfg (not(any(target_os = "redox" , target_os = "haiku" )))] |
2327 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2328 | COLL_WEIGHTS_MAX = libc::_SC_COLL_WEIGHTS_MAX, |
2329 | /// Maximum number of timer expiration overruns. |
2330 | #[cfg (not(any(target_os = "redox" , target_os = "haiku" )))] |
2331 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2332 | DELAYTIMER_MAX = libc::_SC_DELAYTIMER_MAX, |
2333 | /// Maximum number of expressions that can be nested within parentheses by |
2334 | /// the expr utility. |
2335 | #[cfg (not(any(target_os = "redox" , target_os = "haiku" )))] |
2336 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2337 | EXPR_NEST_MAX = libc::_SC_EXPR_NEST_MAX, |
2338 | #[cfg (any( |
2339 | target_os = "dragonfly" , |
2340 | target_os = "freebsd" , |
2341 | target_os = "illumos" , |
2342 | target_os = "ios" , |
2343 | target_os = "linux" , |
2344 | target_os = "macos" , |
2345 | target_os = "netbsd" , |
2346 | target_os = "openbsd" , |
2347 | target_os = "solaris" |
2348 | ))] |
2349 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2350 | /// Maximum length of a host name (not including the terminating null) as |
2351 | /// returned from the `gethostname` function |
2352 | HOST_NAME_MAX = libc::_SC_HOST_NAME_MAX, |
2353 | /// Maximum number of iovec structures that one process has available for |
2354 | /// use with `readv` or `writev`. |
2355 | #[cfg (not(target_os = "redox" ))] |
2356 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2357 | IOV_MAX = libc::_SC_IOV_MAX, |
2358 | /// Unless otherwise noted, the maximum length, in bytes, of a utility's |
2359 | /// input line (either standard input or another file), when the utility is |
2360 | /// described as processing text files. The length includes room for the |
2361 | /// trailing newline. |
2362 | #[cfg (not(any(target_os = "redox" , target_os = "haiku" )))] |
2363 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2364 | LINE_MAX = libc::_SC_LINE_MAX, |
2365 | /// Maximum length of a login name. |
2366 | #[cfg (not(target_os = "haiku" ))] |
2367 | LOGIN_NAME_MAX = libc::_SC_LOGIN_NAME_MAX, |
2368 | /// Maximum number of simultaneous supplementary group IDs per process. |
2369 | NGROUPS_MAX = libc::_SC_NGROUPS_MAX, |
2370 | /// Initial size of `getgrgid_r` and `getgrnam_r` data buffers |
2371 | #[cfg (not(target_os = "redox" ))] |
2372 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2373 | GETGR_R_SIZE_MAX = libc::_SC_GETGR_R_SIZE_MAX, |
2374 | /// Initial size of `getpwuid_r` and `getpwnam_r` data buffers |
2375 | #[cfg (not(target_os = "redox" ))] |
2376 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2377 | GETPW_R_SIZE_MAX = libc::_SC_GETPW_R_SIZE_MAX, |
2378 | /// The maximum number of open message queue descriptors a process may hold. |
2379 | #[cfg (not(any(target_os = "redox" , target_os = "haiku" )))] |
2380 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2381 | MQ_OPEN_MAX = libc::_SC_MQ_OPEN_MAX, |
2382 | /// The maximum number of message priorities supported by the implementation. |
2383 | #[cfg (not(any(target_os = "redox" , target_os = "haiku" )))] |
2384 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2385 | MQ_PRIO_MAX = libc::_SC_MQ_PRIO_MAX, |
2386 | /// A value one greater than the maximum value that the system may assign to |
2387 | /// a newly-created file descriptor. |
2388 | OPEN_MAX = libc::_SC_OPEN_MAX, |
2389 | #[cfg (any( |
2390 | target_os = "dragonfly" , |
2391 | target_os = "freebsd" , |
2392 | target_os = "ios" , |
2393 | target_os = "linux" , |
2394 | target_os = "macos" , |
2395 | target_os = "openbsd" |
2396 | ))] |
2397 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2398 | /// The implementation supports the Advisory Information option. |
2399 | _POSIX_ADVISORY_INFO = libc::_SC_ADVISORY_INFO, |
2400 | #[cfg (any( |
2401 | target_os = "dragonfly" , |
2402 | target_os = "freebsd" , |
2403 | target_os = "illumos" , |
2404 | target_os = "ios" , |
2405 | target_os = "linux" , |
2406 | target_os = "macos" , |
2407 | target_os = "netbsd" , |
2408 | target_os = "openbsd" , |
2409 | target_os = "solaris" |
2410 | ))] |
2411 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2412 | /// The implementation supports barriers. |
2413 | _POSIX_BARRIERS = libc::_SC_BARRIERS, |
2414 | /// The implementation supports asynchronous input and output. |
2415 | #[cfg (not(any(target_os = "redox" , target_os = "haiku" )))] |
2416 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2417 | _POSIX_ASYNCHRONOUS_IO = libc::_SC_ASYNCHRONOUS_IO, |
2418 | #[cfg (any( |
2419 | target_os = "dragonfly" , |
2420 | target_os = "freebsd" , |
2421 | target_os = "illumos" , |
2422 | target_os = "ios" , |
2423 | target_os = "linux" , |
2424 | target_os = "macos" , |
2425 | target_os = "netbsd" , |
2426 | target_os = "openbsd" , |
2427 | target_os = "solaris" |
2428 | ))] |
2429 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2430 | /// The implementation supports clock selection. |
2431 | _POSIX_CLOCK_SELECTION = libc::_SC_CLOCK_SELECTION, |
2432 | #[cfg (any( |
2433 | target_os = "dragonfly" , |
2434 | target_os = "freebsd" , |
2435 | target_os = "illumos" , |
2436 | target_os = "ios" , |
2437 | target_os = "linux" , |
2438 | target_os = "macos" , |
2439 | target_os = "netbsd" , |
2440 | target_os = "openbsd" , |
2441 | target_os = "solaris" |
2442 | ))] |
2443 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2444 | /// The implementation supports the Process CPU-Time Clocks option. |
2445 | _POSIX_CPUTIME = libc::_SC_CPUTIME, |
2446 | /// The implementation supports the File Synchronization option. |
2447 | #[cfg (not(any(target_os = "redox" , target_os = "haiku" )))] |
2448 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2449 | _POSIX_FSYNC = libc::_SC_FSYNC, |
2450 | #[cfg (any( |
2451 | target_os = "dragonfly" , |
2452 | target_os = "freebsd" , |
2453 | target_os = "illumos" , |
2454 | target_os = "ios" , |
2455 | target_os = "linux" , |
2456 | target_os = "macos" , |
2457 | target_os = "openbsd" , |
2458 | target_os = "solaris" |
2459 | ))] |
2460 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2461 | /// The implementation supports the IPv6 option. |
2462 | _POSIX_IPV6 = libc::_SC_IPV6, |
2463 | /// The implementation supports job control. |
2464 | #[cfg (not(target_os = "redox" ))] |
2465 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2466 | _POSIX_JOB_CONTROL = libc::_SC_JOB_CONTROL, |
2467 | /// The implementation supports memory mapped Files. |
2468 | #[cfg (not(any(target_os = "redox" , target_os = "haiku" )))] |
2469 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2470 | _POSIX_MAPPED_FILES = libc::_SC_MAPPED_FILES, |
2471 | /// The implementation supports the Process Memory Locking option. |
2472 | #[cfg (not(any(target_os = "redox" , target_os = "haiku" )))] |
2473 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2474 | _POSIX_MEMLOCK = libc::_SC_MEMLOCK, |
2475 | /// The implementation supports the Range Memory Locking option. |
2476 | #[cfg (not(any(target_os = "redox" , target_os = "haiku" )))] |
2477 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2478 | _POSIX_MEMLOCK_RANGE = libc::_SC_MEMLOCK_RANGE, |
2479 | /// The implementation supports memory protection. |
2480 | #[cfg (not(target_os = "redox" ))] |
2481 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2482 | _POSIX_MEMORY_PROTECTION = libc::_SC_MEMORY_PROTECTION, |
2483 | /// The implementation supports the Message Passing option. |
2484 | #[cfg (not(any(target_os = "redox" , target_os = "haiku" )))] |
2485 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2486 | _POSIX_MESSAGE_PASSING = libc::_SC_MESSAGE_PASSING, |
2487 | /// The implementation supports the Monotonic Clock option. |
2488 | #[cfg (not(target_os = "redox" ))] |
2489 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2490 | _POSIX_MONOTONIC_CLOCK = libc::_SC_MONOTONIC_CLOCK, |
2491 | #[cfg (any( |
2492 | target_os = "android" , |
2493 | target_os = "dragonfly" , |
2494 | target_os = "freebsd" , |
2495 | target_os = "illumos" , |
2496 | target_os = "ios" , |
2497 | target_os = "linux" , |
2498 | target_os = "macos" , |
2499 | target_os = "openbsd" , |
2500 | target_os = "solaris" |
2501 | ))] |
2502 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2503 | /// The implementation supports the Prioritized Input and Output option. |
2504 | _POSIX_PRIORITIZED_IO = libc::_SC_PRIORITIZED_IO, |
2505 | /// The implementation supports the Process Scheduling option. |
2506 | #[cfg (not(any(target_os = "redox" , target_os = "haiku" )))] |
2507 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2508 | _POSIX_PRIORITY_SCHEDULING = libc::_SC_PRIORITY_SCHEDULING, |
2509 | #[cfg (any( |
2510 | target_os = "dragonfly" , |
2511 | target_os = "freebsd" , |
2512 | target_os = "illumos" , |
2513 | target_os = "ios" , |
2514 | target_os = "linux" , |
2515 | target_os = "macos" , |
2516 | target_os = "openbsd" , |
2517 | target_os = "solaris" |
2518 | ))] |
2519 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2520 | /// The implementation supports the Raw Sockets option. |
2521 | _POSIX_RAW_SOCKETS = libc::_SC_RAW_SOCKETS, |
2522 | #[cfg (any( |
2523 | target_os = "dragonfly" , |
2524 | target_os = "freebsd" , |
2525 | target_os = "illumos" , |
2526 | target_os = "ios" , |
2527 | target_os = "linux" , |
2528 | target_os = "macos" , |
2529 | target_os = "netbsd" , |
2530 | target_os = "openbsd" , |
2531 | target_os = "solaris" |
2532 | ))] |
2533 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2534 | /// The implementation supports read-write locks. |
2535 | _POSIX_READER_WRITER_LOCKS = libc::_SC_READER_WRITER_LOCKS, |
2536 | #[cfg (any( |
2537 | target_os = "android" , |
2538 | target_os = "dragonfly" , |
2539 | target_os = "freebsd" , |
2540 | target_os = "ios" , |
2541 | target_os = "linux" , |
2542 | target_os = "macos" , |
2543 | target_os = "openbsd" |
2544 | ))] |
2545 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2546 | /// The implementation supports realtime signals. |
2547 | _POSIX_REALTIME_SIGNALS = libc::_SC_REALTIME_SIGNALS, |
2548 | #[cfg (any( |
2549 | target_os = "dragonfly" , |
2550 | target_os = "freebsd" , |
2551 | target_os = "illumos" , |
2552 | target_os = "ios" , |
2553 | target_os = "linux" , |
2554 | target_os = "macos" , |
2555 | target_os = "netbsd" , |
2556 | target_os = "openbsd" , |
2557 | target_os = "solaris" |
2558 | ))] |
2559 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2560 | /// The implementation supports the Regular Expression Handling option. |
2561 | _POSIX_REGEXP = libc::_SC_REGEXP, |
2562 | /// Each process has a saved set-user-ID and a saved set-group-ID. |
2563 | #[cfg (not(target_os = "redox" ))] |
2564 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2565 | _POSIX_SAVED_IDS = libc::_SC_SAVED_IDS, |
2566 | /// The implementation supports semaphores. |
2567 | #[cfg (not(target_os = "redox" ))] |
2568 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2569 | _POSIX_SEMAPHORES = libc::_SC_SEMAPHORES, |
2570 | /// The implementation supports the Shared Memory Objects option. |
2571 | #[cfg (not(any(target_os = "redox" , target_os = "haiku" )))] |
2572 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2573 | _POSIX_SHARED_MEMORY_OBJECTS = libc::_SC_SHARED_MEMORY_OBJECTS, |
2574 | #[cfg (any( |
2575 | target_os = "dragonfly" , |
2576 | target_os = "freebsd" , |
2577 | target_os = "ios" , |
2578 | target_os = "linux" , |
2579 | target_os = "macos" , |
2580 | target_os = "netbsd" , |
2581 | target_os = "openbsd" |
2582 | ))] |
2583 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2584 | /// The implementation supports the POSIX shell. |
2585 | _POSIX_SHELL = libc::_SC_SHELL, |
2586 | #[cfg (any( |
2587 | target_os = "dragonfly" , |
2588 | target_os = "freebsd" , |
2589 | target_os = "ios" , |
2590 | target_os = "linux" , |
2591 | target_os = "macos" , |
2592 | target_os = "netbsd" , |
2593 | target_os = "openbsd" |
2594 | ))] |
2595 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2596 | /// The implementation supports the Spawn option. |
2597 | _POSIX_SPAWN = libc::_SC_SPAWN, |
2598 | #[cfg (any( |
2599 | target_os = "dragonfly" , |
2600 | target_os = "freebsd" , |
2601 | target_os = "ios" , |
2602 | target_os = "linux" , |
2603 | target_os = "macos" , |
2604 | target_os = "netbsd" , |
2605 | target_os = "openbsd" |
2606 | ))] |
2607 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2608 | /// The implementation supports spin locks. |
2609 | _POSIX_SPIN_LOCKS = libc::_SC_SPIN_LOCKS, |
2610 | #[cfg (any( |
2611 | target_os = "dragonfly" , |
2612 | target_os = "freebsd" , |
2613 | target_os = "ios" , |
2614 | target_os = "linux" , |
2615 | target_os = "macos" , |
2616 | target_os = "openbsd" |
2617 | ))] |
2618 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2619 | /// The implementation supports the Process Sporadic Server option. |
2620 | _POSIX_SPORADIC_SERVER = libc::_SC_SPORADIC_SERVER, |
2621 | #[cfg (any( |
2622 | target_os = "ios" , |
2623 | target_os = "linux" , |
2624 | target_os = "macos" , |
2625 | target_os = "openbsd" |
2626 | ))] |
2627 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2628 | _POSIX_SS_REPL_MAX = libc::_SC_SS_REPL_MAX, |
2629 | /// The implementation supports the Synchronized Input and Output option. |
2630 | #[cfg (not(any(target_os = "redox" , target_os = "haiku" )))] |
2631 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2632 | _POSIX_SYNCHRONIZED_IO = libc::_SC_SYNCHRONIZED_IO, |
2633 | /// The implementation supports the Thread Stack Address Attribute option. |
2634 | #[cfg (not(target_os = "redox" ))] |
2635 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2636 | _POSIX_THREAD_ATTR_STACKADDR = libc::_SC_THREAD_ATTR_STACKADDR, |
2637 | /// The implementation supports the Thread Stack Size Attribute option. |
2638 | #[cfg (not(target_os = "redox" ))] |
2639 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2640 | _POSIX_THREAD_ATTR_STACKSIZE = libc::_SC_THREAD_ATTR_STACKSIZE, |
2641 | #[cfg (any( |
2642 | target_os = "ios" , |
2643 | target_os = "linux" , |
2644 | target_os = "macos" , |
2645 | target_os = "netbsd" , |
2646 | target_os = "openbsd" |
2647 | ))] |
2648 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2649 | /// The implementation supports the Thread CPU-Time Clocks option. |
2650 | _POSIX_THREAD_CPUTIME = libc::_SC_THREAD_CPUTIME, |
2651 | /// The implementation supports the Non-Robust Mutex Priority Inheritance |
2652 | /// option. |
2653 | #[cfg (not(any(target_os = "redox" , target_os = "haiku" )))] |
2654 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2655 | _POSIX_THREAD_PRIO_INHERIT = libc::_SC_THREAD_PRIO_INHERIT, |
2656 | /// The implementation supports the Non-Robust Mutex Priority Protection option. |
2657 | #[cfg (not(any(target_os = "redox" , target_os = "haiku" )))] |
2658 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2659 | _POSIX_THREAD_PRIO_PROTECT = libc::_SC_THREAD_PRIO_PROTECT, |
2660 | /// The implementation supports the Thread Execution Scheduling option. |
2661 | #[cfg (not(target_os = "redox" ))] |
2662 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2663 | _POSIX_THREAD_PRIORITY_SCHEDULING = libc::_SC_THREAD_PRIORITY_SCHEDULING, |
2664 | #[cfg (any( |
2665 | target_os = "dragonfly" , |
2666 | target_os = "freebsd" , |
2667 | target_os = "ios" , |
2668 | target_os = "linux" , |
2669 | target_os = "macos" , |
2670 | target_os = "netbsd" , |
2671 | target_os = "openbsd" |
2672 | ))] |
2673 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2674 | /// The implementation supports the Thread Process-Shared Synchronization |
2675 | /// option. |
2676 | _POSIX_THREAD_PROCESS_SHARED = libc::_SC_THREAD_PROCESS_SHARED, |
2677 | #[cfg (any( |
2678 | target_os = "dragonfly" , |
2679 | target_os = "linux" , |
2680 | target_os = "openbsd" |
2681 | ))] |
2682 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2683 | /// The implementation supports the Robust Mutex Priority Inheritance option. |
2684 | _POSIX_THREAD_ROBUST_PRIO_INHERIT = libc::_SC_THREAD_ROBUST_PRIO_INHERIT, |
2685 | #[cfg (any( |
2686 | target_os = "dragonfly" , |
2687 | target_os = "linux" , |
2688 | target_os = "openbsd" |
2689 | ))] |
2690 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2691 | /// The implementation supports the Robust Mutex Priority Protection option. |
2692 | _POSIX_THREAD_ROBUST_PRIO_PROTECT = libc::_SC_THREAD_ROBUST_PRIO_PROTECT, |
2693 | /// The implementation supports thread-safe functions. |
2694 | #[cfg (not(any(target_os = "redox" , target_os = "haiku" )))] |
2695 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2696 | _POSIX_THREAD_SAFE_FUNCTIONS = libc::_SC_THREAD_SAFE_FUNCTIONS, |
2697 | #[cfg (any( |
2698 | target_os = "dragonfly" , |
2699 | target_os = "freebsd" , |
2700 | target_os = "ios" , |
2701 | target_os = "linux" , |
2702 | target_os = "macos" , |
2703 | target_os = "openbsd" |
2704 | ))] |
2705 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2706 | /// The implementation supports the Thread Sporadic Server option. |
2707 | _POSIX_THREAD_SPORADIC_SERVER = libc::_SC_THREAD_SPORADIC_SERVER, |
2708 | /// The implementation supports threads. |
2709 | #[cfg (not(target_os = "redox" ))] |
2710 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2711 | _POSIX_THREADS = libc::_SC_THREADS, |
2712 | #[cfg (any( |
2713 | target_os = "dragonfly" , |
2714 | target_os = "freebsd" , |
2715 | target_os = "ios" , |
2716 | target_os = "linux" , |
2717 | target_os = "macos" , |
2718 | target_os = "openbsd" |
2719 | ))] |
2720 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2721 | /// The implementation supports timeouts. |
2722 | _POSIX_TIMEOUTS = libc::_SC_TIMEOUTS, |
2723 | /// The implementation supports timers. |
2724 | #[cfg (not(target_os = "redox" ))] |
2725 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2726 | _POSIX_TIMERS = libc::_SC_TIMERS, |
2727 | #[cfg (any( |
2728 | target_os = "dragonfly" , |
2729 | target_os = "freebsd" , |
2730 | target_os = "ios" , |
2731 | target_os = "linux" , |
2732 | target_os = "macos" , |
2733 | target_os = "openbsd" |
2734 | ))] |
2735 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2736 | /// The implementation supports the Trace option. |
2737 | _POSIX_TRACE = libc::_SC_TRACE, |
2738 | #[cfg (any( |
2739 | target_os = "dragonfly" , |
2740 | target_os = "freebsd" , |
2741 | target_os = "ios" , |
2742 | target_os = "linux" , |
2743 | target_os = "macos" , |
2744 | target_os = "openbsd" |
2745 | ))] |
2746 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2747 | /// The implementation supports the Trace Event Filter option. |
2748 | _POSIX_TRACE_EVENT_FILTER = libc::_SC_TRACE_EVENT_FILTER, |
2749 | #[cfg (any( |
2750 | target_os = "ios" , |
2751 | target_os = "linux" , |
2752 | target_os = "macos" , |
2753 | target_os = "openbsd" |
2754 | ))] |
2755 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2756 | _POSIX_TRACE_EVENT_NAME_MAX = libc::_SC_TRACE_EVENT_NAME_MAX, |
2757 | #[cfg (any( |
2758 | target_os = "dragonfly" , |
2759 | target_os = "freebsd" , |
2760 | target_os = "ios" , |
2761 | target_os = "linux" , |
2762 | target_os = "macos" , |
2763 | target_os = "openbsd" |
2764 | ))] |
2765 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2766 | /// The implementation supports the Trace Inherit option. |
2767 | _POSIX_TRACE_INHERIT = libc::_SC_TRACE_INHERIT, |
2768 | #[cfg (any( |
2769 | target_os = "dragonfly" , |
2770 | target_os = "freebsd" , |
2771 | target_os = "ios" , |
2772 | target_os = "linux" , |
2773 | target_os = "macos" , |
2774 | target_os = "openbsd" |
2775 | ))] |
2776 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2777 | /// The implementation supports the Trace Log option. |
2778 | _POSIX_TRACE_LOG = libc::_SC_TRACE_LOG, |
2779 | #[cfg (any( |
2780 | target_os = "ios" , |
2781 | target_os = "linux" , |
2782 | target_os = "macos" , |
2783 | target_os = "openbsd" |
2784 | ))] |
2785 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2786 | _POSIX_TRACE_NAME_MAX = libc::_SC_TRACE_NAME_MAX, |
2787 | #[cfg (any( |
2788 | target_os = "ios" , |
2789 | target_os = "linux" , |
2790 | target_os = "macos" , |
2791 | target_os = "openbsd" |
2792 | ))] |
2793 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2794 | _POSIX_TRACE_SYS_MAX = libc::_SC_TRACE_SYS_MAX, |
2795 | #[cfg (any( |
2796 | target_os = "ios" , |
2797 | target_os = "linux" , |
2798 | target_os = "macos" , |
2799 | target_os = "openbsd" |
2800 | ))] |
2801 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2802 | _POSIX_TRACE_USER_EVENT_MAX = libc::_SC_TRACE_USER_EVENT_MAX, |
2803 | #[cfg (any( |
2804 | target_os = "dragonfly" , |
2805 | target_os = "freebsd" , |
2806 | target_os = "ios" , |
2807 | target_os = "linux" , |
2808 | target_os = "macos" , |
2809 | target_os = "openbsd" |
2810 | ))] |
2811 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2812 | /// The implementation supports the Typed Memory Objects option. |
2813 | _POSIX_TYPED_MEMORY_OBJECTS = libc::_SC_TYPED_MEMORY_OBJECTS, |
2814 | /// Integer value indicating version of this standard (C-language binding) |
2815 | /// to which the implementation conforms. For implementations conforming to |
2816 | /// POSIX.1-2008, the value shall be 200809L. |
2817 | _POSIX_VERSION = libc::_SC_VERSION, |
2818 | #[cfg (any( |
2819 | target_os = "dragonfly" , |
2820 | target_os = "freebsd" , |
2821 | target_os = "ios" , |
2822 | target_os = "linux" , |
2823 | target_os = "macos" , |
2824 | target_os = "netbsd" , |
2825 | target_os = "openbsd" |
2826 | ))] |
2827 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2828 | /// The implementation provides a C-language compilation environment with |
2829 | /// 32-bit `int`, `long`, `pointer`, and `off_t` types. |
2830 | _POSIX_V6_ILP32_OFF32 = libc::_SC_V6_ILP32_OFF32, |
2831 | #[cfg (any( |
2832 | target_os = "dragonfly" , |
2833 | target_os = "freebsd" , |
2834 | target_os = "ios" , |
2835 | target_os = "linux" , |
2836 | target_os = "macos" , |
2837 | target_os = "netbsd" , |
2838 | target_os = "openbsd" |
2839 | ))] |
2840 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2841 | /// The implementation provides a C-language compilation environment with |
2842 | /// 32-bit `int`, `long`, and pointer types and an `off_t` type using at |
2843 | /// least 64 bits. |
2844 | _POSIX_V6_ILP32_OFFBIG = libc::_SC_V6_ILP32_OFFBIG, |
2845 | #[cfg (any( |
2846 | target_os = "dragonfly" , |
2847 | target_os = "freebsd" , |
2848 | target_os = "ios" , |
2849 | target_os = "linux" , |
2850 | target_os = "macos" , |
2851 | target_os = "netbsd" , |
2852 | target_os = "openbsd" |
2853 | ))] |
2854 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2855 | /// The implementation provides a C-language compilation environment with |
2856 | /// 32-bit `int` and 64-bit `long`, `pointer`, and `off_t` types. |
2857 | _POSIX_V6_LP64_OFF64 = libc::_SC_V6_LP64_OFF64, |
2858 | #[cfg (any( |
2859 | target_os = "dragonfly" , |
2860 | target_os = "freebsd" , |
2861 | target_os = "ios" , |
2862 | target_os = "linux" , |
2863 | target_os = "macos" , |
2864 | target_os = "netbsd" , |
2865 | target_os = "openbsd" |
2866 | ))] |
2867 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2868 | /// The implementation provides a C-language compilation environment with an |
2869 | /// `int` type using at least 32 bits and `long`, pointer, and `off_t` types |
2870 | /// using at least 64 bits. |
2871 | _POSIX_V6_LPBIG_OFFBIG = libc::_SC_V6_LPBIG_OFFBIG, |
2872 | /// The implementation supports the C-Language Binding option. |
2873 | #[cfg (not(any(target_os = "redox" , target_os = "haiku" )))] |
2874 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2875 | _POSIX2_C_BIND = libc::_SC_2_C_BIND, |
2876 | /// The implementation supports the C-Language Development Utilities option. |
2877 | #[cfg (not(any(target_os = "redox" , target_os = "haiku" )))] |
2878 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2879 | _POSIX2_C_DEV = libc::_SC_2_C_DEV, |
2880 | /// The implementation supports the Terminal Characteristics option. |
2881 | #[cfg (not(any(target_os = "redox" , target_os = "haiku" )))] |
2882 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2883 | _POSIX2_CHAR_TERM = libc::_SC_2_CHAR_TERM, |
2884 | /// The implementation supports the FORTRAN Development Utilities option. |
2885 | #[cfg (not(any(target_os = "redox" , target_os = "haiku" )))] |
2886 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2887 | _POSIX2_FORT_DEV = libc::_SC_2_FORT_DEV, |
2888 | /// The implementation supports the FORTRAN Runtime Utilities option. |
2889 | #[cfg (not(any(target_os = "redox" , target_os = "haiku" )))] |
2890 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2891 | _POSIX2_FORT_RUN = libc::_SC_2_FORT_RUN, |
2892 | /// The implementation supports the creation of locales by the localedef |
2893 | /// utility. |
2894 | #[cfg (not(any(target_os = "redox" , target_os = "haiku" )))] |
2895 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2896 | _POSIX2_LOCALEDEF = libc::_SC_2_LOCALEDEF, |
2897 | #[cfg (any( |
2898 | target_os = "dragonfly" , |
2899 | target_os = "freebsd" , |
2900 | target_os = "ios" , |
2901 | target_os = "linux" , |
2902 | target_os = "macos" , |
2903 | target_os = "netbsd" , |
2904 | target_os = "openbsd" |
2905 | ))] |
2906 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2907 | /// The implementation supports the Batch Environment Services and Utilities |
2908 | /// option. |
2909 | _POSIX2_PBS = libc::_SC_2_PBS, |
2910 | #[cfg (any( |
2911 | target_os = "dragonfly" , |
2912 | target_os = "freebsd" , |
2913 | target_os = "ios" , |
2914 | target_os = "linux" , |
2915 | target_os = "macos" , |
2916 | target_os = "netbsd" , |
2917 | target_os = "openbsd" |
2918 | ))] |
2919 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2920 | /// The implementation supports the Batch Accounting option. |
2921 | _POSIX2_PBS_ACCOUNTING = libc::_SC_2_PBS_ACCOUNTING, |
2922 | #[cfg (any( |
2923 | target_os = "dragonfly" , |
2924 | target_os = "freebsd" , |
2925 | target_os = "ios" , |
2926 | target_os = "linux" , |
2927 | target_os = "macos" , |
2928 | target_os = "netbsd" , |
2929 | target_os = "openbsd" |
2930 | ))] |
2931 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2932 | /// The implementation supports the Batch Checkpoint/Restart option. |
2933 | _POSIX2_PBS_CHECKPOINT = libc::_SC_2_PBS_CHECKPOINT, |
2934 | #[cfg (any( |
2935 | target_os = "dragonfly" , |
2936 | target_os = "freebsd" , |
2937 | target_os = "ios" , |
2938 | target_os = "linux" , |
2939 | target_os = "macos" , |
2940 | target_os = "netbsd" , |
2941 | target_os = "openbsd" |
2942 | ))] |
2943 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2944 | /// The implementation supports the Locate Batch Job Request option. |
2945 | _POSIX2_PBS_LOCATE = libc::_SC_2_PBS_LOCATE, |
2946 | #[cfg (any( |
2947 | target_os = "dragonfly" , |
2948 | target_os = "freebsd" , |
2949 | target_os = "ios" , |
2950 | target_os = "linux" , |
2951 | target_os = "macos" , |
2952 | target_os = "netbsd" , |
2953 | target_os = "openbsd" |
2954 | ))] |
2955 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2956 | /// The implementation supports the Batch Job Message Request option. |
2957 | _POSIX2_PBS_MESSAGE = libc::_SC_2_PBS_MESSAGE, |
2958 | #[cfg (any( |
2959 | target_os = "dragonfly" , |
2960 | target_os = "freebsd" , |
2961 | target_os = "ios" , |
2962 | target_os = "linux" , |
2963 | target_os = "macos" , |
2964 | target_os = "netbsd" , |
2965 | target_os = "openbsd" |
2966 | ))] |
2967 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2968 | /// The implementation supports the Track Batch Job Request option. |
2969 | _POSIX2_PBS_TRACK = libc::_SC_2_PBS_TRACK, |
2970 | /// The implementation supports the Software Development Utilities option. |
2971 | #[cfg (not(any(target_os = "redox" , target_os = "haiku" )))] |
2972 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2973 | _POSIX2_SW_DEV = libc::_SC_2_SW_DEV, |
2974 | /// The implementation supports the User Portability Utilities option. |
2975 | #[cfg (not(any(target_os = "redox" , target_os = "haiku" )))] |
2976 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2977 | _POSIX2_UPE = libc::_SC_2_UPE, |
2978 | /// Integer value indicating version of the Shell and Utilities volume of |
2979 | /// POSIX.1 to which the implementation conforms. |
2980 | #[cfg (not(any(target_os = "redox" , target_os = "haiku" )))] |
2981 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2982 | _POSIX2_VERSION = libc::_SC_2_VERSION, |
2983 | /// The size of a system page in bytes. |
2984 | /// |
2985 | /// POSIX also defines an alias named `PAGESIZE`, but Rust does not allow two |
2986 | /// enum constants to have the same value, so nix omits `PAGESIZE`. |
2987 | PAGE_SIZE = libc::_SC_PAGE_SIZE, |
2988 | #[cfg (not(any(target_os = "redox" , target_os = "haiku" )))] |
2989 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2990 | PTHREAD_DESTRUCTOR_ITERATIONS = libc::_SC_THREAD_DESTRUCTOR_ITERATIONS, |
2991 | #[cfg (not(any(target_os = "redox" , target_os = "haiku" )))] |
2992 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2993 | PTHREAD_KEYS_MAX = libc::_SC_THREAD_KEYS_MAX, |
2994 | #[cfg (not(target_os = "redox" ))] |
2995 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2996 | PTHREAD_STACK_MIN = libc::_SC_THREAD_STACK_MIN, |
2997 | #[cfg (not(any(target_os = "redox" , target_os = "haiku" )))] |
2998 | #[cfg_attr (docsrs, doc(cfg(all())))] |
2999 | PTHREAD_THREADS_MAX = libc::_SC_THREAD_THREADS_MAX, |
3000 | #[cfg (not(target_os = "haiku" ))] |
3001 | RE_DUP_MAX = libc::_SC_RE_DUP_MAX, |
3002 | #[cfg (any( |
3003 | target_os = "android" , |
3004 | target_os = "dragonfly" , |
3005 | target_os = "freebsd" , |
3006 | target_os = "ios" , |
3007 | target_os = "linux" , |
3008 | target_os = "macos" , |
3009 | target_os = "openbsd" |
3010 | ))] |
3011 | #[cfg_attr (docsrs, doc(cfg(all())))] |
3012 | RTSIG_MAX = libc::_SC_RTSIG_MAX, |
3013 | #[cfg (not(target_os = "redox" ))] |
3014 | #[cfg_attr (docsrs, doc(cfg(all())))] |
3015 | SEM_NSEMS_MAX = libc::_SC_SEM_NSEMS_MAX, |
3016 | #[cfg (any( |
3017 | target_os = "android" , |
3018 | target_os = "dragonfly" , |
3019 | target_os = "freebsd" , |
3020 | target_os = "ios" , |
3021 | target_os = "linux" , |
3022 | target_os = "macos" , |
3023 | target_os = "openbsd" |
3024 | ))] |
3025 | #[cfg_attr (docsrs, doc(cfg(all())))] |
3026 | SEM_VALUE_MAX = libc::_SC_SEM_VALUE_MAX, |
3027 | #[cfg (any( |
3028 | target_os = "android" , |
3029 | target_os = "dragonfly" , |
3030 | target_os = "freebsd" , |
3031 | target_os = "ios" , |
3032 | target_os = "linux" , |
3033 | target_os = "macos" , |
3034 | target_os = "openbsd" |
3035 | ))] |
3036 | #[cfg_attr (docsrs, doc(cfg(all())))] |
3037 | SIGQUEUE_MAX = libc::_SC_SIGQUEUE_MAX, |
3038 | STREAM_MAX = libc::_SC_STREAM_MAX, |
3039 | #[cfg (any( |
3040 | target_os = "dragonfly" , |
3041 | target_os = "freebsd" , |
3042 | target_os = "ios" , |
3043 | target_os = "linux" , |
3044 | target_os = "macos" , |
3045 | target_os = "netbsd" , |
3046 | target_os = "openbsd" |
3047 | ))] |
3048 | #[cfg_attr (docsrs, doc(cfg(all())))] |
3049 | SYMLOOP_MAX = libc::_SC_SYMLOOP_MAX, |
3050 | #[cfg (not(target_os = "redox" ))] |
3051 | #[cfg_attr (docsrs, doc(cfg(all())))] |
3052 | TIMER_MAX = libc::_SC_TIMER_MAX, |
3053 | TTY_NAME_MAX = libc::_SC_TTY_NAME_MAX, |
3054 | TZNAME_MAX = libc::_SC_TZNAME_MAX, |
3055 | #[cfg (any( |
3056 | target_os = "android" , |
3057 | target_os = "dragonfly" , |
3058 | target_os = "freebsd" , |
3059 | target_os = "ios" , |
3060 | target_os = "linux" , |
3061 | target_os = "macos" , |
3062 | target_os = "openbsd" |
3063 | ))] |
3064 | #[cfg_attr (docsrs, doc(cfg(all())))] |
3065 | /// The implementation supports the X/Open Encryption Option Group. |
3066 | _XOPEN_CRYPT = libc::_SC_XOPEN_CRYPT, |
3067 | #[cfg (any( |
3068 | target_os = "android" , |
3069 | target_os = "dragonfly" , |
3070 | target_os = "freebsd" , |
3071 | target_os = "ios" , |
3072 | target_os = "linux" , |
3073 | target_os = "macos" , |
3074 | target_os = "openbsd" |
3075 | ))] |
3076 | #[cfg_attr (docsrs, doc(cfg(all())))] |
3077 | /// The implementation supports the Issue 4, Version 2 Enhanced |
3078 | /// Internationalization Option Group. |
3079 | _XOPEN_ENH_I18N = libc::_SC_XOPEN_ENH_I18N, |
3080 | #[cfg (any( |
3081 | target_os = "android" , |
3082 | target_os = "dragonfly" , |
3083 | target_os = "freebsd" , |
3084 | target_os = "ios" , |
3085 | target_os = "linux" , |
3086 | target_os = "macos" , |
3087 | target_os = "openbsd" |
3088 | ))] |
3089 | #[cfg_attr (docsrs, doc(cfg(all())))] |
3090 | _XOPEN_LEGACY = libc::_SC_XOPEN_LEGACY, |
3091 | #[cfg (any( |
3092 | target_os = "android" , |
3093 | target_os = "dragonfly" , |
3094 | target_os = "freebsd" , |
3095 | target_os = "ios" , |
3096 | target_os = "linux" , |
3097 | target_os = "macos" , |
3098 | target_os = "openbsd" |
3099 | ))] |
3100 | #[cfg_attr (docsrs, doc(cfg(all())))] |
3101 | /// The implementation supports the X/Open Realtime Option Group. |
3102 | _XOPEN_REALTIME = libc::_SC_XOPEN_REALTIME, |
3103 | #[cfg (any( |
3104 | target_os = "android" , |
3105 | target_os = "dragonfly" , |
3106 | target_os = "freebsd" , |
3107 | target_os = "ios" , |
3108 | target_os = "linux" , |
3109 | target_os = "macos" , |
3110 | target_os = "openbsd" |
3111 | ))] |
3112 | #[cfg_attr (docsrs, doc(cfg(all())))] |
3113 | /// The implementation supports the X/Open Realtime Threads Option Group. |
3114 | _XOPEN_REALTIME_THREADS = libc::_SC_XOPEN_REALTIME_THREADS, |
3115 | /// The implementation supports the Issue 4, Version 2 Shared Memory Option |
3116 | /// Group. |
3117 | #[cfg (not(any(target_os = "redox" , target_os = "haiku" )))] |
3118 | #[cfg_attr (docsrs, doc(cfg(all())))] |
3119 | _XOPEN_SHM = libc::_SC_XOPEN_SHM, |
3120 | #[cfg (any( |
3121 | target_os = "dragonfly" , |
3122 | target_os = "freebsd" , |
3123 | target_os = "ios" , |
3124 | target_os = "linux" , |
3125 | target_os = "macos" , |
3126 | target_os = "openbsd" |
3127 | ))] |
3128 | #[cfg_attr (docsrs, doc(cfg(all())))] |
3129 | /// The implementation supports the XSI STREAMS Option Group. |
3130 | _XOPEN_STREAMS = libc::_SC_XOPEN_STREAMS, |
3131 | #[cfg (any( |
3132 | target_os = "android" , |
3133 | target_os = "dragonfly" , |
3134 | target_os = "freebsd" , |
3135 | target_os = "ios" , |
3136 | target_os = "linux" , |
3137 | target_os = "macos" , |
3138 | target_os = "openbsd" |
3139 | ))] |
3140 | #[cfg_attr (docsrs, doc(cfg(all())))] |
3141 | /// The implementation supports the XSI option |
3142 | _XOPEN_UNIX = libc::_SC_XOPEN_UNIX, |
3143 | #[cfg (any( |
3144 | target_os = "android" , |
3145 | target_os = "dragonfly" , |
3146 | target_os = "freebsd" , |
3147 | target_os = "ios" , |
3148 | target_os = "linux" , |
3149 | target_os = "macos" , |
3150 | target_os = "openbsd" |
3151 | ))] |
3152 | #[cfg_attr (docsrs, doc(cfg(all())))] |
3153 | /// Integer value indicating version of the X/Open Portability Guide to |
3154 | /// which the implementation conforms. |
3155 | _XOPEN_VERSION = libc::_SC_XOPEN_VERSION, |
3156 | /// The number of pages of physical memory. Note that it is possible for |
3157 | /// the product of this value to overflow. |
3158 | #[cfg (any(target_os = "android" , target_os = "linux" ))] |
3159 | _PHYS_PAGES = libc::_SC_PHYS_PAGES, |
3160 | /// The number of currently available pages of physical memory. |
3161 | #[cfg (any(target_os = "android" , target_os = "linux" ))] |
3162 | _AVPHYS_PAGES = libc::_SC_AVPHYS_PAGES, |
3163 | /// The number of processors configured. |
3164 | #[cfg (any(target_os = "android" , target_os = "linux" ))] |
3165 | _NPROCESSORS_CONF = libc::_SC_NPROCESSORS_CONF, |
3166 | /// The number of processors currently online (available). |
3167 | #[cfg (any(target_os = "android" , target_os = "linux" ))] |
3168 | _NPROCESSORS_ONLN = libc::_SC_NPROCESSORS_ONLN, |
3169 | } |
3170 | |
3171 | /// Get configurable system variables (see |
3172 | /// [sysconf(3)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/sysconf.html)) |
3173 | /// |
3174 | /// Returns the value of a configurable system variable. Most supported |
3175 | /// variables also have associated compile-time constants, but POSIX |
3176 | /// allows their values to change at runtime. There are generally two types of |
3177 | /// sysconf variables: options and limits. See sysconf(3) for more details. |
3178 | /// |
3179 | /// # Returns |
3180 | /// |
3181 | /// - `Ok(Some(x))`: the variable's limit (for limit variables) or its |
3182 | /// implementation level (for option variables). Implementation levels are |
3183 | /// usually a decimal-coded date, such as 200112 for POSIX 2001.12 |
3184 | /// - `Ok(None)`: the variable has no limit (for limit variables) or is |
3185 | /// unsupported (for option variables) |
3186 | /// - `Err(x)`: an error occurred |
3187 | pub fn sysconf(var: SysconfVar) -> Result<Option<c_long>> { |
3188 | let raw = unsafe { |
3189 | Errno::clear(); |
3190 | libc::sysconf(var as c_int) |
3191 | }; |
3192 | if raw == -1 { |
3193 | if errno::errno() == 0 { |
3194 | Ok(None) |
3195 | } else { |
3196 | Err(Errno::last()) |
3197 | } |
3198 | } else { |
3199 | Ok(Some(raw)) |
3200 | } |
3201 | } |
3202 | } |
3203 | |
3204 | #[cfg (any(target_os = "android" , target_os = "linux" ))] |
3205 | #[cfg (feature = "fs" )] |
3206 | mod pivot_root { |
3207 | use crate::errno::Errno; |
3208 | use crate::{NixPath, Result}; |
3209 | |
3210 | pub fn pivot_root<P1: ?Sized + NixPath, P2: ?Sized + NixPath>( |
3211 | new_root: &P1, |
3212 | put_old: &P2, |
3213 | ) -> Result<()> { |
3214 | let res: i64 = new_root.with_nix_path(|new_root: &CStr| { |
3215 | put_old.with_nix_path(|put_old: &CStr| unsafe { |
3216 | libc::syscall( |
3217 | num:libc::SYS_pivot_root, |
3218 | new_root.as_ptr(), |
3219 | put_old.as_ptr(), |
3220 | ) |
3221 | }) |
3222 | })??; |
3223 | |
3224 | Errno::result(res).map(op:drop) |
3225 | } |
3226 | } |
3227 | |
3228 | #[cfg (any( |
3229 | target_os = "android" , |
3230 | target_os = "dragonfly" , |
3231 | target_os = "freebsd" , |
3232 | target_os = "linux" , |
3233 | target_os = "openbsd" |
3234 | ))] |
3235 | mod setres { |
3236 | feature! { |
3237 | #![feature = "user" ] |
3238 | |
3239 | use super::{Gid, Uid}; |
3240 | use crate::errno::Errno; |
3241 | use crate::Result; |
3242 | |
3243 | /// Sets the real, effective, and saved uid. |
3244 | /// ([see setresuid(2)](https://man7.org/linux/man-pages/man2/setresuid.2.html)) |
3245 | /// |
3246 | /// * `ruid`: real user id |
3247 | /// * `euid`: effective user id |
3248 | /// * `suid`: saved user id |
3249 | /// * returns: Ok or libc error code. |
3250 | /// |
3251 | /// Err is returned if the user doesn't have permission to set this UID. |
3252 | #[inline ] |
3253 | pub fn setresuid(ruid: Uid, euid: Uid, suid: Uid) -> Result<()> { |
3254 | let res = |
3255 | unsafe { libc::setresuid(ruid.into(), euid.into(), suid.into()) }; |
3256 | |
3257 | Errno::result(res).map(drop) |
3258 | } |
3259 | |
3260 | /// Sets the real, effective, and saved gid. |
3261 | /// ([see setresuid(2)](https://man7.org/linux/man-pages/man2/setresuid.2.html)) |
3262 | /// |
3263 | /// * `rgid`: real group id |
3264 | /// * `egid`: effective group id |
3265 | /// * `sgid`: saved group id |
3266 | /// * returns: Ok or libc error code. |
3267 | /// |
3268 | /// Err is returned if the user doesn't have permission to set this GID. |
3269 | #[inline ] |
3270 | pub fn setresgid(rgid: Gid, egid: Gid, sgid: Gid) -> Result<()> { |
3271 | let res = |
3272 | unsafe { libc::setresgid(rgid.into(), egid.into(), sgid.into()) }; |
3273 | |
3274 | Errno::result(res).map(drop) |
3275 | } |
3276 | } |
3277 | } |
3278 | |
3279 | #[cfg (any( |
3280 | target_os = "android" , |
3281 | target_os = "dragonfly" , |
3282 | target_os = "freebsd" , |
3283 | target_os = "linux" , |
3284 | target_os = "openbsd" |
3285 | ))] |
3286 | mod getres { |
3287 | feature! { |
3288 | #![feature = "user" ] |
3289 | |
3290 | use super::{Gid, Uid}; |
3291 | use crate::errno::Errno; |
3292 | use crate::Result; |
3293 | |
3294 | /// Real, effective and saved user IDs. |
3295 | #[derive (Debug, Copy, Clone, Eq, PartialEq)] |
3296 | pub struct ResUid { |
3297 | pub real: Uid, |
3298 | pub effective: Uid, |
3299 | pub saved: Uid, |
3300 | } |
3301 | |
3302 | /// Real, effective and saved group IDs. |
3303 | #[derive (Debug, Copy, Clone, Eq, PartialEq)] |
3304 | pub struct ResGid { |
3305 | pub real: Gid, |
3306 | pub effective: Gid, |
3307 | pub saved: Gid, |
3308 | } |
3309 | |
3310 | /// Gets the real, effective, and saved user IDs. |
3311 | /// |
3312 | /// ([see getresuid(2)](http://man7.org/linux/man-pages/man2/getresuid.2.html)) |
3313 | /// |
3314 | /// #Returns |
3315 | /// |
3316 | /// - `Ok((Uid, Uid, Uid))`: tuple of real, effective and saved uids on success. |
3317 | /// - `Err(x)`: libc error code on failure. |
3318 | /// |
3319 | #[inline ] |
3320 | pub fn getresuid() -> Result<ResUid> { |
3321 | let mut ruid = libc::uid_t::max_value(); |
3322 | let mut euid = libc::uid_t::max_value(); |
3323 | let mut suid = libc::uid_t::max_value(); |
3324 | let res = unsafe { libc::getresuid(&mut ruid, &mut euid, &mut suid) }; |
3325 | |
3326 | Errno::result(res).map(|_| ResUid { |
3327 | real: Uid(ruid), |
3328 | effective: Uid(euid), |
3329 | saved: Uid(suid), |
3330 | }) |
3331 | } |
3332 | |
3333 | /// Gets the real, effective, and saved group IDs. |
3334 | /// |
3335 | /// ([see getresgid(2)](http://man7.org/linux/man-pages/man2/getresgid.2.html)) |
3336 | /// |
3337 | /// #Returns |
3338 | /// |
3339 | /// - `Ok((Gid, Gid, Gid))`: tuple of real, effective and saved gids on success. |
3340 | /// - `Err(x)`: libc error code on failure. |
3341 | /// |
3342 | #[inline ] |
3343 | pub fn getresgid() -> Result<ResGid> { |
3344 | let mut rgid = libc::gid_t::max_value(); |
3345 | let mut egid = libc::gid_t::max_value(); |
3346 | let mut sgid = libc::gid_t::max_value(); |
3347 | let res = unsafe { libc::getresgid(&mut rgid, &mut egid, &mut sgid) }; |
3348 | |
3349 | Errno::result(res).map(|_| ResGid { |
3350 | real: Gid(rgid), |
3351 | effective: Gid(egid), |
3352 | saved: Gid(sgid), |
3353 | }) |
3354 | } |
3355 | } |
3356 | } |
3357 | |
3358 | #[cfg (feature = "fs" )] |
3359 | libc_bitflags! { |
3360 | /// Options for access() |
3361 | #[cfg_attr (docsrs, doc(cfg(feature = "fs" )))] |
3362 | pub struct AccessFlags : c_int { |
3363 | /// Test for existence of file. |
3364 | F_OK; |
3365 | /// Test for read permission. |
3366 | R_OK; |
3367 | /// Test for write permission. |
3368 | W_OK; |
3369 | /// Test for execute (search) permission. |
3370 | X_OK; |
3371 | } |
3372 | } |
3373 | |
3374 | feature! { |
3375 | #![feature = "fs" ] |
3376 | |
3377 | /// Checks the file named by `path` for accessibility according to the flags given by `amode` |
3378 | /// See [access(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/access.html) |
3379 | pub fn access<P: ?Sized + NixPath>(path: &P, amode: AccessFlags) -> Result<()> { |
3380 | let res = path.with_nix_path(|cstr| unsafe { |
3381 | libc::access(cstr.as_ptr(), amode.bits()) |
3382 | })?; |
3383 | Errno::result(res).map(drop) |
3384 | } |
3385 | |
3386 | /// Checks the file named by `path` for accessibility according to the flags given by `mode` |
3387 | /// |
3388 | /// If `dirfd` has a value, then `path` is relative to directory associated with the file descriptor. |
3389 | /// |
3390 | /// If `dirfd` is `None`, then `path` is relative to the current working directory. |
3391 | /// |
3392 | /// # References |
3393 | /// |
3394 | /// [faccessat(2)](http://pubs.opengroup.org/onlinepubs/9699919799/functions/faccessat.html) |
3395 | // redox: does not appear to support the *at family of syscalls. |
3396 | #[cfg (not(target_os = "redox" ))] |
3397 | pub fn faccessat<P: ?Sized + NixPath>( |
3398 | dirfd: Option<RawFd>, |
3399 | path: &P, |
3400 | mode: AccessFlags, |
3401 | flags: AtFlags, |
3402 | ) -> Result<()> { |
3403 | let res = path.with_nix_path(|cstr| unsafe { |
3404 | libc::faccessat( |
3405 | at_rawfd(dirfd), |
3406 | cstr.as_ptr(), |
3407 | mode.bits(), |
3408 | flags.bits(), |
3409 | ) |
3410 | })?; |
3411 | Errno::result(res).map(drop) |
3412 | } |
3413 | |
3414 | /// Checks the file named by `path` for accessibility according to the flags given |
3415 | /// by `mode` using effective UID, effective GID and supplementary group lists. |
3416 | /// |
3417 | /// # References |
3418 | /// |
3419 | /// * [FreeBSD man page](https://www.freebsd.org/cgi/man.cgi?query=eaccess&sektion=2&n=1) |
3420 | /// * [Linux man page](https://man7.org/linux/man-pages/man3/euidaccess.3.html) |
3421 | #[cfg (any( |
3422 | all(target_os = "linux" , not(target_env = "uclibc" )), |
3423 | target_os = "freebsd" , |
3424 | target_os = "dragonfly" |
3425 | ))] |
3426 | pub fn eaccess<P: ?Sized + NixPath>(path: &P, mode: AccessFlags) -> Result<()> { |
3427 | let res = path.with_nix_path(|cstr| unsafe { |
3428 | libc::eaccess(cstr.as_ptr(), mode.bits()) |
3429 | })?; |
3430 | Errno::result(res).map(drop) |
3431 | } |
3432 | } |
3433 | |
3434 | feature! { |
3435 | #![feature = "user" ] |
3436 | |
3437 | /// Representation of a User, based on `libc::passwd` |
3438 | /// |
3439 | /// The reason some fields in this struct are `String` and others are `CString` is because some |
3440 | /// fields are based on the user's locale, which could be non-UTF8, while other fields are |
3441 | /// guaranteed to conform to [`NAME_REGEX`](https://serverfault.com/a/73101/407341), which only |
3442 | /// contains ASCII. |
3443 | #[cfg (not(target_os = "redox" ))] // RedoxFS does not support passwd |
3444 | #[derive (Debug, Clone, Eq, PartialEq)] |
3445 | pub struct User { |
3446 | /// Username |
3447 | pub name: String, |
3448 | /// User password (probably hashed) |
3449 | pub passwd: CString, |
3450 | /// User ID |
3451 | pub uid: Uid, |
3452 | /// Group ID |
3453 | pub gid: Gid, |
3454 | /// User information |
3455 | #[cfg (not(all(target_os = "android" , target_pointer_width = "32" )))] |
3456 | pub gecos: CString, |
3457 | /// Home directory |
3458 | pub dir: PathBuf, |
3459 | /// Path to shell |
3460 | pub shell: PathBuf, |
3461 | /// Login class |
3462 | #[cfg (not(any( |
3463 | target_os = "aix" , |
3464 | target_os = "android" , |
3465 | target_os = "fuchsia" , |
3466 | target_os = "haiku" , |
3467 | target_os = "illumos" , |
3468 | target_os = "linux" , |
3469 | target_os = "solaris" |
3470 | )))] |
3471 | #[cfg_attr (docsrs, doc(cfg(all())))] |
3472 | pub class: CString, |
3473 | /// Last password change |
3474 | #[cfg (not(any( |
3475 | target_os = "aix" , |
3476 | target_os = "android" , |
3477 | target_os = "fuchsia" , |
3478 | target_os = "haiku" , |
3479 | target_os = "illumos" , |
3480 | target_os = "linux" , |
3481 | target_os = "solaris" |
3482 | )))] |
3483 | #[cfg_attr (docsrs, doc(cfg(all())))] |
3484 | pub change: libc::time_t, |
3485 | /// Expiration time of account |
3486 | #[cfg (not(any( |
3487 | target_os = "aix" , |
3488 | target_os = "android" , |
3489 | target_os = "fuchsia" , |
3490 | target_os = "haiku" , |
3491 | target_os = "illumos" , |
3492 | target_os = "linux" , |
3493 | target_os = "solaris" |
3494 | )))] |
3495 | #[cfg_attr (docsrs, doc(cfg(all())))] |
3496 | pub expire: libc::time_t, |
3497 | } |
3498 | |
3499 | #[cfg (not(target_os = "redox" ))] //RedoxFS does not support passwd |
3500 | impl From<&libc::passwd> for User { |
3501 | fn from(pw: &libc::passwd) -> User { |
3502 | unsafe { |
3503 | User { |
3504 | name: if pw.pw_name.is_null() { |
3505 | Default::default() |
3506 | } else { |
3507 | CStr::from_ptr(pw.pw_name).to_string_lossy().into_owned() |
3508 | }, |
3509 | passwd: if pw.pw_passwd.is_null() { |
3510 | Default::default() |
3511 | } else { |
3512 | CString::new(CStr::from_ptr(pw.pw_passwd).to_bytes()) |
3513 | .unwrap() |
3514 | }, |
3515 | #[cfg (not(all( |
3516 | target_os = "android" , |
3517 | target_pointer_width = "32" |
3518 | )))] |
3519 | gecos: if pw.pw_gecos.is_null() { |
3520 | Default::default() |
3521 | } else { |
3522 | CString::new(CStr::from_ptr(pw.pw_gecos).to_bytes()) |
3523 | .unwrap() |
3524 | }, |
3525 | dir: if pw.pw_dir.is_null() { |
3526 | Default::default() |
3527 | } else { |
3528 | PathBuf::from(OsStr::from_bytes( |
3529 | CStr::from_ptr(pw.pw_dir).to_bytes(), |
3530 | )) |
3531 | }, |
3532 | shell: if pw.pw_shell.is_null() { |
3533 | Default::default() |
3534 | } else { |
3535 | PathBuf::from(OsStr::from_bytes( |
3536 | CStr::from_ptr(pw.pw_shell).to_bytes(), |
3537 | )) |
3538 | }, |
3539 | uid: Uid::from_raw(pw.pw_uid), |
3540 | gid: Gid::from_raw(pw.pw_gid), |
3541 | #[cfg (not(any( |
3542 | target_os = "aix" , |
3543 | target_os = "android" , |
3544 | target_os = "fuchsia" , |
3545 | target_os = "haiku" , |
3546 | target_os = "illumos" , |
3547 | target_os = "linux" , |
3548 | target_os = "solaris" |
3549 | )))] |
3550 | class: CString::new(CStr::from_ptr(pw.pw_class).to_bytes()) |
3551 | .unwrap(), |
3552 | #[cfg (not(any( |
3553 | target_os = "aix" , |
3554 | target_os = "android" , |
3555 | target_os = "fuchsia" , |
3556 | target_os = "haiku" , |
3557 | target_os = "illumos" , |
3558 | target_os = "linux" , |
3559 | target_os = "solaris" |
3560 | )))] |
3561 | change: pw.pw_change, |
3562 | #[cfg (not(any( |
3563 | target_os = "aix" , |
3564 | target_os = "android" , |
3565 | target_os = "fuchsia" , |
3566 | target_os = "haiku" , |
3567 | target_os = "illumos" , |
3568 | target_os = "linux" , |
3569 | target_os = "solaris" |
3570 | )))] |
3571 | expire: pw.pw_expire, |
3572 | } |
3573 | } |
3574 | } |
3575 | } |
3576 | |
3577 | #[cfg (not(target_os = "redox" ))] // RedoxFS does not support passwd |
3578 | impl From<User> for libc::passwd { |
3579 | fn from(u: User) -> Self { |
3580 | let name = match CString::new(u.name) { |
3581 | Ok(n) => n.into_raw(), |
3582 | Err(_) => CString::new("" ).unwrap().into_raw(), |
3583 | }; |
3584 | let dir = match u.dir.into_os_string().into_string() { |
3585 | Ok(s) => CString::new(s.as_str()).unwrap().into_raw(), |
3586 | Err(_) => CString::new("" ).unwrap().into_raw(), |
3587 | }; |
3588 | let shell = match u.shell.into_os_string().into_string() { |
3589 | Ok(s) => CString::new(s.as_str()).unwrap().into_raw(), |
3590 | Err(_) => CString::new("" ).unwrap().into_raw(), |
3591 | }; |
3592 | Self { |
3593 | pw_name: name, |
3594 | pw_passwd: u.passwd.into_raw(), |
3595 | #[cfg (not(all( |
3596 | target_os = "android" , |
3597 | target_pointer_width = "32" |
3598 | )))] |
3599 | pw_gecos: u.gecos.into_raw(), |
3600 | pw_dir: dir, |
3601 | pw_shell: shell, |
3602 | pw_uid: u.uid.0, |
3603 | pw_gid: u.gid.0, |
3604 | #[cfg (not(any( |
3605 | target_os = "aix" , |
3606 | target_os = "android" , |
3607 | target_os = "fuchsia" , |
3608 | target_os = "haiku" , |
3609 | target_os = "illumos" , |
3610 | target_os = "linux" , |
3611 | target_os = "solaris" |
3612 | )))] |
3613 | pw_class: u.class.into_raw(), |
3614 | #[cfg (not(any( |
3615 | target_os = "aix" , |
3616 | target_os = "android" , |
3617 | target_os = "fuchsia" , |
3618 | target_os = "haiku" , |
3619 | target_os = "illumos" , |
3620 | target_os = "linux" , |
3621 | target_os = "solaris" |
3622 | )))] |
3623 | pw_change: u.change, |
3624 | #[cfg (not(any( |
3625 | target_os = "aix" , |
3626 | target_os = "android" , |
3627 | target_os = "fuchsia" , |
3628 | target_os = "haiku" , |
3629 | target_os = "illumos" , |
3630 | target_os = "linux" , |
3631 | target_os = "solaris" |
3632 | )))] |
3633 | pw_expire: u.expire, |
3634 | #[cfg (target_os = "illumos" )] |
3635 | pw_age: CString::new("" ).unwrap().into_raw(), |
3636 | #[cfg (target_os = "illumos" )] |
3637 | pw_comment: CString::new("" ).unwrap().into_raw(), |
3638 | #[cfg (any(target_os = "dragonfly" , target_os = "freebsd" ))] |
3639 | pw_fields: 0, |
3640 | } |
3641 | } |
3642 | } |
3643 | |
3644 | #[cfg (not(target_os = "redox" ))] // RedoxFS does not support passwd |
3645 | impl User { |
3646 | /// # Safety |
3647 | /// |
3648 | /// If `f` writes to its `*mut *mut libc::passwd` parameter, then it must |
3649 | /// also initialize the value pointed to by its `*mut libc::group` |
3650 | /// parameter. |
3651 | unsafe fn from_anything<F>(f: F) -> Result<Option<Self>> |
3652 | where |
3653 | F: Fn( |
3654 | *mut libc::passwd, |
3655 | *mut c_char, |
3656 | libc::size_t, |
3657 | *mut *mut libc::passwd, |
3658 | ) -> libc::c_int, |
3659 | { |
3660 | let buflimit = 1048576; |
3661 | let bufsize = match sysconf(SysconfVar::GETPW_R_SIZE_MAX) { |
3662 | Ok(Some(n)) => n as usize, |
3663 | Ok(None) | Err(_) => 16384, |
3664 | }; |
3665 | |
3666 | let mut cbuf = Vec::with_capacity(bufsize); |
3667 | let mut pwd = mem::MaybeUninit::<libc::passwd>::uninit(); |
3668 | let mut res = ptr::null_mut(); |
3669 | |
3670 | loop { |
3671 | let error = f( |
3672 | pwd.as_mut_ptr(), |
3673 | cbuf.as_mut_ptr(), |
3674 | cbuf.capacity(), |
3675 | &mut res, |
3676 | ); |
3677 | if error == 0 { |
3678 | if res.is_null() { |
3679 | return Ok(None); |
3680 | } else { |
3681 | // SAFETY: `f` guarantees that `pwd` is initialized if `res` |
3682 | // is not null. |
3683 | let pwd = pwd.assume_init(); |
3684 | return Ok(Some(User::from(&pwd))); |
3685 | } |
3686 | } else if Errno::last() == Errno::ERANGE { |
3687 | // Trigger the internal buffer resizing logic. |
3688 | reserve_double_buffer_size(&mut cbuf, buflimit)?; |
3689 | } else { |
3690 | return Err(Errno::last()); |
3691 | } |
3692 | } |
3693 | } |
3694 | |
3695 | /// Get a user by UID. |
3696 | /// |
3697 | /// Internally, this function calls |
3698 | /// [getpwuid_r(3)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/getpwuid_r.html) |
3699 | /// |
3700 | /// # Examples |
3701 | /// |
3702 | /// ``` |
3703 | /// use nix::unistd::{Uid, User}; |
3704 | /// // Returns an Result<Option<User>>, thus the double unwrap. |
3705 | /// let res = User::from_uid(Uid::from_raw(0)).unwrap().unwrap(); |
3706 | /// assert_eq!(res.name, "root"); |
3707 | /// ``` |
3708 | pub fn from_uid(uid: Uid) -> Result<Option<Self>> { |
3709 | // SAFETY: `getpwuid_r` will write to `res` if it initializes the value |
3710 | // at `pwd`. |
3711 | unsafe { |
3712 | User::from_anything(|pwd, cbuf, cap, res| { |
3713 | libc::getpwuid_r(uid.0, pwd, cbuf, cap, res) |
3714 | }) |
3715 | } |
3716 | } |
3717 | |
3718 | /// Get a user by name. |
3719 | /// |
3720 | /// Internally, this function calls |
3721 | /// [getpwnam_r(3)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/getpwnam_r.html) |
3722 | /// |
3723 | /// # Examples |
3724 | /// |
3725 | /// ``` |
3726 | /// use nix::unistd::User; |
3727 | /// // Returns an Result<Option<User>>, thus the double unwrap. |
3728 | /// let res = User::from_name("root").unwrap().unwrap(); |
3729 | /// assert_eq!(res.name, "root"); |
3730 | /// ``` |
3731 | pub fn from_name(name: &str) -> Result<Option<Self>> { |
3732 | let name = match CString::new(name) { |
3733 | Ok(c_str) => c_str, |
3734 | Err(_nul_error) => return Ok(None), |
3735 | }; |
3736 | // SAFETY: `getpwnam_r` will write to `res` if it initializes the value |
3737 | // at `pwd`. |
3738 | unsafe { |
3739 | User::from_anything(|pwd, cbuf, cap, res| { |
3740 | libc::getpwnam_r(name.as_ptr(), pwd, cbuf, cap, res) |
3741 | }) |
3742 | } |
3743 | } |
3744 | } |
3745 | |
3746 | /// Representation of a Group, based on `libc::group` |
3747 | #[cfg (not(target_os = "redox" ))] // RedoxFS does not support passwd |
3748 | #[derive (Debug, Clone, Eq, PartialEq)] |
3749 | pub struct Group { |
3750 | /// Group name |
3751 | pub name: String, |
3752 | /// Group password |
3753 | pub passwd: CString, |
3754 | /// Group ID |
3755 | pub gid: Gid, |
3756 | /// List of Group members |
3757 | pub mem: Vec<String>, |
3758 | } |
3759 | |
3760 | #[cfg (not(target_os = "redox" ))] // RedoxFS does not support passwd |
3761 | impl From<&libc::group> for Group { |
3762 | fn from(gr: &libc::group) -> Group { |
3763 | unsafe { |
3764 | Group { |
3765 | name: if gr.gr_name.is_null() { |
3766 | Default::default() |
3767 | } else { |
3768 | CStr::from_ptr(gr.gr_name).to_string_lossy().into_owned() |
3769 | }, |
3770 | passwd: if gr.gr_passwd.is_null() { |
3771 | Default::default() |
3772 | } else { |
3773 | CString::new(CStr::from_ptr(gr.gr_passwd).to_bytes()) |
3774 | .unwrap() |
3775 | }, |
3776 | gid: Gid::from_raw(gr.gr_gid), |
3777 | mem: if gr.gr_mem.is_null() { |
3778 | Default::default() |
3779 | } else { |
3780 | Group::members(gr.gr_mem) |
3781 | }, |
3782 | } |
3783 | } |
3784 | } |
3785 | } |
3786 | |
3787 | #[cfg (not(target_os = "redox" ))] // RedoxFS does not support passwd |
3788 | impl Group { |
3789 | unsafe fn members(mem: *mut *mut c_char) -> Vec<String> { |
3790 | let mut ret = Vec::new(); |
3791 | |
3792 | for i in 0.. { |
3793 | let u = mem.offset(i); |
3794 | if (*u).is_null() { |
3795 | break; |
3796 | } else { |
3797 | let s = CStr::from_ptr(*u).to_string_lossy().into_owned(); |
3798 | ret.push(s); |
3799 | } |
3800 | } |
3801 | |
3802 | ret |
3803 | } |
3804 | |
3805 | /// # Safety |
3806 | /// |
3807 | /// If `f` writes to its `*mut *mut libc::group` parameter, then it must |
3808 | /// also initialize the value pointed to by its `*mut libc::group` |
3809 | /// parameter. |
3810 | unsafe fn from_anything<F>(f: F) -> Result<Option<Self>> |
3811 | where |
3812 | F: Fn( |
3813 | *mut libc::group, |
3814 | *mut c_char, |
3815 | libc::size_t, |
3816 | *mut *mut libc::group, |
3817 | ) -> libc::c_int, |
3818 | { |
3819 | let buflimit = 1048576; |
3820 | let bufsize = match sysconf(SysconfVar::GETGR_R_SIZE_MAX) { |
3821 | Ok(Some(n)) => n as usize, |
3822 | Ok(None) | Err(_) => 16384, |
3823 | }; |
3824 | |
3825 | let mut cbuf = Vec::with_capacity(bufsize); |
3826 | let mut grp = mem::MaybeUninit::<libc::group>::uninit(); |
3827 | let mut res = ptr::null_mut(); |
3828 | |
3829 | loop { |
3830 | let error = f( |
3831 | grp.as_mut_ptr(), |
3832 | cbuf.as_mut_ptr(), |
3833 | cbuf.capacity(), |
3834 | &mut res, |
3835 | ); |
3836 | if error == 0 { |
3837 | if res.is_null() { |
3838 | return Ok(None); |
3839 | } else { |
3840 | // SAFETY: `f` guarantees that `grp` is initialized if `res` |
3841 | // is not null. |
3842 | let grp = grp.assume_init(); |
3843 | return Ok(Some(Group::from(&grp))); |
3844 | } |
3845 | } else if Errno::last() == Errno::ERANGE { |
3846 | // Trigger the internal buffer resizing logic. |
3847 | reserve_double_buffer_size(&mut cbuf, buflimit)?; |
3848 | } else { |
3849 | return Err(Errno::last()); |
3850 | } |
3851 | } |
3852 | } |
3853 | |
3854 | /// Get a group by GID. |
3855 | /// |
3856 | /// Internally, this function calls |
3857 | /// [getgrgid_r(3)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/getpwuid_r.html) |
3858 | /// |
3859 | /// # Examples |
3860 | /// |
3861 | // Disable this test on all OS except Linux as root group may not exist. |
3862 | #[cfg_attr (not(target_os = "linux" ), doc = " ```no_run" )] |
3863 | #[cfg_attr (target_os = "linux" , doc = " ```" )] |
3864 | /// use nix::unistd::{Gid, Group}; |
3865 | /// // Returns an Result<Option<Group>>, thus the double unwrap. |
3866 | /// let res = Group::from_gid(Gid::from_raw(0)).unwrap().unwrap(); |
3867 | /// assert!(res.name == "root"); |
3868 | /// ``` |
3869 | pub fn from_gid(gid: Gid) -> Result<Option<Self>> { |
3870 | // SAFETY: `getgrgid_r` will write to `res` if it initializes the value |
3871 | // at `grp`. |
3872 | unsafe { |
3873 | Group::from_anything(|grp, cbuf, cap, res| { |
3874 | libc::getgrgid_r(gid.0, grp, cbuf, cap, res) |
3875 | }) |
3876 | } |
3877 | } |
3878 | |
3879 | /// Get a group by name. |
3880 | /// |
3881 | /// Internally, this function calls |
3882 | /// [getgrnam_r(3)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/getpwuid_r.html) |
3883 | /// |
3884 | /// # Examples |
3885 | /// |
3886 | // Disable this test on all OS except Linux as root group may not exist. |
3887 | #[cfg_attr (not(target_os = "linux" ), doc = " ```no_run" )] |
3888 | #[cfg_attr (target_os = "linux" , doc = " ```" )] |
3889 | /// use nix::unistd::Group; |
3890 | /// // Returns an Result<Option<Group>>, thus the double unwrap. |
3891 | /// let res = Group::from_name("root").unwrap().unwrap(); |
3892 | /// assert!(res.name == "root"); |
3893 | /// ``` |
3894 | pub fn from_name(name: &str) -> Result<Option<Self>> { |
3895 | let name = match CString::new(name) { |
3896 | Ok(c_str) => c_str, |
3897 | Err(_nul_error) => return Ok(None), |
3898 | }; |
3899 | // SAFETY: `getgrnam_r` will write to `res` if it initializes the value |
3900 | // at `grp`. |
3901 | unsafe { |
3902 | Group::from_anything(|grp, cbuf, cap, res| { |
3903 | libc::getgrnam_r(name.as_ptr(), grp, cbuf, cap, res) |
3904 | }) |
3905 | } |
3906 | } |
3907 | } |
3908 | } |
3909 | |
3910 | feature! { |
3911 | #![feature = "term" ] |
3912 | |
3913 | /// Get the name of the terminal device that is open on file descriptor fd |
3914 | /// (see [`ttyname(3)`](https://man7.org/linux/man-pages/man3/ttyname.3.html)). |
3915 | #[cfg (not(target_os = "fuchsia" ))] |
3916 | pub fn ttyname(fd: RawFd) -> Result<PathBuf> { |
3917 | const PATH_MAX: usize = libc::PATH_MAX as usize; |
3918 | let mut buf = vec![0_u8; PATH_MAX]; |
3919 | let c_buf = buf.as_mut_ptr() as *mut libc::c_char; |
3920 | |
3921 | let ret = unsafe { libc::ttyname_r(fd, c_buf, buf.len()) }; |
3922 | if ret != 0 { |
3923 | return Err(Errno::from_i32(ret)); |
3924 | } |
3925 | |
3926 | let nul = buf.iter().position(|c| *c == b' \0' ).unwrap(); |
3927 | buf.truncate(nul); |
3928 | Ok(OsString::from_vec(buf).into()) |
3929 | } |
3930 | } |
3931 | |
3932 | feature! { |
3933 | #![all(feature = "socket" , feature = "user" )] |
3934 | |
3935 | /// Get the effective user ID and group ID associated with a Unix domain socket. |
3936 | /// |
3937 | /// See also [getpeereid(3)](https://www.freebsd.org/cgi/man.cgi?query=getpeereid) |
3938 | #[cfg (any( |
3939 | target_os = "macos" , |
3940 | target_os = "ios" , |
3941 | target_os = "freebsd" , |
3942 | target_os = "openbsd" , |
3943 | target_os = "netbsd" , |
3944 | target_os = "dragonfly" , |
3945 | ))] |
3946 | pub fn getpeereid(fd: RawFd) -> Result<(Uid, Gid)> { |
3947 | let mut uid = 1; |
3948 | let mut gid = 1; |
3949 | |
3950 | let ret = unsafe { libc::getpeereid(fd, &mut uid, &mut gid) }; |
3951 | |
3952 | Errno::result(ret).map(|_| (Uid(uid), Gid(gid))) |
3953 | } |
3954 | } |
3955 | |
3956 | feature! { |
3957 | #![all(feature = "fs" )] |
3958 | |
3959 | /// Set the file flags. |
3960 | /// |
3961 | /// See also [chflags(2)](https://www.freebsd.org/cgi/man.cgi?query=chflags&sektion=2) |
3962 | #[cfg (any( |
3963 | target_os = "openbsd" , |
3964 | target_os = "netbsd" , |
3965 | target_os = "freebsd" , |
3966 | target_os = "dragonfly" , |
3967 | target_os = "macos" , |
3968 | target_os = "ios" |
3969 | ))] |
3970 | pub fn chflags<P: ?Sized + NixPath>(path: &P, flags: FileFlag) -> Result<()> { |
3971 | let res = path.with_nix_path(|cstr| unsafe { |
3972 | libc::chflags(cstr.as_ptr(), flags.bits()) |
3973 | })?; |
3974 | |
3975 | Errno::result(res).map(drop) |
3976 | } |
3977 | } |
3978 | |