• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 //! Implementations of io-lifetimes' traits for mio's types. In the
2 //! future, we'll prefer to have crates provide their own impls; this is
3 //! just a temporary measure.
4 
5 #[cfg(any(unix, target_os = "wasi"))]
6 use crate::{AsFd, BorrowedFd, FromFd, IntoFd, OwnedFd};
7 #[cfg(windows)]
8 use crate::{AsSocket, BorrowedSocket, FromSocket, IntoSocket, OwnedSocket};
9 #[cfg(unix)]
10 use std::os::unix::io::{AsRawFd, FromRawFd, IntoRawFd};
11 #[cfg(target_os = "wasi")]
12 use std::os::wasi::io::{AsRawFd, FromRawFd, IntoRawFd};
13 #[cfg(windows)]
14 use std::os::windows::io::{AsRawSocket, FromRawSocket, IntoRawSocket};
15 
16 #[cfg(any(unix, target_os = "wasi"))]
17 impl AsFd for mio::net::TcpStream {
18     #[inline]
as_fd(&self) -> BorrowedFd<'_>19     fn as_fd(&self) -> BorrowedFd<'_> {
20         unsafe { BorrowedFd::borrow_raw(self.as_raw_fd()) }
21     }
22 }
23 
24 #[cfg(windows)]
25 impl AsSocket for mio::net::TcpStream {
26     #[inline]
as_socket(&self) -> BorrowedSocket<'_>27     fn as_socket(&self) -> BorrowedSocket<'_> {
28         unsafe { BorrowedSocket::borrow_raw(self.as_raw_socket()) }
29     }
30 }
31 
32 #[cfg(any(unix, target_os = "wasi"))]
33 impl IntoFd for mio::net::TcpStream {
34     #[inline]
into_fd(self) -> OwnedFd35     fn into_fd(self) -> OwnedFd {
36         unsafe { OwnedFd::from_raw_fd(self.into_raw_fd()) }
37     }
38 }
39 
40 #[cfg(any(unix, target_os = "wasi"))]
41 impl From<mio::net::TcpStream> for OwnedFd {
42     #[inline]
from(owned: mio::net::TcpStream) -> Self43     fn from(owned: mio::net::TcpStream) -> Self {
44         unsafe { Self::from_raw_fd(owned.into_raw_fd()) }
45     }
46 }
47 
48 #[cfg(windows)]
49 impl IntoSocket for mio::net::TcpStream {
50     #[inline]
into_socket(self) -> OwnedSocket51     fn into_socket(self) -> OwnedSocket {
52         unsafe { OwnedSocket::from_raw_socket(self.into_raw_socket()) }
53     }
54 }
55 
56 #[cfg(windows)]
57 impl From<mio::net::TcpStream> for OwnedSocket {
58     #[inline]
from(owned: mio::net::TcpStream) -> Self59     fn from(owned: mio::net::TcpStream) -> Self {
60         unsafe { Self::from_raw_socket(owned.into_raw_socket()) }
61     }
62 }
63 
64 #[cfg(any(unix, target_os = "wasi"))]
65 impl FromFd for mio::net::TcpStream {
66     #[inline]
from_fd(owned: OwnedFd) -> Self67     fn from_fd(owned: OwnedFd) -> Self {
68         unsafe { Self::from_raw_fd(owned.into_raw_fd()) }
69     }
70 }
71 
72 #[cfg(any(unix, target_os = "wasi"))]
73 impl From<OwnedFd> for mio::net::TcpStream {
74     #[inline]
from(owned: OwnedFd) -> Self75     fn from(owned: OwnedFd) -> Self {
76         unsafe { Self::from_raw_fd(owned.into_raw_fd()) }
77     }
78 }
79 
80 #[cfg(windows)]
81 impl FromSocket for mio::net::TcpStream {
82     #[inline]
from_socket(owned: OwnedSocket) -> Self83     fn from_socket(owned: OwnedSocket) -> Self {
84         unsafe { Self::from_raw_socket(owned.into_raw_socket()) }
85     }
86 }
87 
88 #[cfg(windows)]
89 impl From<OwnedSocket> for mio::net::TcpStream {
90     #[inline]
from(owned: OwnedSocket) -> Self91     fn from(owned: OwnedSocket) -> Self {
92         unsafe { Self::from_raw_socket(owned.into_raw_socket()) }
93     }
94 }
95 
96 #[cfg(any(unix, target_os = "wasi"))]
97 impl AsFd for mio::net::TcpListener {
98     #[inline]
as_fd(&self) -> BorrowedFd<'_>99     fn as_fd(&self) -> BorrowedFd<'_> {
100         unsafe { BorrowedFd::borrow_raw(self.as_raw_fd()) }
101     }
102 }
103 
104 #[cfg(windows)]
105 impl AsSocket for mio::net::TcpListener {
106     #[inline]
as_socket(&self) -> BorrowedSocket<'_>107     fn as_socket(&self) -> BorrowedSocket<'_> {
108         unsafe { BorrowedSocket::borrow_raw(self.as_raw_socket()) }
109     }
110 }
111 
112 #[cfg(any(unix, target_os = "wasi"))]
113 impl IntoFd for mio::net::TcpListener {
114     #[inline]
into_fd(self) -> OwnedFd115     fn into_fd(self) -> OwnedFd {
116         unsafe { OwnedFd::from_raw_fd(self.into_raw_fd()) }
117     }
118 }
119 
120 #[cfg(any(unix, target_os = "wasi"))]
121 impl From<mio::net::TcpListener> for OwnedFd {
122     #[inline]
from(owned: mio::net::TcpListener) -> Self123     fn from(owned: mio::net::TcpListener) -> Self {
124         unsafe { Self::from_raw_fd(owned.into_raw_fd()) }
125     }
126 }
127 
128 #[cfg(windows)]
129 impl IntoSocket for mio::net::TcpListener {
130     #[inline]
into_socket(self) -> OwnedSocket131     fn into_socket(self) -> OwnedSocket {
132         unsafe { OwnedSocket::from_raw_socket(self.into_raw_socket()) }
133     }
134 }
135 
136 #[cfg(windows)]
137 impl From<mio::net::TcpListener> for OwnedSocket {
138     #[inline]
from(owned: mio::net::TcpListener) -> Self139     fn from(owned: mio::net::TcpListener) -> Self {
140         unsafe { Self::from_raw_socket(owned.into_raw_socket()) }
141     }
142 }
143 
144 #[cfg(any(unix, target_os = "wasi"))]
145 impl FromFd for mio::net::TcpListener {
146     #[inline]
from_fd(owned: OwnedFd) -> Self147     fn from_fd(owned: OwnedFd) -> Self {
148         unsafe { Self::from_raw_fd(owned.into_raw_fd()) }
149     }
150 }
151 
152 #[cfg(any(unix, target_os = "wasi"))]
153 impl From<OwnedFd> for mio::net::TcpListener {
154     #[inline]
from(owned: OwnedFd) -> Self155     fn from(owned: OwnedFd) -> Self {
156         unsafe { Self::from_raw_fd(owned.into_raw_fd()) }
157     }
158 }
159 
160 #[cfg(windows)]
161 impl FromSocket for mio::net::TcpListener {
162     #[inline]
from_socket(owned: OwnedSocket) -> Self163     fn from_socket(owned: OwnedSocket) -> Self {
164         unsafe { Self::from_raw_socket(owned.into_raw_socket()) }
165     }
166 }
167 
168 #[cfg(windows)]
169 impl From<OwnedSocket> for mio::net::TcpListener {
170     #[inline]
from(owned: OwnedSocket) -> Self171     fn from(owned: OwnedSocket) -> Self {
172         unsafe { Self::from_raw_socket(owned.into_raw_socket()) }
173     }
174 }
175 
176 #[cfg(any(unix, target_os = "wasi"))]
177 impl AsFd for mio::net::UdpSocket {
178     #[inline]
as_fd(&self) -> BorrowedFd<'_>179     fn as_fd(&self) -> BorrowedFd<'_> {
180         unsafe { BorrowedFd::borrow_raw(self.as_raw_fd()) }
181     }
182 }
183 
184 #[cfg(windows)]
185 impl AsSocket for mio::net::UdpSocket {
186     #[inline]
as_socket(&self) -> BorrowedSocket<'_>187     fn as_socket(&self) -> BorrowedSocket<'_> {
188         unsafe { BorrowedSocket::borrow_raw(self.as_raw_socket()) }
189     }
190 }
191 
192 #[cfg(any(unix, target_os = "wasi"))]
193 impl IntoFd for mio::net::UdpSocket {
194     #[inline]
into_fd(self) -> OwnedFd195     fn into_fd(self) -> OwnedFd {
196         unsafe { OwnedFd::from_raw_fd(self.into_raw_fd()) }
197     }
198 }
199 
200 #[cfg(any(unix, target_os = "wasi"))]
201 impl From<mio::net::UdpSocket> for OwnedFd {
202     #[inline]
from(owned: mio::net::UdpSocket) -> Self203     fn from(owned: mio::net::UdpSocket) -> Self {
204         unsafe { Self::from_raw_fd(owned.into_raw_fd()) }
205     }
206 }
207 
208 #[cfg(windows)]
209 impl IntoSocket for mio::net::UdpSocket {
210     #[inline]
into_socket(self) -> OwnedSocket211     fn into_socket(self) -> OwnedSocket {
212         unsafe { OwnedSocket::from_raw_socket(self.into_raw_socket()) }
213     }
214 }
215 
216 #[cfg(windows)]
217 impl From<mio::net::UdpSocket> for OwnedSocket {
218     #[inline]
from(owned: mio::net::UdpSocket) -> Self219     fn from(owned: mio::net::UdpSocket) -> Self {
220         unsafe { Self::from_raw_socket(owned.into_raw_socket()) }
221     }
222 }
223 
224 #[cfg(any(unix, target_os = "wasi"))]
225 impl FromFd for mio::net::UdpSocket {
226     #[inline]
from_fd(owned: OwnedFd) -> Self227     fn from_fd(owned: OwnedFd) -> Self {
228         unsafe { Self::from_raw_fd(owned.into_raw_fd()) }
229     }
230 }
231 
232 #[cfg(any(unix, target_os = "wasi"))]
233 impl From<OwnedFd> for mio::net::UdpSocket {
234     #[inline]
from(owned: OwnedFd) -> Self235     fn from(owned: OwnedFd) -> Self {
236         unsafe { Self::from_raw_fd(owned.into_raw_fd()) }
237     }
238 }
239 
240 #[cfg(windows)]
241 impl FromSocket for mio::net::UdpSocket {
242     #[inline]
from_socket(owned: OwnedSocket) -> Self243     fn from_socket(owned: OwnedSocket) -> Self {
244         unsafe { Self::from_raw_socket(owned.into_raw_socket()) }
245     }
246 }
247 
248 #[cfg(windows)]
249 impl From<OwnedSocket> for mio::net::UdpSocket {
250     #[inline]
from(owned: OwnedSocket) -> Self251     fn from(owned: OwnedSocket) -> Self {
252         unsafe { Self::from_raw_socket(owned.into_raw_socket()) }
253     }
254 }
255 
256 #[cfg(unix)]
257 impl AsFd for mio::net::UnixDatagram {
258     #[inline]
as_fd(&self) -> BorrowedFd<'_>259     fn as_fd(&self) -> BorrowedFd<'_> {
260         unsafe { BorrowedFd::borrow_raw(self.as_raw_fd()) }
261     }
262 }
263 
264 #[cfg(unix)]
265 impl IntoFd for mio::net::UnixDatagram {
266     #[inline]
into_fd(self) -> OwnedFd267     fn into_fd(self) -> OwnedFd {
268         unsafe { OwnedFd::from_raw_fd(self.into_raw_fd()) }
269     }
270 }
271 
272 #[cfg(unix)]
273 impl From<mio::net::UnixDatagram> for OwnedFd {
274     #[inline]
from(owned: mio::net::UnixDatagram) -> Self275     fn from(owned: mio::net::UnixDatagram) -> Self {
276         unsafe { Self::from_raw_fd(owned.into_raw_fd()) }
277     }
278 }
279 
280 #[cfg(unix)]
281 impl FromFd for mio::net::UnixDatagram {
282     #[inline]
from_fd(owned: OwnedFd) -> Self283     fn from_fd(owned: OwnedFd) -> Self {
284         unsafe { Self::from_raw_fd(owned.into_raw_fd()) }
285     }
286 }
287 
288 #[cfg(unix)]
289 impl From<OwnedFd> for mio::net::UnixDatagram {
290     #[inline]
from(owned: OwnedFd) -> Self291     fn from(owned: OwnedFd) -> Self {
292         unsafe { Self::from_raw_fd(owned.into_raw_fd()) }
293     }
294 }
295 
296 #[cfg(unix)]
297 impl AsFd for mio::net::UnixListener {
298     #[inline]
as_fd(&self) -> BorrowedFd<'_>299     fn as_fd(&self) -> BorrowedFd<'_> {
300         unsafe { BorrowedFd::borrow_raw(self.as_raw_fd()) }
301     }
302 }
303 
304 #[cfg(unix)]
305 impl IntoFd for mio::net::UnixListener {
306     #[inline]
into_fd(self) -> OwnedFd307     fn into_fd(self) -> OwnedFd {
308         unsafe { OwnedFd::from_raw_fd(self.into_raw_fd()) }
309     }
310 }
311 
312 #[cfg(unix)]
313 impl From<mio::net::UnixListener> for OwnedFd {
314     #[inline]
from(owned: mio::net::UnixListener) -> Self315     fn from(owned: mio::net::UnixListener) -> Self {
316         unsafe { Self::from_raw_fd(owned.into_raw_fd()) }
317     }
318 }
319 
320 #[cfg(unix)]
321 impl FromFd for mio::net::UnixListener {
322     #[inline]
from_fd(owned: OwnedFd) -> Self323     fn from_fd(owned: OwnedFd) -> Self {
324         unsafe { Self::from_raw_fd(owned.into_raw_fd()) }
325     }
326 }
327 
328 #[cfg(unix)]
329 impl From<OwnedFd> for mio::net::UnixListener {
330     #[inline]
from(owned: OwnedFd) -> Self331     fn from(owned: OwnedFd) -> Self {
332         unsafe { Self::from_raw_fd(owned.into_raw_fd()) }
333     }
334 }
335 
336 #[cfg(unix)]
337 impl AsFd for mio::net::UnixStream {
338     #[inline]
as_fd(&self) -> BorrowedFd<'_>339     fn as_fd(&self) -> BorrowedFd<'_> {
340         unsafe { BorrowedFd::borrow_raw(self.as_raw_fd()) }
341     }
342 }
343 
344 #[cfg(unix)]
345 impl IntoFd for mio::net::UnixStream {
346     #[inline]
into_fd(self) -> OwnedFd347     fn into_fd(self) -> OwnedFd {
348         unsafe { OwnedFd::from_raw_fd(self.into_raw_fd()) }
349     }
350 }
351 
352 #[cfg(unix)]
353 impl From<mio::net::UnixStream> for OwnedFd {
354     #[inline]
from(owned: mio::net::UnixStream) -> Self355     fn from(owned: mio::net::UnixStream) -> Self {
356         unsafe { Self::from_raw_fd(owned.into_raw_fd()) }
357     }
358 }
359 
360 #[cfg(unix)]
361 impl FromFd for mio::net::UnixStream {
362     #[inline]
from_fd(owned: OwnedFd) -> Self363     fn from_fd(owned: OwnedFd) -> Self {
364         unsafe { Self::from_raw_fd(owned.into_raw_fd()) }
365     }
366 }
367 
368 #[cfg(unix)]
369 impl From<OwnedFd> for mio::net::UnixStream {
370     #[inline]
from(owned: OwnedFd) -> Self371     fn from(owned: OwnedFd) -> Self {
372         unsafe { Self::from_raw_fd(owned.into_raw_fd()) }
373     }
374 }
375 
376 #[cfg(unix)]
377 impl AsFd for mio::unix::pipe::Receiver {
378     #[inline]
as_fd(&self) -> BorrowedFd<'_>379     fn as_fd(&self) -> BorrowedFd<'_> {
380         unsafe { BorrowedFd::borrow_raw(self.as_raw_fd()) }
381     }
382 }
383 
384 #[cfg(unix)]
385 impl IntoFd for mio::unix::pipe::Receiver {
386     #[inline]
into_fd(self) -> OwnedFd387     fn into_fd(self) -> OwnedFd {
388         unsafe { OwnedFd::from_raw_fd(self.into_raw_fd()) }
389     }
390 }
391 
392 #[cfg(unix)]
393 impl From<mio::unix::pipe::Receiver> for OwnedFd {
394     #[inline]
from(owned: mio::unix::pipe::Receiver) -> Self395     fn from(owned: mio::unix::pipe::Receiver) -> Self {
396         unsafe { Self::from_raw_fd(owned.into_raw_fd()) }
397     }
398 }
399 
400 #[cfg(unix)]
401 impl FromFd for mio::unix::pipe::Receiver {
402     #[inline]
from_fd(owned: OwnedFd) -> Self403     fn from_fd(owned: OwnedFd) -> Self {
404         unsafe { Self::from_raw_fd(owned.into_raw_fd()) }
405     }
406 }
407 
408 #[cfg(unix)]
409 impl From<OwnedFd> for mio::unix::pipe::Receiver {
410     #[inline]
from(owned: OwnedFd) -> Self411     fn from(owned: OwnedFd) -> Self {
412         unsafe { Self::from_raw_fd(owned.into_raw_fd()) }
413     }
414 }
415 
416 #[cfg(unix)]
417 impl AsFd for mio::unix::pipe::Sender {
418     #[inline]
as_fd(&self) -> BorrowedFd<'_>419     fn as_fd(&self) -> BorrowedFd<'_> {
420         unsafe { BorrowedFd::borrow_raw(self.as_raw_fd()) }
421     }
422 }
423 
424 #[cfg(unix)]
425 impl IntoFd for mio::unix::pipe::Sender {
426     #[inline]
into_fd(self) -> OwnedFd427     fn into_fd(self) -> OwnedFd {
428         unsafe { OwnedFd::from_raw_fd(self.into_raw_fd()) }
429     }
430 }
431 
432 #[cfg(unix)]
433 impl From<mio::unix::pipe::Sender> for OwnedFd {
434     #[inline]
from(owned: mio::unix::pipe::Sender) -> Self435     fn from(owned: mio::unix::pipe::Sender) -> Self {
436         unsafe { Self::from_raw_fd(owned.into_raw_fd()) }
437     }
438 }
439 
440 #[cfg(unix)]
441 impl FromFd for mio::unix::pipe::Sender {
442     #[inline]
from_fd(owned: OwnedFd) -> Self443     fn from_fd(owned: OwnedFd) -> Self {
444         unsafe { Self::from_raw_fd(owned.into_raw_fd()) }
445     }
446 }
447 
448 #[cfg(unix)]
449 impl From<OwnedFd> for mio::unix::pipe::Sender {
450     #[inline]
from(owned: OwnedFd) -> Self451     fn from(owned: OwnedFd) -> Self {
452         unsafe { Self::from_raw_fd(owned.into_raw_fd()) }
453     }
454 }
455