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, SelectorInner, SockState}; 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 40 cfg_os_ext! { 41 pub(crate) mod named_pipe; 42 } 43 44 mod waker; 45 pub(crate) use waker::Waker; 46 47 cfg_io_source! { 48 use std::io; 49 use std::os::windows::io::RawSocket; 50 use std::pin::Pin; 51 use std::sync::{Arc, Mutex}; 52 53 use crate::{Interest, Registry, Token}; 54 55 struct InternalState { 56 selector: Arc<SelectorInner>, 57 token: Token, 58 interests: Interest, 59 sock_state: Pin<Arc<Mutex<SockState>>>, 60 } 61 62 impl Drop for InternalState { 63 fn drop(&mut self) { 64 let mut sock_state = self.sock_state.lock().unwrap(); 65 sock_state.mark_delete(); 66 } 67 } 68 69 pub struct IoSourceState { 70 // This is `None` if the socket has not yet been registered. 71 // 72 // We box the internal state to not increase the size on the stack as the 73 // type might move around a lot. 74 inner: Option<Box<InternalState>>, 75 } 76 77 impl IoSourceState { 78 pub fn new() -> IoSourceState { 79 IoSourceState { inner: None } 80 } 81 82 pub fn do_io<T, F, R>(&self, f: F, io: &T) -> io::Result<R> 83 where 84 F: FnOnce(&T) -> io::Result<R>, 85 { 86 let result = f(io); 87 if let Err(ref e) = result { 88 if e.kind() == io::ErrorKind::WouldBlock { 89 self.inner.as_ref().map_or(Ok(()), |state| { 90 state 91 .selector 92 .reregister(state.sock_state.clone(), state.token, state.interests) 93 })?; 94 } 95 } 96 result 97 } 98 99 pub fn register( 100 &mut self, 101 registry: &Registry, 102 token: Token, 103 interests: Interest, 104 socket: RawSocket, 105 ) -> io::Result<()> { 106 if self.inner.is_some() { 107 Err(io::ErrorKind::AlreadyExists.into()) 108 } else { 109 registry 110 .selector() 111 .register(socket, token, interests) 112 .map(|state| { 113 self.inner = Some(Box::new(state)); 114 }) 115 } 116 } 117 118 pub fn reregister( 119 &mut self, 120 registry: &Registry, 121 token: Token, 122 interests: Interest, 123 ) -> io::Result<()> { 124 match self.inner.as_mut() { 125 Some(state) => { 126 registry 127 .selector() 128 .reregister(state.sock_state.clone(), token, interests) 129 .map(|()| { 130 state.token = token; 131 state.interests = interests; 132 }) 133 } 134 None => Err(io::ErrorKind::NotFound.into()), 135 } 136 } 137 138 pub fn deregister(&mut self) -> io::Result<()> { 139 match self.inner.as_mut() { 140 Some(state) => { 141 { 142 let mut sock_state = state.sock_state.lock().unwrap(); 143 sock_state.mark_delete(); 144 } 145 self.inner = None; 146 Ok(()) 147 } 148 None => Err(io::ErrorKind::NotFound.into()), 149 } 150 } 151 } 152 } 153