1#![unstable(reason = "not public", issue = "none", feature = "fd")]
2
3#[cfg(test)]
4mod tests;
5
6#[cfg(not(any(
7 target_os = "linux",
8 target_os = "l4re",
9 target_os = "android",
10 target_os = "hurd",
11)))]
12use libc::off_t as off64_t;
13#[cfg(any(
14 target_os = "android",
15 target_os = "linux",
16 target_os = "l4re",
17 target_os = "hurd",
18))]
19use libc::off64_t;
20
21use crate::cmp;
22use crate::io::{self, BorrowedCursor, IoSlice, IoSliceMut, Read};
23use crate::os::unix::io::{AsFd, AsRawFd, BorrowedFd, FromRawFd, IntoRawFd, OwnedFd, RawFd};
24use crate::sys::cvt;
25#[cfg(all(target_os = "android", target_pointer_width = "64"))]
26use crate::sys::pal::weak::syscall;
27#[cfg(any(all(target_os = "android", target_pointer_width = "32"), target_vendor = "apple"))]
28use crate::sys::pal::weak::weak;
29use crate::sys_common::{AsInner, FromInner, IntoInner};
30
31#[derive(Debug)]
32pub struct FileDesc(OwnedFd);
33
34// The maximum read limit on most POSIX-like systems is `SSIZE_MAX`,
35// with the man page quoting that if the count of bytes to read is
36// greater than `SSIZE_MAX` the result is "unspecified".
37//
38// On Apple targets however, apparently the 64-bit libc is either buggy or
39// intentionally showing odd behavior by rejecting any read with a size
40// larger than or equal to INT_MAX. To handle both of these the read
41// size is capped on both platforms.
42const READ_LIMIT: usize = if cfg!(target_vendor = "apple") {
43 libc::c_int::MAX as usize - 1
44} else {
45 libc::ssize_t::MAX as usize
46};
47
48#[cfg(any(
49 target_os = "dragonfly",
50 target_os = "freebsd",
51 target_os = "netbsd",
52 target_os = "openbsd",
53 target_vendor = "apple",
54 target_os = "cygwin",
55))]
56const fn max_iov() -> usize {
57 libc::IOV_MAX as usize
58}
59
60#[cfg(any(
61 target_os = "android",
62 target_os = "emscripten",
63 target_os = "linux",
64 target_os = "nto",
65))]
66const fn max_iov() -> usize {
67 libc::UIO_MAXIOV as usize
68}
69
70#[cfg(not(any(
71 target_os = "android",
72 target_os = "dragonfly",
73 target_os = "emscripten",
74 target_os = "espidf",
75 target_os = "freebsd",
76 target_os = "linux",
77 target_os = "netbsd",
78 target_os = "nuttx",
79 target_os = "nto",
80 target_os = "openbsd",
81 target_os = "horizon",
82 target_os = "vita",
83 target_vendor = "apple",
84 target_os = "cygwin",
85)))]
86const fn max_iov() -> usize {
87 16 // The minimum value required by POSIX.
88}
89
90impl FileDesc {
91 #[inline]
92 pub fn try_clone(&self) -> io::Result<Self> {
93 self.duplicate()
94 }
95
96 pub fn read(&self, buf: &mut [u8]) -> io::Result<usize> {
97 let ret = cvt(unsafe {
98 libc::read(
99 self.as_raw_fd(),
100 buf.as_mut_ptr() as *mut libc::c_void,
101 cmp::min(buf.len(), READ_LIMIT),
102 )
103 })?;
104 Ok(ret as usize)
105 }
106
107 #[cfg(not(any(
108 target_os = "espidf",
109 target_os = "horizon",
110 target_os = "vita",
111 target_os = "nuttx"
112 )))]
113 pub fn read_vectored(&self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
114 let ret = cvt(unsafe {
115 libc::readv(
116 self.as_raw_fd(),
117 bufs.as_mut_ptr() as *mut libc::iovec as *const libc::iovec,
118 cmp::min(bufs.len(), max_iov()) as libc::c_int,
119 )
120 })?;
121 Ok(ret as usize)
122 }
123
124 #[cfg(any(
125 target_os = "espidf",
126 target_os = "horizon",
127 target_os = "vita",
128 target_os = "nuttx"
129 ))]
130 pub fn read_vectored(&self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
131 io::default_read_vectored(|b| self.read(b), bufs)
132 }
133
134 #[inline]
135 pub fn is_read_vectored(&self) -> bool {
136 cfg!(not(any(
137 target_os = "espidf",
138 target_os = "horizon",
139 target_os = "vita",
140 target_os = "nuttx"
141 )))
142 }
143
144 pub fn read_to_end(&self, buf: &mut Vec<u8>) -> io::Result<usize> {
145 let mut me = self;
146 (&mut me).read_to_end(buf)
147 }
148
149 #[cfg_attr(target_os = "vxworks", allow(unused_unsafe))]
150 pub fn read_at(&self, buf: &mut [u8], offset: u64) -> io::Result<usize> {
151 #[cfg(not(any(
152 all(target_os = "linux", not(target_env = "musl")),
153 target_os = "android",
154 target_os = "hurd"
155 )))]
156 use libc::pread as pread64;
157 #[cfg(any(
158 all(target_os = "linux", not(target_env = "musl")),
159 target_os = "android",
160 target_os = "hurd"
161 ))]
162 use libc::pread64;
163
164 unsafe {
165 cvt(pread64(
166 self.as_raw_fd(),
167 buf.as_mut_ptr() as *mut libc::c_void,
168 cmp::min(buf.len(), READ_LIMIT),
169 offset as off64_t,
170 ))
171 .map(|n| n as usize)
172 }
173 }
174
175 pub fn read_buf(&self, mut cursor: BorrowedCursor<'_>) -> io::Result<()> {
176 let ret = cvt(unsafe {
177 libc::read(
178 self.as_raw_fd(),
179 cursor.as_mut().as_mut_ptr() as *mut libc::c_void,
180 cmp::min(cursor.capacity(), READ_LIMIT),
181 )
182 })?;
183
184 // Safety: `ret` bytes were written to the initialized portion of the buffer
185 unsafe {
186 cursor.advance_unchecked(ret as usize);
187 }
188 Ok(())
189 }
190
191 #[cfg(any(
192 target_os = "aix",
193 target_os = "dragonfly", // DragonFly 1.5
194 target_os = "emscripten",
195 target_os = "freebsd",
196 target_os = "fuchsia",
197 target_os = "hurd",
198 target_os = "illumos",
199 target_os = "linux",
200 target_os = "netbsd",
201 target_os = "openbsd", // OpenBSD 2.7
202 ))]
203 pub fn read_vectored_at(&self, bufs: &mut [IoSliceMut<'_>], offset: u64) -> io::Result<usize> {
204 let ret = cvt(unsafe {
205 libc::preadv(
206 self.as_raw_fd(),
207 bufs.as_mut_ptr() as *mut libc::iovec as *const libc::iovec,
208 cmp::min(bufs.len(), max_iov()) as libc::c_int,
209 offset as _,
210 )
211 })?;
212 Ok(ret as usize)
213 }
214
215 #[cfg(not(any(
216 target_os = "aix",
217 target_os = "android",
218 target_os = "dragonfly",
219 target_os = "emscripten",
220 target_os = "freebsd",
221 target_os = "fuchsia",
222 target_os = "hurd",
223 target_os = "illumos",
224 target_os = "linux",
225 target_os = "netbsd",
226 target_os = "openbsd",
227 target_vendor = "apple",
228 )))]
229 pub fn read_vectored_at(&self, bufs: &mut [IoSliceMut<'_>], offset: u64) -> io::Result<usize> {
230 io::default_read_vectored(|b| self.read_at(b, offset), bufs)
231 }
232
233 // We support some old Android versions that do not have `preadv` in libc,
234 // so we use weak linkage and fallback to a direct syscall if not available.
235 //
236 // On 32-bit targets, we don't want to deal with weird ABI issues around
237 // passing 64-bits parameters to syscalls, so we fallback to the default
238 // implementation if `preadv` is not available.
239 #[cfg(all(target_os = "android", target_pointer_width = "64"))]
240 pub fn read_vectored_at(&self, bufs: &mut [IoSliceMut<'_>], offset: u64) -> io::Result<usize> {
241 syscall!(
242 fn preadv(
243 fd: libc::c_int,
244 iovec: *const libc::iovec,
245 n_iovec: libc::c_int,
246 offset: off64_t,
247 ) -> isize;
248 );
249
250 let ret = cvt(unsafe {
251 preadv(
252 self.as_raw_fd(),
253 bufs.as_mut_ptr() as *mut libc::iovec as *const libc::iovec,
254 cmp::min(bufs.len(), max_iov()) as libc::c_int,
255 offset as _,
256 )
257 })?;
258 Ok(ret as usize)
259 }
260
261 #[cfg(all(target_os = "android", target_pointer_width = "32"))]
262 pub fn read_vectored_at(&self, bufs: &mut [IoSliceMut<'_>], offset: u64) -> io::Result<usize> {
263 weak!(
264 fn preadv64(
265 fd: libc::c_int,
266 iovec: *const libc::iovec,
267 n_iovec: libc::c_int,
268 offset: off64_t,
269 ) -> isize;
270 );
271
272 match preadv64.get() {
273 Some(preadv) => {
274 let ret = cvt(unsafe {
275 preadv(
276 self.as_raw_fd(),
277 bufs.as_mut_ptr() as *mut libc::iovec as *const libc::iovec,
278 cmp::min(bufs.len(), max_iov()) as libc::c_int,
279 offset as _,
280 )
281 })?;
282 Ok(ret as usize)
283 }
284 None => io::default_read_vectored(|b| self.read_at(b, offset), bufs),
285 }
286 }
287
288 // We support old MacOS, iOS, watchOS, tvOS and visionOS. `preadv` was added in the following
289 // Apple OS versions:
290 // ios 14.0
291 // tvos 14.0
292 // macos 11.0
293 // watchos 7.0
294 //
295 // These versions may be newer than the minimum supported versions of OS's we support so we must
296 // use "weak" linking.
297 #[cfg(target_vendor = "apple")]
298 pub fn read_vectored_at(&self, bufs: &mut [IoSliceMut<'_>], offset: u64) -> io::Result<usize> {
299 weak!(
300 fn preadv(
301 fd: libc::c_int,
302 iovec: *const libc::iovec,
303 n_iovec: libc::c_int,
304 offset: off64_t,
305 ) -> isize;
306 );
307
308 match preadv.get() {
309 Some(preadv) => {
310 let ret = cvt(unsafe {
311 preadv(
312 self.as_raw_fd(),
313 bufs.as_mut_ptr() as *mut libc::iovec as *const libc::iovec,
314 cmp::min(bufs.len(), max_iov()) as libc::c_int,
315 offset as _,
316 )
317 })?;
318 Ok(ret as usize)
319 }
320 None => io::default_read_vectored(|b| self.read_at(b, offset), bufs),
321 }
322 }
323
324 pub fn write(&self, buf: &[u8]) -> io::Result<usize> {
325 let ret = cvt(unsafe {
326 libc::write(
327 self.as_raw_fd(),
328 buf.as_ptr() as *const libc::c_void,
329 cmp::min(buf.len(), READ_LIMIT),
330 )
331 })?;
332 Ok(ret as usize)
333 }
334
335 #[cfg(not(any(
336 target_os = "espidf",
337 target_os = "horizon",
338 target_os = "vita",
339 target_os = "nuttx"
340 )))]
341 pub fn write_vectored(&self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
342 let ret = cvt(unsafe {
343 libc::writev(
344 self.as_raw_fd(),
345 bufs.as_ptr() as *const libc::iovec,
346 cmp::min(bufs.len(), max_iov()) as libc::c_int,
347 )
348 })?;
349 Ok(ret as usize)
350 }
351
352 #[cfg(any(
353 target_os = "espidf",
354 target_os = "horizon",
355 target_os = "vita",
356 target_os = "nuttx"
357 ))]
358 pub fn write_vectored(&self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
359 io::default_write_vectored(|b| self.write(b), bufs)
360 }
361
362 #[inline]
363 pub fn is_write_vectored(&self) -> bool {
364 cfg!(not(any(
365 target_os = "espidf",
366 target_os = "horizon",
367 target_os = "vita",
368 target_os = "nuttx"
369 )))
370 }
371
372 #[cfg_attr(target_os = "vxworks", allow(unused_unsafe))]
373 pub fn write_at(&self, buf: &[u8], offset: u64) -> io::Result<usize> {
374 #[cfg(not(any(
375 all(target_os = "linux", not(target_env = "musl")),
376 target_os = "android",
377 target_os = "hurd"
378 )))]
379 use libc::pwrite as pwrite64;
380 #[cfg(any(
381 all(target_os = "linux", not(target_env = "musl")),
382 target_os = "android",
383 target_os = "hurd"
384 ))]
385 use libc::pwrite64;
386
387 unsafe {
388 cvt(pwrite64(
389 self.as_raw_fd(),
390 buf.as_ptr() as *const libc::c_void,
391 cmp::min(buf.len(), READ_LIMIT),
392 offset as off64_t,
393 ))
394 .map(|n| n as usize)
395 }
396 }
397
398 #[cfg(any(
399 target_os = "aix",
400 target_os = "dragonfly", // DragonFly 1.5
401 target_os = "emscripten",
402 target_os = "freebsd",
403 target_os = "fuchsia",
404 target_os = "hurd",
405 target_os = "illumos",
406 target_os = "linux",
407 target_os = "netbsd",
408 target_os = "openbsd", // OpenBSD 2.7
409 ))]
410 pub fn write_vectored_at(&self, bufs: &[IoSlice<'_>], offset: u64) -> io::Result<usize> {
411 let ret = cvt(unsafe {
412 libc::pwritev(
413 self.as_raw_fd(),
414 bufs.as_ptr() as *const libc::iovec,
415 cmp::min(bufs.len(), max_iov()) as libc::c_int,
416 offset as _,
417 )
418 })?;
419 Ok(ret as usize)
420 }
421
422 #[cfg(not(any(
423 target_os = "aix",
424 target_os = "android",
425 target_os = "dragonfly",
426 target_os = "emscripten",
427 target_os = "freebsd",
428 target_os = "fuchsia",
429 target_os = "hurd",
430 target_os = "illumos",
431 target_os = "linux",
432 target_os = "netbsd",
433 target_os = "openbsd",
434 target_vendor = "apple",
435 )))]
436 pub fn write_vectored_at(&self, bufs: &[IoSlice<'_>], offset: u64) -> io::Result<usize> {
437 io::default_write_vectored(|b| self.write_at(b, offset), bufs)
438 }
439
440 // We support some old Android versions that do not have `pwritev` in libc,
441 // so we use weak linkage and fallback to a direct syscall if not available.
442 //
443 // On 32-bit targets, we don't want to deal with weird ABI issues around
444 // passing 64-bits parameters to syscalls, so we fallback to the default
445 // implementation if `pwritev` is not available.
446 #[cfg(all(target_os = "android", target_pointer_width = "64"))]
447 pub fn write_vectored_at(&self, bufs: &[IoSlice<'_>], offset: u64) -> io::Result<usize> {
448 syscall!(
449 fn pwritev(
450 fd: libc::c_int,
451 iovec: *const libc::iovec,
452 n_iovec: libc::c_int,
453 offset: off64_t,
454 ) -> isize;
455 );
456
457 let ret = cvt(unsafe {
458 pwritev(
459 self.as_raw_fd(),
460 bufs.as_ptr() as *const libc::iovec,
461 cmp::min(bufs.len(), max_iov()) as libc::c_int,
462 offset as _,
463 )
464 })?;
465 Ok(ret as usize)
466 }
467
468 #[cfg(all(target_os = "android", target_pointer_width = "32"))]
469 pub fn write_vectored_at(&self, bufs: &[IoSlice<'_>], offset: u64) -> io::Result<usize> {
470 weak!(
471 fn pwritev64(
472 fd: libc::c_int,
473 iovec: *const libc::iovec,
474 n_iovec: libc::c_int,
475 offset: off64_t,
476 ) -> isize;
477 );
478
479 match pwritev64.get() {
480 Some(pwritev) => {
481 let ret = cvt(unsafe {
482 pwritev(
483 self.as_raw_fd(),
484 bufs.as_ptr() as *const libc::iovec,
485 cmp::min(bufs.len(), max_iov()) as libc::c_int,
486 offset as _,
487 )
488 })?;
489 Ok(ret as usize)
490 }
491 None => io::default_write_vectored(|b| self.write_at(b, offset), bufs),
492 }
493 }
494
495 // We support old MacOS, iOS, watchOS, tvOS and visionOS. `pwritev` was added in the following
496 // Apple OS versions:
497 // ios 14.0
498 // tvos 14.0
499 // macos 11.0
500 // watchos 7.0
501 //
502 // These versions may be newer than the minimum supported versions of OS's we support so we must
503 // use "weak" linking.
504 #[cfg(target_vendor = "apple")]
505 pub fn write_vectored_at(&self, bufs: &[IoSlice<'_>], offset: u64) -> io::Result<usize> {
506 weak!(
507 fn pwritev(
508 fd: libc::c_int,
509 iovec: *const libc::iovec,
510 n_iovec: libc::c_int,
511 offset: off64_t,
512 ) -> isize;
513 );
514
515 match pwritev.get() {
516 Some(pwritev) => {
517 let ret = cvt(unsafe {
518 pwritev(
519 self.as_raw_fd(),
520 bufs.as_ptr() as *const libc::iovec,
521 cmp::min(bufs.len(), max_iov()) as libc::c_int,
522 offset as _,
523 )
524 })?;
525 Ok(ret as usize)
526 }
527 None => io::default_write_vectored(|b| self.write_at(b, offset), bufs),
528 }
529 }
530
531 #[cfg(not(any(
532 target_env = "newlib",
533 target_os = "solaris",
534 target_os = "illumos",
535 target_os = "emscripten",
536 target_os = "fuchsia",
537 target_os = "l4re",
538 target_os = "linux",
539 target_os = "cygwin",
540 target_os = "haiku",
541 target_os = "redox",
542 target_os = "vxworks",
543 target_os = "nto",
544 )))]
545 pub fn set_cloexec(&self) -> io::Result<()> {
546 unsafe {
547 cvt(libc::ioctl(self.as_raw_fd(), libc::FIOCLEX))?;
548 Ok(())
549 }
550 }
551 #[cfg(any(
552 all(
553 target_env = "newlib",
554 not(any(target_os = "espidf", target_os = "horizon", target_os = "vita"))
555 ),
556 target_os = "solaris",
557 target_os = "illumos",
558 target_os = "emscripten",
559 target_os = "fuchsia",
560 target_os = "l4re",
561 target_os = "linux",
562 target_os = "cygwin",
563 target_os = "haiku",
564 target_os = "redox",
565 target_os = "vxworks",
566 target_os = "nto",
567 ))]
568 pub fn set_cloexec(&self) -> io::Result<()> {
569 unsafe {
570 let previous = cvt(libc::fcntl(self.as_raw_fd(), libc::F_GETFD))?;
571 let new = previous | libc::FD_CLOEXEC;
572 if new != previous {
573 cvt(libc::fcntl(self.as_raw_fd(), libc::F_SETFD, new))?;
574 }
575 Ok(())
576 }
577 }
578 #[cfg(any(target_os = "espidf", target_os = "horizon", target_os = "vita"))]
579 pub fn set_cloexec(&self) -> io::Result<()> {
580 // FD_CLOEXEC is not supported in ESP-IDF, Horizon OS and Vita but there's no need to,
581 // because none of them supports spawning processes.
582 Ok(())
583 }
584
585 #[cfg(target_os = "linux")]
586 pub fn set_nonblocking(&self, nonblocking: bool) -> io::Result<()> {
587 unsafe {
588 let v = nonblocking as libc::c_int;
589 cvt(libc::ioctl(self.as_raw_fd(), libc::FIONBIO, &v))?;
590 Ok(())
591 }
592 }
593
594 #[cfg(not(target_os = "linux"))]
595 pub fn set_nonblocking(&self, nonblocking: bool) -> io::Result<()> {
596 unsafe {
597 let previous = cvt(libc::fcntl(self.as_raw_fd(), libc::F_GETFL))?;
598 let new = if nonblocking {
599 previous | libc::O_NONBLOCK
600 } else {
601 previous & !libc::O_NONBLOCK
602 };
603 if new != previous {
604 cvt(libc::fcntl(self.as_raw_fd(), libc::F_SETFL, new))?;
605 }
606 Ok(())
607 }
608 }
609
610 #[inline]
611 pub fn duplicate(&self) -> io::Result<FileDesc> {
612 Ok(Self(self.0.try_clone()?))
613 }
614}
615
616impl<'a> Read for &'a FileDesc {
617 fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
618 (**self).read(buf)
619 }
620
621 fn read_buf(&mut self, cursor: BorrowedCursor<'_>) -> io::Result<()> {
622 (**self).read_buf(cursor)
623 }
624
625 fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
626 (**self).read_vectored(bufs)
627 }
628
629 #[inline]
630 fn is_read_vectored(&self) -> bool {
631 (**self).is_read_vectored()
632 }
633}
634
635impl AsInner<OwnedFd> for FileDesc {
636 #[inline]
637 fn as_inner(&self) -> &OwnedFd {
638 &self.0
639 }
640}
641
642impl IntoInner<OwnedFd> for FileDesc {
643 fn into_inner(self) -> OwnedFd {
644 self.0
645 }
646}
647
648impl FromInner<OwnedFd> for FileDesc {
649 fn from_inner(owned_fd: OwnedFd) -> Self {
650 Self(owned_fd)
651 }
652}
653
654impl AsFd for FileDesc {
655 fn as_fd(&self) -> BorrowedFd<'_> {
656 self.0.as_fd()
657 }
658}
659
660impl AsRawFd for FileDesc {
661 #[inline]
662 fn as_raw_fd(&self) -> RawFd {
663 self.0.as_raw_fd()
664 }
665}
666
667impl IntoRawFd for FileDesc {
668 fn into_raw_fd(self) -> RawFd {
669 self.0.into_raw_fd()
670 }
671}
672
673impl FromRawFd for FileDesc {
674 unsafe fn from_raw_fd(raw_fd: RawFd) -> Self {
675 Self(unsafe { FromRawFd::from_raw_fd(raw_fd) })
676 }
677}
678