1#![stable(feature = "io_safety", since = "1.63.0")]
4#![deny(unsafe_op_in_unsafe_fn)]
5
6#[cfg(target_os = "motor")]
7use moto_rt::libc;
8
9use super::raw::{AsRawFd, FromRawFd, IntoRawFd, RawFd};
10use crate::alloc::Allocator;
11#[cfg(not(target_os = "trusty"))]
12use crate::fs;
13use crate::marker::PhantomData;
14use crate::mem::ManuallyDrop;
15#[cfg(not(any(
16 all(target_family = "wasm", not(target_os = "emscripten")),
17 target_env = "sgx",
18 target_os = "hermit",
19 target_os = "trusty",
20 target_os = "motor"
21)))]
22use crate::sys::cvt;
23#[cfg(not(target_os = "trusty"))]
24use crate::sys::{AsInner, FromInner, IntoInner};
25use crate::{fmt, io};
26
27type ValidRawFd = core::num::niche_types::NotAllOnes<RawFd>;
28
29#[derive(Copy, Clone)]
49#[repr(transparent)]
50#[rustc_nonnull_optimization_guaranteed]
51#[stable(feature = "io_safety", since = "1.63.0")]
52pub struct BorrowedFd<'fd> {
53 fd: ValidRawFd,
54 _phantom: PhantomData<&'fd OwnedFd>,
55}
56
57#[repr(transparent)]
69#[rustc_nonnull_optimization_guaranteed]
70#[stable(feature = "io_safety", since = "1.63.0")]
71pub struct OwnedFd {
72 fd: ValidRawFd,
73}
74
75impl BorrowedFd<'_> {
76 #[inline]
87 #[track_caller]
88 #[rustc_const_stable(feature = "io_safety", since = "1.63.0")]
89 #[stable(feature = "io_safety", since = "1.63.0")]
90 pub const unsafe fn borrow_raw(fd: RawFd) -> Self {
91 Self { fd: ValidRawFd::new(fd).expect("fd != -1"), _phantom: PhantomData }
92 }
93
94 #[cfg_attr(all(unix, not(miri)), doc = "```")]
97 #[cfg_attr(not(unix), doc = "```ignore (needs unix)")]
98 #[unstable(feature = "fd_view", issue = "160402")]
108 pub fn to_view<T>(&self) -> &T
109 where
110 Self: AsRef<T>,
111 {
112 self.as_ref()
113 }
114}
115
116impl OwnedFd {
117 #[stable(feature = "io_safety", since = "1.63.0")]
120 pub fn try_clone(&self) -> io::Result<Self> {
121 self.as_fd().try_clone_to_owned()
122 }
123}
124
125impl BorrowedFd<'_> {
126 #[cfg(not(any(
129 all(target_family = "wasm", not(target_os = "emscripten")),
130 target_os = "hermit",
131 target_os = "trusty",
132 target_os = "motor"
133 )))]
134 #[stable(feature = "io_safety", since = "1.63.0")]
135 pub fn try_clone_to_owned(&self) -> io::Result<OwnedFd> {
136 #[cfg(not(any(target_os = "espidf", target_os = "vita")))]
140 let cmd = libc::F_DUPFD_CLOEXEC;
141
142 #[cfg(any(target_os = "espidf", target_os = "vita"))]
147 let cmd = libc::F_DUPFD;
148
149 let fd = cvt(unsafe { libc::fcntl(self.as_raw_fd(), cmd, 3) })?;
151 Ok(unsafe { OwnedFd::from_raw_fd(fd) })
152 }
153
154 #[cfg(any(
157 all(target_family = "wasm", not(target_os = "emscripten")),
158 target_os = "hermit",
159 target_os = "trusty"
160 ))]
161 #[stable(feature = "io_safety", since = "1.63.0")]
162 pub fn try_clone_to_owned(&self) -> io::Result<OwnedFd> {
163 Err(io::Error::UNSUPPORTED_PLATFORM)
164 }
165
166 #[cfg(target_os = "motor")]
169 #[stable(feature = "io_safety", since = "1.63.0")]
170 pub fn try_clone_to_owned(&self) -> io::Result<OwnedFd> {
171 let fd = moto_rt::fs::duplicate(self.as_raw_fd()).map_err(crate::sys::map_motor_error)?;
172 Ok(unsafe { OwnedFd::from_raw_fd(fd) })
173 }
174}
175
176#[stable(feature = "io_safety", since = "1.63.0")]
177impl AsRawFd for BorrowedFd<'_> {
178 #[inline]
179 fn as_raw_fd(&self) -> RawFd {
180 self.fd.as_inner()
181 }
182}
183
184#[stable(feature = "io_safety", since = "1.63.0")]
185impl AsRawFd for OwnedFd {
186 #[inline]
187 fn as_raw_fd(&self) -> RawFd {
188 self.fd.as_inner()
189 }
190}
191
192#[stable(feature = "io_safety", since = "1.63.0")]
193impl IntoRawFd for OwnedFd {
194 #[inline]
195 fn into_raw_fd(self) -> RawFd {
196 ManuallyDrop::new(self).fd.as_inner()
197 }
198}
199
200#[stable(feature = "io_safety", since = "1.63.0")]
201impl FromRawFd for OwnedFd {
202 #[inline]
215 #[track_caller]
216 unsafe fn from_raw_fd(fd: RawFd) -> Self {
217 Self { fd: ValidRawFd::new(fd).expect("fd != -1") }
218 }
219}
220
221#[stable(feature = "io_safety", since = "1.63.0")]
222impl Drop for OwnedFd {
223 #[inline]
224 fn drop(&mut self) {
225 unsafe {
226 #[cfg(not(target_os = "hermit"))]
238 {
239 #[cfg(unix)]
240 crate::sys::fs::debug_assert_fd_is_open(self.fd.as_inner());
241
242 let _ = libc::close(self.fd.as_inner());
243 }
244 #[cfg(target_os = "hermit")]
245 let _ = hermit_abi::close(self.fd.as_inner());
246 }
247 }
248}
249
250#[stable(feature = "io_safety", since = "1.63.0")]
251impl fmt::Debug for BorrowedFd<'_> {
252 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
253 f.debug_struct("BorrowedFd").field("fd", &self.fd).finish()
254 }
255}
256
257#[stable(feature = "io_safety", since = "1.63.0")]
258impl fmt::Debug for OwnedFd {
259 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
260 f.debug_struct("OwnedFd").field("fd", &self.fd).finish()
261 }
262}
263
264macro_rules! impl_is_terminal {
265 ($($t:ty),*$(,)?) => {$(
266 #[stable(feature = "is_terminal", since = "1.70.0")]
267 impl io::IsTerminal for $t {
268 #[inline]
269 fn is_terminal(&self) -> bool {
270 crate::sys::io::is_terminal(self)
271 }
272 }
273 )*}
274}
275
276impl_is_terminal!(BorrowedFd<'_>, OwnedFd);
277
278#[stable(feature = "io_safety", since = "1.63.0")]
284pub trait AsFd {
285 #[stable(feature = "io_safety", since = "1.63.0")]
301 fn as_fd(&self) -> BorrowedFd<'_>;
302}
303
304#[stable(feature = "io_safety", since = "1.63.0")]
305impl<T: AsFd + ?Sized> AsFd for &T {
306 #[inline]
307 fn as_fd(&self) -> BorrowedFd<'_> {
308 T::as_fd(self)
309 }
310}
311
312#[stable(feature = "io_safety", since = "1.63.0")]
313impl<T: AsFd + ?Sized> AsFd for &mut T {
314 #[inline]
315 fn as_fd(&self) -> BorrowedFd<'_> {
316 T::as_fd(self)
317 }
318}
319
320#[stable(feature = "io_safety", since = "1.63.0")]
321impl AsFd for BorrowedFd<'_> {
322 #[inline]
323 fn as_fd(&self) -> BorrowedFd<'_> {
324 *self
325 }
326}
327
328#[stable(feature = "io_safety", since = "1.63.0")]
329impl AsFd for OwnedFd {
330 #[inline]
331 fn as_fd(&self) -> BorrowedFd<'_> {
332 unsafe { BorrowedFd::borrow_raw(self.as_raw_fd()) }
336 }
337}
338
339#[stable(feature = "io_safety", since = "1.63.0")]
340#[cfg(not(target_os = "trusty"))]
341impl AsFd for fs::File {
342 #[inline]
343 fn as_fd(&self) -> BorrowedFd<'_> {
344 self.as_inner().as_fd()
345 }
346}
347
348#[stable(feature = "io_safety", since = "1.63.0")]
349#[cfg(not(target_os = "trusty"))]
350impl From<fs::File> for OwnedFd {
351 #[inline]
353 fn from(file: fs::File) -> OwnedFd {
354 file.into_inner().into_inner().into_inner()
355 }
356}
357
358#[stable(feature = "io_safety", since = "1.63.0")]
359#[cfg(not(target_os = "trusty"))]
360impl From<OwnedFd> for fs::File {
361 #[inline]
364 fn from(owned_fd: OwnedFd) -> Self {
365 Self::from_inner(FromInner::from_inner(FromInner::from_inner(owned_fd)))
366 }
367}
368
369#[stable(feature = "io_safety", since = "1.63.0")]
370#[cfg(not(target_os = "trusty"))]
371impl AsFd for crate::net::TcpStream {
372 #[inline]
373 fn as_fd(&self) -> BorrowedFd<'_> {
374 self.as_inner().socket().as_fd()
375 }
376}
377
378#[stable(feature = "io_safety", since = "1.63.0")]
379#[cfg(not(target_os = "trusty"))]
380impl From<crate::net::TcpStream> for OwnedFd {
381 #[inline]
383 fn from(tcp_stream: crate::net::TcpStream) -> OwnedFd {
384 tcp_stream.into_inner().into_socket().into_inner().into_inner()
385 }
386}
387
388#[stable(feature = "io_safety", since = "1.63.0")]
389#[cfg(not(target_os = "trusty"))]
390impl From<OwnedFd> for crate::net::TcpStream {
391 #[inline]
392 fn from(owned_fd: OwnedFd) -> Self {
393 Self::from_inner(FromInner::from_inner(FromInner::from_inner(FromInner::from_inner(
394 owned_fd,
395 ))))
396 }
397}
398
399#[stable(feature = "io_safety", since = "1.63.0")]
400#[cfg(not(target_os = "trusty"))]
401impl AsFd for crate::net::TcpListener {
402 #[inline]
403 fn as_fd(&self) -> BorrowedFd<'_> {
404 self.as_inner().socket().as_fd()
405 }
406}
407
408#[stable(feature = "io_safety", since = "1.63.0")]
409#[cfg(not(target_os = "trusty"))]
410impl From<crate::net::TcpListener> for OwnedFd {
411 #[inline]
413 fn from(tcp_listener: crate::net::TcpListener) -> OwnedFd {
414 tcp_listener.into_inner().into_socket().into_inner().into_inner()
415 }
416}
417
418#[stable(feature = "io_safety", since = "1.63.0")]
419#[cfg(not(target_os = "trusty"))]
420impl From<OwnedFd> for crate::net::TcpListener {
421 #[inline]
422 fn from(owned_fd: OwnedFd) -> Self {
423 Self::from_inner(FromInner::from_inner(FromInner::from_inner(FromInner::from_inner(
424 owned_fd,
425 ))))
426 }
427}
428
429#[stable(feature = "io_safety", since = "1.63.0")]
430#[cfg(not(target_os = "trusty"))]
431impl AsFd for crate::net::UdpSocket {
432 #[inline]
433 fn as_fd(&self) -> BorrowedFd<'_> {
434 self.as_inner().socket().as_fd()
435 }
436}
437
438#[stable(feature = "io_safety", since = "1.63.0")]
439#[cfg(not(target_os = "trusty"))]
440impl From<crate::net::UdpSocket> for OwnedFd {
441 #[inline]
443 fn from(udp_socket: crate::net::UdpSocket) -> OwnedFd {
444 udp_socket.into_inner().into_socket().into_inner().into_inner()
445 }
446}
447
448#[stable(feature = "io_safety", since = "1.63.0")]
449#[cfg(not(target_os = "trusty"))]
450impl From<OwnedFd> for crate::net::UdpSocket {
451 #[inline]
452 fn from(owned_fd: OwnedFd) -> Self {
453 Self::from_inner(FromInner::from_inner(FromInner::from_inner(FromInner::from_inner(
454 owned_fd,
455 ))))
456 }
457}
458
459pub(crate) macro unsafe_impl_fd_asrefs {
475 ($($t:ty),*$(,)?) => {$(
476 #[unstable(feature = "fd_view", issue = "160402")]
477 #[unstable_feature_bound(fd_view)]
478 impl AsRef<$t> for BorrowedFd<'_> {
479 #[inline]
480 fn as_ref(&self) -> &$t {
481 use core::mem;
482
483 fn type_check<T: From<OwnedFd> + Into<OwnedFd> + AsFd>() {}
486
487 const {
489 assert!(mem::size_of::<RawFd>() == mem::size_of::<$t>());
490 assert!(mem::size_of::<RawFd>() == mem::size_of::<BorrowedFd<'_>>());
491 }
492 type_check::<$t>();
493 unsafe { mem::transmute::<&BorrowedFd<'_>, &$t>(self) }
495 }
496 }
497 )*}
498}
499
500#[cfg(not(target_os = "trusty"))]
501unsafe_impl_fd_asrefs!(
502 crate::fs::File,
503 crate::net::TcpStream,
504 crate::net::TcpListener,
505 crate::net::UdpSocket,
506);
507
508#[cfg(unix)]
509unsafe_impl_fd_asrefs!(io::PipeWriter, io::PipeReader);
510
511#[stable(feature = "asfd_ptrs", since = "1.64.0")]
512impl<T: AsFd + ?Sized> AsFd for crate::sync::Arc<T> {
528 #[inline]
529 fn as_fd(&self) -> BorrowedFd<'_> {
530 (**self).as_fd()
531 }
532}
533
534#[stable(feature = "asfd_rc", since = "1.69.0")]
535impl<T: AsFd + ?Sized> AsFd for crate::rc::Rc<T> {
536 #[inline]
537 fn as_fd(&self) -> BorrowedFd<'_> {
538 (**self).as_fd()
539 }
540}
541
542#[unstable(feature = "unique_rc_arc", issue = "112566")]
543impl<T: AsFd + ?Sized> AsFd for crate::rc::UniqueRc<T> {
544 #[inline]
545 fn as_fd(&self) -> BorrowedFd<'_> {
546 (**self).as_fd()
547 }
548}
549
550#[stable(feature = "asfd_ptrs", since = "1.64.0")]
551impl<T: AsFd + ?Sized, A: Allocator> AsFd for Box<T, A> {
552 #[inline]
553 fn as_fd(&self) -> BorrowedFd<'_> {
554 (**self).as_fd()
555 }
556}
557
558#[stable(feature = "io_safety", since = "1.63.0")]
559impl AsFd for io::Stdin {
560 #[inline]
561 fn as_fd(&self) -> BorrowedFd<'_> {
562 unsafe { BorrowedFd::borrow_raw(0) }
563 }
564}
565
566#[stable(feature = "io_safety", since = "1.63.0")]
567impl<'a> AsFd for io::StdinLock<'a> {
568 #[inline]
569 fn as_fd(&self) -> BorrowedFd<'_> {
570 unsafe { BorrowedFd::borrow_raw(0) }
572 }
573}
574
575#[stable(feature = "io_safety", since = "1.63.0")]
576impl AsFd for io::Stdout {
577 #[inline]
578 fn as_fd(&self) -> BorrowedFd<'_> {
579 unsafe { BorrowedFd::borrow_raw(1) }
580 }
581}
582
583#[stable(feature = "io_safety", since = "1.63.0")]
584impl<'a> AsFd for io::StdoutLock<'a> {
585 #[inline]
586 fn as_fd(&self) -> BorrowedFd<'_> {
587 unsafe { BorrowedFd::borrow_raw(1) }
589 }
590}
591
592#[stable(feature = "io_safety", since = "1.63.0")]
593impl AsFd for io::Stderr {
594 #[inline]
595 fn as_fd(&self) -> BorrowedFd<'_> {
596 unsafe { BorrowedFd::borrow_raw(2) }
597 }
598}
599
600#[stable(feature = "io_safety", since = "1.63.0")]
601impl<'a> AsFd for io::StderrLock<'a> {
602 #[inline]
603 fn as_fd(&self) -> BorrowedFd<'_> {
604 unsafe { BorrowedFd::borrow_raw(2) }
606 }
607}
608
609#[stable(feature = "anonymous_pipe", since = "1.87.0")]
610#[cfg(not(target_os = "trusty"))]
611impl AsFd for io::PipeReader {
612 fn as_fd(&self) -> BorrowedFd<'_> {
613 self.0.as_fd()
614 }
615}
616
617#[stable(feature = "anonymous_pipe", since = "1.87.0")]
618#[cfg(not(target_os = "trusty"))]
619impl From<io::PipeReader> for OwnedFd {
620 fn from(pipe: io::PipeReader) -> Self {
621 pipe.0.into_inner()
622 }
623}
624
625#[stable(feature = "anonymous_pipe", since = "1.87.0")]
626#[cfg(not(target_os = "trusty"))]
627impl AsFd for io::PipeWriter {
628 fn as_fd(&self) -> BorrowedFd<'_> {
629 self.0.as_fd()
630 }
631}
632
633#[stable(feature = "anonymous_pipe", since = "1.87.0")]
634#[cfg(not(target_os = "trusty"))]
635impl From<io::PipeWriter> for OwnedFd {
636 fn from(pipe: io::PipeWriter) -> Self {
637 pipe.0.into_inner()
638 }
639}
640
641#[stable(feature = "anonymous_pipe", since = "1.87.0")]
642#[cfg(not(target_os = "trusty"))]
643impl From<OwnedFd> for io::PipeReader {
644 fn from(owned_fd: OwnedFd) -> Self {
645 Self(FromInner::from_inner(owned_fd))
646 }
647}
648
649#[stable(feature = "anonymous_pipe", since = "1.87.0")]
650#[cfg(not(target_os = "trusty"))]
651impl From<OwnedFd> for io::PipeWriter {
652 fn from(owned_fd: OwnedFd) -> Self {
653 Self(FromInner::from_inner(owned_fd))
654 }
655}