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