1 mod afd;
2 
3 pub mod event;
4 pub use event::{Event, Events};
5 
6 mod handle;
7 use handle::Handle;
8 
9 mod io_status_block;
10 mod iocp;
11 
12 mod overlapped;
13 use overlapped::Overlapped;
14 
15 mod selector;
16 pub use selector::Selector;
17 
18 // Macros must be defined before the modules that use them
19 cfg_net! {
20     /// Helper macro to execute a system call that returns an `io::Result`.
21     //
22     // Macro must be defined before any modules that uses them.
23     macro_rules! syscall {
24         ($fn: ident ( $($arg: expr),* $(,)* ), $err_test: path, $err_value: expr) => {{
25             let res = unsafe { $fn($($arg, )*) };
26             if $err_test(&res, &$err_value) {
27                 Err(io::Error::last_os_error())
28             } else {
29                 Ok(res)
30             }
31         }};
32     }
33 
34     mod net;
35 
36     pub(crate) mod tcp;
37     pub(crate) mod udp;
38 
39     pub use selector::{SelectorInner, SockState};
40 }
41 
42 cfg_os_ext! {
43     pub(crate) mod named_pipe;
44 }
45 
46 mod waker;
47 pub(crate) use waker::Waker;
48 
49 cfg_io_source! {
50     use std::io;
51     use std::os::windows::io::RawSocket;
52     use std::pin::Pin;
53     use std::sync::{Arc, Mutex};
54 
55     use crate::{Interest, Registry, Token};
56 
57     struct InternalState {
58         selector: Arc<SelectorInner>,
59         token: Token,
60         interests: Interest,
61         sock_state: Pin<Arc<Mutex<SockState>>>,
62     }
63 
64     impl Drop for InternalState {
65         fn drop(&mut self) {
66             let mut sock_state = self.sock_state.lock().unwrap();
67             sock_state.mark_delete();
68         }
69     }
70 
71     pub struct IoSourceState {
72         // This is `None` if the socket has not yet been registered.
73         //
74         // We box the internal state to not increase the size on the stack as the
75         // type might move around a lot.
76         inner: Option<Box<InternalState>>,
77     }
78 
79     impl IoSourceState {
80         pub fn new() -> IoSourceState {
81             IoSourceState { inner: None }
82         }
83 
84         pub fn do_io<T, F, R>(&self, f: F, io: &T) -> io::Result<R>
85         where
86             F: FnOnce(&T) -> io::Result<R>,
87         {
88             let result = f(io);
89             if let Err(ref e) = result {
90                 if e.kind() == io::ErrorKind::WouldBlock {
91                     self.inner.as_ref().map_or(Ok(()), |state| {
92                         state
93                             .selector
94                             .reregister(state.sock_state.clone(), state.token, state.interests)
95                     })?;
96                 }
97             }
98             result
99         }
100 
101         pub fn register(
102             &mut self,
103             registry: &Registry,
104             token: Token,
105             interests: Interest,
106             socket: RawSocket,
107         ) -> io::Result<()> {
108             if self.inner.is_some() {
109                 Err(io::ErrorKind::AlreadyExists.into())
110             } else {
111                 registry
112                     .selector()
113                     .register(socket, token, interests)
114                     .map(|state| {
115                         self.inner = Some(Box::new(state));
116                     })
117             }
118         }
119 
120         pub fn reregister(
121             &mut self,
122             registry: &Registry,
123             token: Token,
124             interests: Interest,
125         ) -> io::Result<()> {
126             match self.inner.as_mut() {
127                 Some(state) => {
128                     registry
129                         .selector()
130                         .reregister(state.sock_state.clone(), token, interests)
131                         .map(|()| {
132                             state.token = token;
133                             state.interests = interests;
134                         })
135                 }
136                 None => Err(io::ErrorKind::NotFound.into()),
137             }
138         }
139 
140         pub fn deregister(&mut self) -> io::Result<()> {
141             match self.inner.as_mut() {
142                 Some(state) => {
143                     {
144                         let mut sock_state = state.sock_state.lock().unwrap();
145                         sock_state.mark_delete();
146                     }
147                     self.inner = None;
148                     Ok(())
149                 }
150                 None => Err(io::ErrorKind::NotFound.into()),
151             }
152         }
153     }
154 }
155