author | alfadur <mail@none> |
Thu, 26 Dec 2019 21:04:37 +0300 | |
changeset 15552 | a859f08ebb4f |
parent 15542 | fd3a20e9d095 |
child 15553 | ede5f4ec48f3 |
permissions | -rw-r--r-- |
13119 | 1 |
extern crate slab; |
2 |
||
13414 | 3 |
use std::{ |
13415 | 4 |
collections::HashSet, |
14478 | 5 |
io, |
6 |
io::{Error, ErrorKind, Read, Write}, |
|
7 |
mem::{replace, swap}, |
|
8 |
net::{IpAddr, Ipv4Addr, SocketAddr}, |
|
13414 | 9 |
}; |
10 |
||
14478 | 11 |
use log::*; |
13414 | 12 |
use mio::{ |
14478 | 13 |
net::{TcpListener, TcpStream}, |
14851
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
14 |
Evented, Poll, PollOpt, Ready, Token, |
13414 | 15 |
}; |
14824 | 16 |
use mio_extras::timer; |
13414 | 17 |
use netbuf; |
13119 | 18 |
use slab::Slab; |
19 |
||
13666 | 20 |
use crate::{ |
15542 | 21 |
core::types::ClientId, |
15095 | 22 |
handlers, |
15542 | 23 |
handlers::{IoResult, IoTask, ServerState}, |
15124
823052e66611
check for account existence before asking passwords
alfadur
parents:
15123
diff
changeset
|
24 |
protocol::{messages::HwServerMessage::Redirect, messages::*, ProtocolDecoder}, |
13666 | 25 |
utils, |
13414 | 26 |
}; |
14800
f43ab2bd76ae
add a thread for internal server IO and implement account checking with it
alfadur
parents:
14718
diff
changeset
|
27 |
|
f43ab2bd76ae
add a thread for internal server IO and implement account checking with it
alfadur
parents:
14718
diff
changeset
|
28 |
#[cfg(feature = "official-server")] |
15119 | 29 |
use super::io::{IoThread, RequestId}; |
14800
f43ab2bd76ae
add a thread for internal server IO and implement account checking with it
alfadur
parents:
14718
diff
changeset
|
30 |
|
13773 | 31 |
#[cfg(feature = "tls-connections")] |
32 |
use openssl::{ |
|
14478 | 33 |
error::ErrorStack, |
13773 | 34 |
ssl::{ |
14478 | 35 |
HandshakeError, MidHandshakeSslStream, Ssl, SslContext, SslContextBuilder, SslFiletype, |
36 |
SslMethod, SslOptions, SslStream, SslStreamBuilder, SslVerifyMode, |
|
13773 | 37 |
}, |
38 |
}; |
|
14824 | 39 |
use std::time::Duration; |
13414 | 40 |
|
41 |
const MAX_BYTES_PER_READ: usize = 2048; |
|
14824 | 42 |
const SEND_PING_TIMEOUT: Duration = Duration::from_secs(30); |
14828 | 43 |
const DROP_CLIENT_TIMEOUT: Duration = Duration::from_secs(30); |
44 |
const PING_PROBES_COUNT: u8 = 2; |
|
13119 | 45 |
|
13415 | 46 |
#[derive(Hash, Eq, PartialEq, Copy, Clone)] |
13414 | 47 |
pub enum NetworkClientState { |
48 |
Idle, |
|
49 |
NeedsWrite, |
|
50 |
NeedsRead, |
|
51 |
Closed, |
|
14851
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
52 |
#[cfg(feature = "tls-connections")] |
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
53 |
Connected, |
13414 | 54 |
} |
55 |
||
56 |
type NetworkResult<T> = io::Result<(T, NetworkClientState)>; |
|
13119 | 57 |
|
13773 | 58 |
pub enum ClientSocket { |
14478 | 59 |
Plain(TcpStream), |
14851
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
60 |
#[cfg(feature = "tls-connections")] |
13773 | 61 |
SslHandshake(Option<MidHandshakeSslStream<TcpStream>>), |
14851
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
62 |
#[cfg(feature = "tls-connections")] |
14478 | 63 |
SslStream(SslStream<TcpStream>), |
13773 | 64 |
} |
65 |
||
66 |
impl ClientSocket { |
|
67 |
fn inner(&self) -> &TcpStream { |
|
68 |
match self { |
|
69 |
ClientSocket::Plain(stream) => stream, |
|
14851
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
70 |
#[cfg(feature = "tls-connections")] |
13773 | 71 |
ClientSocket::SslHandshake(Some(builder)) => builder.get_ref(), |
14851
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
72 |
#[cfg(feature = "tls-connections")] |
13773 | 73 |
ClientSocket::SslHandshake(None) => unreachable!(), |
14851
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
74 |
#[cfg(feature = "tls-connections")] |
14478 | 75 |
ClientSocket::SslStream(ssl_stream) => ssl_stream.get_ref(), |
13773 | 76 |
} |
77 |
} |
|
78 |
} |
|
79 |
||
13119 | 80 |
pub struct NetworkClient { |
81 |
id: ClientId, |
|
13773 | 82 |
socket: ClientSocket, |
13119 | 83 |
peer_addr: SocketAddr, |
84 |
decoder: ProtocolDecoder, |
|
14478 | 85 |
buf_out: netbuf::Buf, |
14824 | 86 |
timeout: timer::Timeout, |
15195
e705ac360785
pin removed clients until the output buffer is flushed
alfadur
parents:
15194
diff
changeset
|
87 |
pending_close: bool, |
13119 | 88 |
} |
89 |
||
90 |
impl NetworkClient { |
|
14824 | 91 |
pub fn new( |
92 |
id: ClientId, |
|
93 |
socket: ClientSocket, |
|
94 |
peer_addr: SocketAddr, |
|
95 |
timeout: timer::Timeout, |
|
96 |
) -> NetworkClient { |
|
13119 | 97 |
NetworkClient { |
14478 | 98 |
id, |
99 |
socket, |
|
100 |
peer_addr, |
|
13119 | 101 |
decoder: ProtocolDecoder::new(), |
14478 | 102 |
buf_out: netbuf::Buf::new(), |
14824 | 103 |
timeout, |
15195
e705ac360785
pin removed clients until the output buffer is flushed
alfadur
parents:
15194
diff
changeset
|
104 |
pending_close: false, |
13119 | 105 |
} |
106 |
} |
|
107 |
||
13776 | 108 |
#[cfg(feature = "tls-connections")] |
14478 | 109 |
fn handshake_impl( |
110 |
&mut self, |
|
111 |
handshake: MidHandshakeSslStream<TcpStream>, |
|
112 |
) -> io::Result<NetworkClientState> { |
|
13776 | 113 |
match handshake.handshake() { |
114 |
Ok(stream) => { |
|
115 |
self.socket = ClientSocket::SslStream(stream); |
|
14478 | 116 |
debug!( |
117 |
"TLS handshake with {} ({}) completed", |
|
118 |
self.id, self.peer_addr |
|
119 |
); |
|
14851
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
120 |
Ok(NetworkClientState::Connected) |
13776 | 121 |
} |
122 |
Err(HandshakeError::WouldBlock(new_handshake)) => { |
|
123 |
self.socket = ClientSocket::SslHandshake(Some(new_handshake)); |
|
124 |
Ok(NetworkClientState::Idle) |
|
125 |
} |
|
13777 | 126 |
Err(HandshakeError::Failure(new_handshake)) => { |
127 |
self.socket = ClientSocket::SslHandshake(Some(new_handshake)); |
|
13776 | 128 |
debug!("TLS handshake with {} ({}) failed", self.id, self.peer_addr); |
129 |
Err(Error::new(ErrorKind::Other, "Connection failure")) |
|
130 |
} |
|
14478 | 131 |
Err(HandshakeError::SetupFailure(_)) => unreachable!(), |
13776 | 132 |
} |
133 |
} |
|
134 |
||
14478 | 135 |
fn read_impl<R: Read>( |
136 |
decoder: &mut ProtocolDecoder, |
|
137 |
source: &mut R, |
|
138 |
id: ClientId, |
|
139 |
addr: &SocketAddr, |
|
15096 | 140 |
) -> NetworkResult<Vec<HwProtocolMessage>> { |
13414 | 141 |
let mut bytes_read = 0; |
142 |
let result = loop { |
|
13773 | 143 |
match decoder.read_from(source) { |
13414 | 144 |
Ok(bytes) => { |
13773 | 145 |
debug!("Client {}: read {} bytes", id, bytes); |
13414 | 146 |
bytes_read += bytes; |
147 |
if bytes == 0 { |
|
148 |
let result = if bytes_read == 0 { |
|
13773 | 149 |
info!("EOF for client {} ({})", id, addr); |
13414 | 150 |
(Vec::new(), NetworkClientState::Closed) |
151 |
} else { |
|
13773 | 152 |
(decoder.extract_messages(), NetworkClientState::NeedsRead) |
13414 | 153 |
}; |
154 |
break Ok(result); |
|
14478 | 155 |
} else if bytes_read >= MAX_BYTES_PER_READ { |
156 |
break Ok((decoder.extract_messages(), NetworkClientState::NeedsRead)); |
|
13414 | 157 |
} |
158 |
} |
|
159 |
Err(ref error) if error.kind() == ErrorKind::WouldBlock => { |
|
14478 | 160 |
let messages = if bytes_read == 0 { |
13414 | 161 |
Vec::new() |
162 |
} else { |
|
13773 | 163 |
decoder.extract_messages() |
13414 | 164 |
}; |
165 |
break Ok((messages, NetworkClientState::Idle)); |
|
166 |
} |
|
14478 | 167 |
Err(error) => break Err(error), |
13414 | 168 |
} |
169 |
}; |
|
170 |
result |
|
171 |
} |
|
172 |
||
15096 | 173 |
pub fn read(&mut self) -> NetworkResult<Vec<HwProtocolMessage>> { |
13773 | 174 |
match self.socket { |
14478 | 175 |
ClientSocket::Plain(ref mut stream) => { |
176 |
NetworkClient::read_impl(&mut self.decoder, stream, self.id, &self.peer_addr) |
|
177 |
} |
|
14851
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
178 |
#[cfg(feature = "tls-connections")] |
13773 | 179 |
ClientSocket::SslHandshake(ref mut handshake_opt) => { |
13776 | 180 |
let handshake = std::mem::replace(handshake_opt, None).unwrap(); |
181 |
Ok((Vec::new(), self.handshake_impl(handshake)?)) |
|
14478 | 182 |
} |
14851
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
183 |
#[cfg(feature = "tls-connections")] |
14478 | 184 |
ClientSocket::SslStream(ref mut stream) => { |
13773 | 185 |
NetworkClient::read_impl(&mut self.decoder, stream, self.id, &self.peer_addr) |
14478 | 186 |
} |
13773 | 187 |
} |
188 |
} |
|
189 |
||
15195
e705ac360785
pin removed clients until the output buffer is flushed
alfadur
parents:
15194
diff
changeset
|
190 |
fn write_impl<W: Write>( |
e705ac360785
pin removed clients until the output buffer is flushed
alfadur
parents:
15194
diff
changeset
|
191 |
buf_out: &mut netbuf::Buf, |
e705ac360785
pin removed clients until the output buffer is flushed
alfadur
parents:
15194
diff
changeset
|
192 |
destination: &mut W, |
e705ac360785
pin removed clients until the output buffer is flushed
alfadur
parents:
15194
diff
changeset
|
193 |
close_on_empty: bool, |
e705ac360785
pin removed clients until the output buffer is flushed
alfadur
parents:
15194
diff
changeset
|
194 |
) -> NetworkResult<()> { |
13414 | 195 |
let result = loop { |
13773 | 196 |
match buf_out.write_to(destination) { |
14478 | 197 |
Ok(bytes) if buf_out.is_empty() || bytes == 0 => { |
15195
e705ac360785
pin removed clients until the output buffer is flushed
alfadur
parents:
15194
diff
changeset
|
198 |
let status = if buf_out.is_empty() && close_on_empty { |
e705ac360785
pin removed clients until the output buffer is flushed
alfadur
parents:
15194
diff
changeset
|
199 |
NetworkClientState::Closed |
e705ac360785
pin removed clients until the output buffer is flushed
alfadur
parents:
15194
diff
changeset
|
200 |
} else { |
e705ac360785
pin removed clients until the output buffer is flushed
alfadur
parents:
15194
diff
changeset
|
201 |
NetworkClientState::Idle |
e705ac360785
pin removed clients until the output buffer is flushed
alfadur
parents:
15194
diff
changeset
|
202 |
}; |
e705ac360785
pin removed clients until the output buffer is flushed
alfadur
parents:
15194
diff
changeset
|
203 |
break Ok(((), status)); |
14478 | 204 |
} |
13415 | 205 |
Ok(_) => (), |
14478 | 206 |
Err(ref error) |
207 |
if error.kind() == ErrorKind::Interrupted |
|
208 |
|| error.kind() == ErrorKind::WouldBlock => |
|
209 |
{ |
|
13414 | 210 |
break Ok(((), NetworkClientState::NeedsWrite)); |
14478 | 211 |
} |
212 |
Err(error) => break Err(error), |
|
13414 | 213 |
} |
214 |
}; |
|
13773 | 215 |
result |
216 |
} |
|
217 |
||
218 |
pub fn write(&mut self) -> NetworkResult<()> { |
|
14851
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
219 |
let result = match self.socket { |
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
220 |
ClientSocket::Plain(ref mut stream) => { |
15195
e705ac360785
pin removed clients until the output buffer is flushed
alfadur
parents:
15194
diff
changeset
|
221 |
NetworkClient::write_impl(&mut self.buf_out, stream, self.pending_close) |
13773 | 222 |
} |
14478 | 223 |
#[cfg(feature = "tls-connections")] |
14851
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
224 |
ClientSocket::SslHandshake(ref mut handshake_opt) => { |
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
225 |
let handshake = std::mem::replace(handshake_opt, None).unwrap(); |
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
226 |
Ok(((), self.handshake_impl(handshake)?)) |
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
227 |
} |
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
228 |
#[cfg(feature = "tls-connections")] |
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
229 |
ClientSocket::SslStream(ref mut stream) => { |
15195
e705ac360785
pin removed clients until the output buffer is flushed
alfadur
parents:
15194
diff
changeset
|
230 |
NetworkClient::write_impl(&mut self.buf_out, stream, self.pending_close) |
13773 | 231 |
} |
232 |
}; |
|
233 |
||
234 |
self.socket.inner().flush()?; |
|
13414 | 235 |
result |
236 |
} |
|
237 |
||
13119 | 238 |
pub fn send_raw_msg(&mut self, msg: &[u8]) { |
13500 | 239 |
self.buf_out.write_all(msg).unwrap(); |
13119 | 240 |
} |
241 |
||
13500 | 242 |
pub fn send_string(&mut self, msg: &str) { |
13119 | 243 |
self.send_raw_msg(&msg.as_bytes()); |
244 |
} |
|
14824 | 245 |
|
246 |
pub fn replace_timeout(&mut self, timeout: timer::Timeout) -> timer::Timeout { |
|
247 |
replace(&mut self.timeout, timeout) |
|
248 |
} |
|
15195
e705ac360785
pin removed clients until the output buffer is flushed
alfadur
parents:
15194
diff
changeset
|
249 |
|
e705ac360785
pin removed clients until the output buffer is flushed
alfadur
parents:
15194
diff
changeset
|
250 |
pub fn has_pending_sends(&self) -> bool { |
e705ac360785
pin removed clients until the output buffer is flushed
alfadur
parents:
15194
diff
changeset
|
251 |
!self.buf_out.is_empty() |
e705ac360785
pin removed clients until the output buffer is flushed
alfadur
parents:
15194
diff
changeset
|
252 |
} |
13119 | 253 |
} |
254 |
||
13773 | 255 |
#[cfg(feature = "tls-connections")] |
256 |
struct ServerSsl { |
|
14851
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
257 |
listener: TcpListener, |
14478 | 258 |
context: SslContext, |
13773 | 259 |
} |
260 |
||
14800
f43ab2bd76ae
add a thread for internal server IO and implement account checking with it
alfadur
parents:
14718
diff
changeset
|
261 |
#[cfg(feature = "official-server")] |
f43ab2bd76ae
add a thread for internal server IO and implement account checking with it
alfadur
parents:
14718
diff
changeset
|
262 |
pub struct IoLayer { |
f43ab2bd76ae
add a thread for internal server IO and implement account checking with it
alfadur
parents:
14718
diff
changeset
|
263 |
next_request_id: RequestId, |
f43ab2bd76ae
add a thread for internal server IO and implement account checking with it
alfadur
parents:
14718
diff
changeset
|
264 |
request_queue: Vec<(RequestId, ClientId)>, |
15119 | 265 |
io_thread: IoThread, |
14800
f43ab2bd76ae
add a thread for internal server IO and implement account checking with it
alfadur
parents:
14718
diff
changeset
|
266 |
} |
f43ab2bd76ae
add a thread for internal server IO and implement account checking with it
alfadur
parents:
14718
diff
changeset
|
267 |
|
f43ab2bd76ae
add a thread for internal server IO and implement account checking with it
alfadur
parents:
14718
diff
changeset
|
268 |
#[cfg(feature = "official-server")] |
f43ab2bd76ae
add a thread for internal server IO and implement account checking with it
alfadur
parents:
14718
diff
changeset
|
269 |
impl IoLayer { |
f43ab2bd76ae
add a thread for internal server IO and implement account checking with it
alfadur
parents:
14718
diff
changeset
|
270 |
fn new() -> Self { |
f43ab2bd76ae
add a thread for internal server IO and implement account checking with it
alfadur
parents:
14718
diff
changeset
|
271 |
Self { |
f43ab2bd76ae
add a thread for internal server IO and implement account checking with it
alfadur
parents:
14718
diff
changeset
|
272 |
next_request_id: 0, |
f43ab2bd76ae
add a thread for internal server IO and implement account checking with it
alfadur
parents:
14718
diff
changeset
|
273 |
request_queue: vec![], |
15119 | 274 |
io_thread: IoThread::new(), |
14800
f43ab2bd76ae
add a thread for internal server IO and implement account checking with it
alfadur
parents:
14718
diff
changeset
|
275 |
} |
f43ab2bd76ae
add a thread for internal server IO and implement account checking with it
alfadur
parents:
14718
diff
changeset
|
276 |
} |
f43ab2bd76ae
add a thread for internal server IO and implement account checking with it
alfadur
parents:
14718
diff
changeset
|
277 |
|
f43ab2bd76ae
add a thread for internal server IO and implement account checking with it
alfadur
parents:
14718
diff
changeset
|
278 |
fn send(&mut self, client_id: ClientId, task: IoTask) { |
f43ab2bd76ae
add a thread for internal server IO and implement account checking with it
alfadur
parents:
14718
diff
changeset
|
279 |
let request_id = self.next_request_id; |
f43ab2bd76ae
add a thread for internal server IO and implement account checking with it
alfadur
parents:
14718
diff
changeset
|
280 |
self.next_request_id += 1; |
f43ab2bd76ae
add a thread for internal server IO and implement account checking with it
alfadur
parents:
14718
diff
changeset
|
281 |
self.request_queue.push((request_id, client_id)); |
f43ab2bd76ae
add a thread for internal server IO and implement account checking with it
alfadur
parents:
14718
diff
changeset
|
282 |
self.io_thread.send(request_id, task); |
f43ab2bd76ae
add a thread for internal server IO and implement account checking with it
alfadur
parents:
14718
diff
changeset
|
283 |
} |
f43ab2bd76ae
add a thread for internal server IO and implement account checking with it
alfadur
parents:
14718
diff
changeset
|
284 |
|
f43ab2bd76ae
add a thread for internal server IO and implement account checking with it
alfadur
parents:
14718
diff
changeset
|
285 |
fn try_recv(&mut self) -> Option<(ClientId, IoResult)> { |
f43ab2bd76ae
add a thread for internal server IO and implement account checking with it
alfadur
parents:
14718
diff
changeset
|
286 |
let (request_id, result) = self.io_thread.try_recv()?; |
f43ab2bd76ae
add a thread for internal server IO and implement account checking with it
alfadur
parents:
14718
diff
changeset
|
287 |
if let Some(index) = self |
f43ab2bd76ae
add a thread for internal server IO and implement account checking with it
alfadur
parents:
14718
diff
changeset
|
288 |
.request_queue |
f43ab2bd76ae
add a thread for internal server IO and implement account checking with it
alfadur
parents:
14718
diff
changeset
|
289 |
.iter() |
f43ab2bd76ae
add a thread for internal server IO and implement account checking with it
alfadur
parents:
14718
diff
changeset
|
290 |
.position(|(id, _)| *id == request_id) |
f43ab2bd76ae
add a thread for internal server IO and implement account checking with it
alfadur
parents:
14718
diff
changeset
|
291 |
{ |
f43ab2bd76ae
add a thread for internal server IO and implement account checking with it
alfadur
parents:
14718
diff
changeset
|
292 |
let (_, client_id) = self.request_queue.swap_remove(index); |
f43ab2bd76ae
add a thread for internal server IO and implement account checking with it
alfadur
parents:
14718
diff
changeset
|
293 |
Some((client_id, result)) |
f43ab2bd76ae
add a thread for internal server IO and implement account checking with it
alfadur
parents:
14718
diff
changeset
|
294 |
} else { |
f43ab2bd76ae
add a thread for internal server IO and implement account checking with it
alfadur
parents:
14718
diff
changeset
|
295 |
None |
f43ab2bd76ae
add a thread for internal server IO and implement account checking with it
alfadur
parents:
14718
diff
changeset
|
296 |
} |
f43ab2bd76ae
add a thread for internal server IO and implement account checking with it
alfadur
parents:
14718
diff
changeset
|
297 |
} |
f43ab2bd76ae
add a thread for internal server IO and implement account checking with it
alfadur
parents:
14718
diff
changeset
|
298 |
|
f43ab2bd76ae
add a thread for internal server IO and implement account checking with it
alfadur
parents:
14718
diff
changeset
|
299 |
fn cancel(&mut self, client_id: ClientId) { |
f43ab2bd76ae
add a thread for internal server IO and implement account checking with it
alfadur
parents:
14718
diff
changeset
|
300 |
let mut index = 0; |
f43ab2bd76ae
add a thread for internal server IO and implement account checking with it
alfadur
parents:
14718
diff
changeset
|
301 |
while index < self.request_queue.len() { |
f43ab2bd76ae
add a thread for internal server IO and implement account checking with it
alfadur
parents:
14718
diff
changeset
|
302 |
if self.request_queue[index].1 == client_id { |
f43ab2bd76ae
add a thread for internal server IO and implement account checking with it
alfadur
parents:
14718
diff
changeset
|
303 |
self.request_queue.swap_remove(index); |
f43ab2bd76ae
add a thread for internal server IO and implement account checking with it
alfadur
parents:
14718
diff
changeset
|
304 |
} else { |
f43ab2bd76ae
add a thread for internal server IO and implement account checking with it
alfadur
parents:
14718
diff
changeset
|
305 |
index += 1; |
f43ab2bd76ae
add a thread for internal server IO and implement account checking with it
alfadur
parents:
14718
diff
changeset
|
306 |
} |
f43ab2bd76ae
add a thread for internal server IO and implement account checking with it
alfadur
parents:
14718
diff
changeset
|
307 |
} |
f43ab2bd76ae
add a thread for internal server IO and implement account checking with it
alfadur
parents:
14718
diff
changeset
|
308 |
} |
f43ab2bd76ae
add a thread for internal server IO and implement account checking with it
alfadur
parents:
14718
diff
changeset
|
309 |
} |
f43ab2bd76ae
add a thread for internal server IO and implement account checking with it
alfadur
parents:
14718
diff
changeset
|
310 |
|
14824 | 311 |
enum TimeoutEvent { |
14828 | 312 |
SendPing { probes_count: u8 }, |
14824 | 313 |
DropClient, |
314 |
} |
|
315 |
||
316 |
struct TimerData(TimeoutEvent, ClientId); |
|
317 |
||
13119 | 318 |
pub struct NetworkLayer { |
319 |
listener: TcpListener, |
|
15542 | 320 |
server_state: ServerState, |
13414 | 321 |
clients: Slab<NetworkClient>, |
13415 | 322 |
pending: HashSet<(ClientId, NetworkClientState)>, |
13773 | 323 |
pending_cache: Vec<(ClientId, NetworkClientState)>, |
324 |
#[cfg(feature = "tls-connections")] |
|
14478 | 325 |
ssl: ServerSsl, |
14800
f43ab2bd76ae
add a thread for internal server IO and implement account checking with it
alfadur
parents:
14718
diff
changeset
|
326 |
#[cfg(feature = "official-server")] |
f43ab2bd76ae
add a thread for internal server IO and implement account checking with it
alfadur
parents:
14718
diff
changeset
|
327 |
io: IoLayer, |
14824 | 328 |
timer: timer::Timer<TimerData>, |
329 |
} |
|
330 |
||
14851
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
331 |
fn register_read<E: Evented>(poll: &Poll, evented: &E, token: mio::Token) -> io::Result<()> { |
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
332 |
poll.register(evented, token, Ready::readable(), PollOpt::edge()) |
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
333 |
} |
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
334 |
|
14828 | 335 |
fn create_ping_timeout( |
336 |
timer: &mut timer::Timer<TimerData>, |
|
337 |
probes_count: u8, |
|
338 |
client_id: ClientId, |
|
339 |
) -> timer::Timeout { |
|
14824 | 340 |
timer.set_timeout( |
341 |
SEND_PING_TIMEOUT, |
|
14828 | 342 |
TimerData(TimeoutEvent::SendPing { probes_count }, client_id), |
14824 | 343 |
) |
344 |
} |
|
345 |
||
346 |
fn create_drop_timeout(timer: &mut timer::Timer<TimerData>, client_id: ClientId) -> timer::Timeout { |
|
347 |
timer.set_timeout( |
|
348 |
DROP_CLIENT_TIMEOUT, |
|
349 |
TimerData(TimeoutEvent::DropClient, client_id), |
|
350 |
) |
|
13119 | 351 |
} |
352 |
||
353 |
impl NetworkLayer { |
|
14851
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
354 |
pub fn register(&self, poll: &Poll) -> io::Result<()> { |
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
355 |
register_read(poll, &self.listener, utils::SERVER_TOKEN)?; |
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
356 |
#[cfg(feature = "tls-connections")] |
14856 | 357 |
register_read(poll, &self.ssl.listener, utils::SECURE_SERVER_TOKEN)?; |
14851
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
358 |
register_read(poll, &self.timer, utils::TIMER_TOKEN)?; |
14824 | 359 |
|
14800
f43ab2bd76ae
add a thread for internal server IO and implement account checking with it
alfadur
parents:
14718
diff
changeset
|
360 |
#[cfg(feature = "official-server")] |
f43ab2bd76ae
add a thread for internal server IO and implement account checking with it
alfadur
parents:
14718
diff
changeset
|
361 |
self.io.io_thread.register_rx(poll, utils::IO_TOKEN)?; |
f43ab2bd76ae
add a thread for internal server IO and implement account checking with it
alfadur
parents:
14718
diff
changeset
|
362 |
|
f43ab2bd76ae
add a thread for internal server IO and implement account checking with it
alfadur
parents:
14718
diff
changeset
|
363 |
Ok(()) |
13119 | 364 |
} |
365 |
||
15196 | 366 |
fn deregister_client(&mut self, poll: &Poll, id: ClientId, is_error: bool) { |
15195
e705ac360785
pin removed clients until the output buffer is flushed
alfadur
parents:
15194
diff
changeset
|
367 |
if let Some(ref mut client) = self.clients.get_mut(id) { |
13773 | 368 |
poll.deregister(client.socket.inner()) |
13500 | 369 |
.expect("could not deregister socket"); |
15196 | 370 |
if client.has_pending_sends() && !is_error { |
15195
e705ac360785
pin removed clients until the output buffer is flushed
alfadur
parents:
15194
diff
changeset
|
371 |
info!( |
e705ac360785
pin removed clients until the output buffer is flushed
alfadur
parents:
15194
diff
changeset
|
372 |
"client {} ({}) pending removal", |
e705ac360785
pin removed clients until the output buffer is flushed
alfadur
parents:
15194
diff
changeset
|
373 |
client.id, client.peer_addr |
e705ac360785
pin removed clients until the output buffer is flushed
alfadur
parents:
15194
diff
changeset
|
374 |
); |
e705ac360785
pin removed clients until the output buffer is flushed
alfadur
parents:
15194
diff
changeset
|
375 |
client.pending_close = true; |
e705ac360785
pin removed clients until the output buffer is flushed
alfadur
parents:
15194
diff
changeset
|
376 |
poll.register( |
e705ac360785
pin removed clients until the output buffer is flushed
alfadur
parents:
15194
diff
changeset
|
377 |
client.socket.inner(), |
e705ac360785
pin removed clients until the output buffer is flushed
alfadur
parents:
15194
diff
changeset
|
378 |
Token(id), |
e705ac360785
pin removed clients until the output buffer is flushed
alfadur
parents:
15194
diff
changeset
|
379 |
Ready::writable(), |
e705ac360785
pin removed clients until the output buffer is flushed
alfadur
parents:
15194
diff
changeset
|
380 |
PollOpt::edge(), |
e705ac360785
pin removed clients until the output buffer is flushed
alfadur
parents:
15194
diff
changeset
|
381 |
) |
e705ac360785
pin removed clients until the output buffer is flushed
alfadur
parents:
15194
diff
changeset
|
382 |
.unwrap_or_else(|_| { |
e705ac360785
pin removed clients until the output buffer is flushed
alfadur
parents:
15194
diff
changeset
|
383 |
self.clients.remove(id); |
e705ac360785
pin removed clients until the output buffer is flushed
alfadur
parents:
15194
diff
changeset
|
384 |
}); |
e705ac360785
pin removed clients until the output buffer is flushed
alfadur
parents:
15194
diff
changeset
|
385 |
} else { |
e705ac360785
pin removed clients until the output buffer is flushed
alfadur
parents:
15194
diff
changeset
|
386 |
info!("client {} ({}) removed", client.id, client.peer_addr); |
e705ac360785
pin removed clients until the output buffer is flushed
alfadur
parents:
15194
diff
changeset
|
387 |
self.clients.remove(id); |
e705ac360785
pin removed clients until the output buffer is flushed
alfadur
parents:
15194
diff
changeset
|
388 |
} |
14800
f43ab2bd76ae
add a thread for internal server IO and implement account checking with it
alfadur
parents:
14718
diff
changeset
|
389 |
#[cfg(feature = "official-server")] |
f43ab2bd76ae
add a thread for internal server IO and implement account checking with it
alfadur
parents:
14718
diff
changeset
|
390 |
self.io.cancel(id); |
13119 | 391 |
} |
392 |
} |
|
393 |
||
14478 | 394 |
fn register_client( |
395 |
&mut self, |
|
396 |
poll: &Poll, |
|
397 |
client_socket: ClientSocket, |
|
398 |
addr: SocketAddr, |
|
14937 | 399 |
) -> io::Result<ClientId> { |
14714 | 400 |
let entry = self.clients.vacant_entry(); |
401 |
let client_id = entry.key(); |
|
402 |
||
14478 | 403 |
poll.register( |
404 |
client_socket.inner(), |
|
14714 | 405 |
Token(client_id), |
14478 | 406 |
Ready::readable() | Ready::writable(), |
407 |
PollOpt::edge(), |
|
14937 | 408 |
)?; |
13119 | 409 |
|
14824 | 410 |
let client = NetworkClient::new( |
411 |
client_id, |
|
412 |
client_socket, |
|
413 |
addr, |
|
14828 | 414 |
create_ping_timeout(&mut self.timer, PING_PROBES_COUNT - 1, client_id), |
14824 | 415 |
); |
13119 | 416 |
info!("client {} ({}) added", client.id, client.peer_addr); |
417 |
entry.insert(client); |
|
14714 | 418 |
|
14937 | 419 |
Ok(client_id) |
13119 | 420 |
} |
421 |
||
14800
f43ab2bd76ae
add a thread for internal server IO and implement account checking with it
alfadur
parents:
14718
diff
changeset
|
422 |
fn handle_response(&mut self, mut response: handlers::Response, poll: &Poll) { |
14851
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
423 |
if response.is_empty() { |
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
424 |
return; |
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
425 |
} |
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
426 |
|
14693
6e6632068a33
Server action refactoring part 3 of N
alfadur <mail@none>
parents:
14692
diff
changeset
|
427 |
debug!("{} pending server messages", response.len()); |
15542 | 428 |
let output = response.extract_messages(&mut self.server_state.server); |
14693
6e6632068a33
Server action refactoring part 3 of N
alfadur <mail@none>
parents:
14692
diff
changeset
|
429 |
for (clients, message) in output { |
13419 | 430 |
debug!("Message {:?} to {:?}", message, clients); |
431 |
let msg_string = message.to_raw_protocol(); |
|
432 |
for client_id in clients { |
|
433 |
if let Some(client) = self.clients.get_mut(client_id) { |
|
434 |
client.send_string(&msg_string); |
|
14478 | 435 |
self.pending |
436 |
.insert((client_id, NetworkClientState::NeedsWrite)); |
|
13414 | 437 |
} |
438 |
} |
|
439 |
} |
|
14717 | 440 |
|
441 |
for client_id in response.extract_removed_clients() { |
|
15196 | 442 |
self.deregister_client(poll, client_id, false); |
14717 | 443 |
} |
14800
f43ab2bd76ae
add a thread for internal server IO and implement account checking with it
alfadur
parents:
14718
diff
changeset
|
444 |
|
f43ab2bd76ae
add a thread for internal server IO and implement account checking with it
alfadur
parents:
14718
diff
changeset
|
445 |
#[cfg(feature = "official-server")] |
f43ab2bd76ae
add a thread for internal server IO and implement account checking with it
alfadur
parents:
14718
diff
changeset
|
446 |
{ |
f43ab2bd76ae
add a thread for internal server IO and implement account checking with it
alfadur
parents:
14718
diff
changeset
|
447 |
let client_id = response.client_id(); |
f43ab2bd76ae
add a thread for internal server IO and implement account checking with it
alfadur
parents:
14718
diff
changeset
|
448 |
for task in response.extract_io_tasks() { |
f43ab2bd76ae
add a thread for internal server IO and implement account checking with it
alfadur
parents:
14718
diff
changeset
|
449 |
self.io.send(client_id, task); |
f43ab2bd76ae
add a thread for internal server IO and implement account checking with it
alfadur
parents:
14718
diff
changeset
|
450 |
} |
f43ab2bd76ae
add a thread for internal server IO and implement account checking with it
alfadur
parents:
14718
diff
changeset
|
451 |
} |
f43ab2bd76ae
add a thread for internal server IO and implement account checking with it
alfadur
parents:
14718
diff
changeset
|
452 |
} |
f43ab2bd76ae
add a thread for internal server IO and implement account checking with it
alfadur
parents:
14718
diff
changeset
|
453 |
|
14824 | 454 |
pub fn handle_timeout(&mut self, poll: &Poll) -> io::Result<()> { |
455 |
while let Some(TimerData(event, client_id)) = self.timer.poll() { |
|
456 |
match event { |
|
14828 | 457 |
TimeoutEvent::SendPing { probes_count } => { |
14824 | 458 |
if let Some(ref mut client) = self.clients.get_mut(client_id) { |
15096 | 459 |
client.send_string(&HwServerMessage::Ping.to_raw_protocol()); |
14824 | 460 |
client.write()?; |
14828 | 461 |
let timeout = if probes_count != 0 { |
462 |
create_ping_timeout(&mut self.timer, probes_count - 1, client_id) |
|
463 |
} else { |
|
464 |
create_drop_timeout(&mut self.timer, client_id) |
|
465 |
}; |
|
466 |
client.replace_timeout(timeout); |
|
14824 | 467 |
} |
468 |
} |
|
469 |
TimeoutEvent::DropClient => { |
|
15196 | 470 |
if let Some(ref mut client) = self.clients.get_mut(client_id) { |
471 |
client.send_string( |
|
472 |
&HwServerMessage::Bye("Ping timeout".to_string()).to_raw_protocol(), |
|
473 |
); |
|
474 |
client.write(); |
|
475 |
} |
|
14824 | 476 |
self.operation_failed( |
477 |
poll, |
|
478 |
client_id, |
|
479 |
&ErrorKind::TimedOut.into(), |
|
480 |
"No ping response", |
|
481 |
)?; |
|
482 |
} |
|
483 |
} |
|
484 |
} |
|
485 |
Ok(()) |
|
486 |
} |
|
487 |
||
14800
f43ab2bd76ae
add a thread for internal server IO and implement account checking with it
alfadur
parents:
14718
diff
changeset
|
488 |
#[cfg(feature = "official-server")] |
15123 | 489 |
pub fn handle_io_result(&mut self, poll: &Poll) -> io::Result<()> { |
490 |
while let Some((client_id, result)) = self.io.try_recv() { |
|
491 |
debug!("Handling io result {:?} for client {}", result, client_id); |
|
14800
f43ab2bd76ae
add a thread for internal server IO and implement account checking with it
alfadur
parents:
14718
diff
changeset
|
492 |
let mut response = handlers::Response::new(client_id); |
f43ab2bd76ae
add a thread for internal server IO and implement account checking with it
alfadur
parents:
14718
diff
changeset
|
493 |
handlers::handle_io_result(&mut self.server, client_id, &mut response, result); |
15123 | 494 |
self.handle_response(response, poll); |
14800
f43ab2bd76ae
add a thread for internal server IO and implement account checking with it
alfadur
parents:
14718
diff
changeset
|
495 |
} |
14937 | 496 |
Ok(()) |
13414 | 497 |
} |
498 |
||
13773 | 499 |
fn create_client_socket(&self, socket: TcpStream) -> io::Result<ClientSocket> { |
14851
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
500 |
Ok(ClientSocket::Plain(socket)) |
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
501 |
} |
13773 | 502 |
|
14851
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
503 |
#[cfg(feature = "tls-connections")] |
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
504 |
fn create_client_secure_socket(&self, socket: TcpStream) -> io::Result<ClientSocket> { |
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
505 |
let ssl = Ssl::new(&self.ssl.context).unwrap(); |
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
506 |
let mut builder = SslStreamBuilder::new(ssl, socket); |
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
507 |
builder.set_accept_state(); |
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
508 |
match builder.handshake() { |
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
509 |
Ok(stream) => Ok(ClientSocket::SslStream(stream)), |
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
510 |
Err(HandshakeError::WouldBlock(stream)) => Ok(ClientSocket::SslHandshake(Some(stream))), |
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
511 |
Err(e) => { |
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
512 |
debug!("OpenSSL handshake failed: {}", e); |
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
513 |
Err(Error::new(ErrorKind::Other, "Connection failure")) |
13773 | 514 |
} |
515 |
} |
|
516 |
} |
|
517 |
||
14856 | 518 |
fn init_client(&mut self, poll: &Poll, client_id: ClientId) { |
519 |
let mut response = handlers::Response::new(client_id); |
|
14868 | 520 |
|
521 |
if let ClientSocket::Plain(_) = self.clients[client_id].socket { |
|
522 |
#[cfg(feature = "tls-connections")] |
|
523 |
response.add(Redirect(self.ssl.listener.local_addr().unwrap().port()).send_self()) |
|
524 |
} |
|
14856 | 525 |
|
15539 | 526 |
if let IpAddr::V4(addr) = self.clients[client_id].peer_addr.ip() { |
527 |
handlers::handle_client_accept( |
|
15542 | 528 |
&mut self.server_state, |
15539 | 529 |
client_id, |
530 |
&mut response, |
|
531 |
addr.octets(), |
|
532 |
addr.is_loopback(), |
|
533 |
); |
|
534 |
self.handle_response(response, poll); |
|
535 |
} else { |
|
536 |
todo!("implement something") |
|
537 |
} |
|
14856 | 538 |
} |
539 |
||
14851
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
540 |
pub fn accept_client(&mut self, poll: &Poll, server_token: mio::Token) -> io::Result<()> { |
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
541 |
match server_token { |
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
542 |
utils::SERVER_TOKEN => { |
14891 | 543 |
let (client_socket, addr) = self.listener.accept()?; |
544 |
info!("Connected(plaintext): {}", addr); |
|
14851
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
545 |
let client_id = |
14937 | 546 |
self.register_client(poll, self.create_client_socket(client_socket)?, addr)?; |
14856 | 547 |
self.init_client(poll, client_id); |
14851
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
548 |
} |
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
549 |
#[cfg(feature = "tls-connections")] |
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
550 |
utils::SECURE_SERVER_TOKEN => { |
14891 | 551 |
let (client_socket, addr) = self.ssl.listener.accept()?; |
552 |
info!("Connected(TLS): {}", addr); |
|
14937 | 553 |
self.register_client(poll, self.create_client_secure_socket(client_socket)?, addr)?; |
14851
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
554 |
} |
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
555 |
_ => unreachable!(), |
14714 | 556 |
} |
13119 | 557 |
|
558 |
Ok(()) |
|
559 |
} |
|
560 |
||
14478 | 561 |
fn operation_failed( |
562 |
&mut self, |
|
563 |
poll: &Poll, |
|
564 |
client_id: ClientId, |
|
565 |
error: &Error, |
|
566 |
msg: &str, |
|
567 |
) -> io::Result<()> { |
|
13414 | 568 |
let addr = if let Some(ref mut client) = self.clients.get_mut(client_id) { |
569 |
client.peer_addr |
|
570 |
} else { |
|
571 |
SocketAddr::new(IpAddr::V4(Ipv4Addr::new(0, 0, 0, 0)), 0) |
|
572 |
}; |
|
573 |
debug!("{}({}): {}", msg, addr, error); |
|
574 |
self.client_error(poll, client_id) |
|
13119 | 575 |
} |
576 |
||
14478 | 577 |
pub fn client_readable(&mut self, poll: &Poll, client_id: ClientId) -> io::Result<()> { |
578 |
let messages = if let Some(ref mut client) = self.clients.get_mut(client_id) { |
|
14828 | 579 |
let timeout = client.replace_timeout(create_ping_timeout( |
580 |
&mut self.timer, |
|
581 |
PING_PROBES_COUNT - 1, |
|
582 |
client_id, |
|
583 |
)); |
|
14824 | 584 |
self.timer.cancel_timeout(&timeout); |
14478 | 585 |
client.read() |
586 |
} else { |
|
587 |
warn!("invalid readable client: {}", client_id); |
|
588 |
Ok((Vec::new(), NetworkClientState::Idle)) |
|
589 |
}; |
|
13414 | 590 |
|
14692
455865ccd36c
Server action refactoring part 2 of N
alfadur <mail@none>
parents:
14478
diff
changeset
|
591 |
let mut response = handlers::Response::new(client_id); |
455865ccd36c
Server action refactoring part 2 of N
alfadur <mail@none>
parents:
14478
diff
changeset
|
592 |
|
13414 | 593 |
match messages { |
594 |
Ok((messages, state)) => { |
|
595 |
for message in messages { |
|
14692
455865ccd36c
Server action refactoring part 2 of N
alfadur <mail@none>
parents:
14478
diff
changeset
|
596 |
debug!("Handling message {:?} for client {}", message, client_id); |
15542 | 597 |
handlers::handle(&mut self.server_state, client_id, &mut response, message); |
13414 | 598 |
} |
599 |
match state { |
|
13415 | 600 |
NetworkClientState::NeedsRead => { |
601 |
self.pending.insert((client_id, state)); |
|
14478 | 602 |
} |
603 |
NetworkClientState::Closed => self.client_error(&poll, client_id)?, |
|
14851
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
604 |
#[cfg(feature = "tls-connections")] |
14856 | 605 |
NetworkClientState::Connected => self.init_client(poll, client_id), |
13414 | 606 |
_ => {} |
607 |
}; |
|
13119 | 608 |
} |
13414 | 609 |
Err(e) => self.operation_failed( |
14478 | 610 |
poll, |
611 |
client_id, |
|
612 |
&e, |
|
613 |
"Error while reading from client socket", |
|
614 |
)?, |
|
13119 | 615 |
} |
616 |
||
14851
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
617 |
self.handle_response(response, poll); |
13119 | 618 |
|
619 |
Ok(()) |
|
620 |
} |
|
621 |
||
14478 | 622 |
pub fn client_writable(&mut self, poll: &Poll, client_id: ClientId) -> io::Result<()> { |
623 |
let result = if let Some(ref mut client) = self.clients.get_mut(client_id) { |
|
624 |
client.write() |
|
625 |
} else { |
|
626 |
warn!("invalid writable client: {}", client_id); |
|
627 |
Ok(((), NetworkClientState::Idle)) |
|
628 |
}; |
|
13414 | 629 |
|
630 |
match result { |
|
13415 | 631 |
Ok(((), state)) if state == NetworkClientState::NeedsWrite => { |
632 |
self.pending.insert((client_id, state)); |
|
14478 | 633 |
} |
15195
e705ac360785
pin removed clients until the output buffer is flushed
alfadur
parents:
15194
diff
changeset
|
634 |
Ok(((), state)) if state == NetworkClientState::Closed => { |
15196 | 635 |
self.deregister_client(poll, client_id, false); |
15195
e705ac360785
pin removed clients until the output buffer is flushed
alfadur
parents:
15194
diff
changeset
|
636 |
} |
e705ac360785
pin removed clients until the output buffer is flushed
alfadur
parents:
15194
diff
changeset
|
637 |
Ok(_) => (), |
14478 | 638 |
Err(e) => { |
639 |
self.operation_failed(poll, client_id, &e, "Error while writing to client socket")? |
|
640 |
} |
|
13119 | 641 |
} |
642 |
||
643 |
Ok(()) |
|
644 |
} |
|
645 |
||
14478 | 646 |
pub fn client_error(&mut self, poll: &Poll, client_id: ClientId) -> io::Result<()> { |
15196 | 647 |
let pending_close = self.clients[client_id].pending_close; |
648 |
self.deregister_client(poll, client_id, true); |
|
649 |
||
650 |
if !pending_close { |
|
651 |
let mut response = handlers::Response::new(client_id); |
|
15542 | 652 |
handlers::handle_client_loss(&mut self.server_state, client_id, &mut response); |
15196 | 653 |
self.handle_response(response, poll); |
654 |
} |
|
13119 | 655 |
|
656 |
Ok(()) |
|
657 |
} |
|
13414 | 658 |
|
659 |
pub fn has_pending_operations(&self) -> bool { |
|
660 |
!self.pending.is_empty() |
|
661 |
} |
|
662 |
||
663 |
pub fn on_idle(&mut self, poll: &Poll) -> io::Result<()> { |
|
13415 | 664 |
if self.has_pending_operations() { |
13450 | 665 |
let mut cache = replace(&mut self.pending_cache, Vec::new()); |
13415 | 666 |
cache.extend(self.pending.drain()); |
667 |
for (id, state) in cache.drain(..) { |
|
668 |
match state { |
|
14478 | 669 |
NetworkClientState::NeedsRead => self.client_readable(poll, id)?, |
670 |
NetworkClientState::NeedsWrite => self.client_writable(poll, id)?, |
|
13415 | 671 |
_ => {} |
672 |
} |
|
13414 | 673 |
} |
13415 | 674 |
swap(&mut cache, &mut self.pending_cache); |
13414 | 675 |
} |
676 |
Ok(()) |
|
677 |
} |
|
13119 | 678 |
} |
14851
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
679 |
|
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
680 |
pub struct NetworkLayerBuilder { |
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
681 |
listener: Option<TcpListener>, |
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
682 |
secure_listener: Option<TcpListener>, |
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
683 |
clients_capacity: usize, |
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
684 |
rooms_capacity: usize, |
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
685 |
} |
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
686 |
|
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
687 |
impl Default for NetworkLayerBuilder { |
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
688 |
fn default() -> Self { |
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
689 |
Self { |
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
690 |
clients_capacity: 1024, |
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
691 |
rooms_capacity: 512, |
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
692 |
listener: None, |
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
693 |
secure_listener: None, |
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
694 |
} |
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
695 |
} |
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
696 |
} |
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
697 |
|
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
698 |
impl NetworkLayerBuilder { |
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
699 |
pub fn with_listener(self, listener: TcpListener) -> Self { |
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
700 |
Self { |
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
701 |
listener: Some(listener), |
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
702 |
..self |
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
703 |
} |
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
704 |
} |
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
705 |
|
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
706 |
pub fn with_secure_listener(self, listener: TcpListener) -> Self { |
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
707 |
Self { |
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
708 |
secure_listener: Some(listener), |
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
709 |
..self |
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
710 |
} |
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
711 |
} |
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
712 |
|
14856 | 713 |
#[cfg(feature = "tls-connections")] |
714 |
fn create_ssl_context(listener: TcpListener) -> ServerSsl { |
|
715 |
let mut builder = SslContextBuilder::new(SslMethod::tls()).unwrap(); |
|
716 |
builder.set_verify(SslVerifyMode::NONE); |
|
717 |
builder.set_read_ahead(true); |
|
718 |
builder |
|
719 |
.set_certificate_file("ssl/cert.pem", SslFiletype::PEM) |
|
720 |
.expect("Cannot find certificate file"); |
|
721 |
builder |
|
722 |
.set_private_key_file("ssl/key.pem", SslFiletype::PEM) |
|
723 |
.expect("Cannot find private key file"); |
|
724 |
builder.set_options(SslOptions::NO_COMPRESSION); |
|
15552 | 725 |
builder.set_options(SslOptions::NO_TLSV1_0); |
726 |
builder.set_options(SslOptions::NO_TLSV1_1); |
|
727 |
builder.set_cipher_list("ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384").unwrap(); |
|
14856 | 728 |
ServerSsl { |
729 |
listener, |
|
730 |
context: builder.build(), |
|
731 |
} |
|
732 |
} |
|
733 |
||
14851
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
734 |
pub fn build(self) -> NetworkLayer { |
15542 | 735 |
let server_state = ServerState::new(self.clients_capacity, self.rooms_capacity); |
736 |
||
14851
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
737 |
let clients = Slab::with_capacity(self.clients_capacity); |
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
738 |
let pending = HashSet::with_capacity(2 * self.clients_capacity); |
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
739 |
let pending_cache = Vec::with_capacity(2 * self.clients_capacity); |
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
740 |
let timer = timer::Builder::default().build(); |
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
741 |
|
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
742 |
NetworkLayer { |
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
743 |
listener: self.listener.expect("No listener provided"), |
15542 | 744 |
server_state, |
14851
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
745 |
clients, |
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
746 |
pending, |
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
747 |
pending_cache, |
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
748 |
#[cfg(feature = "tls-connections")] |
14856 | 749 |
ssl: Self::create_ssl_context( |
14851
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
750 |
self.secure_listener.expect("No secure listener provided"), |
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
751 |
), |
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
752 |
#[cfg(feature = "official-server")] |
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
753 |
io: IoLayer::new(), |
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
754 |
timer, |
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
755 |
} |
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
756 |
} |
8ddb5842fe0b
allow running plaintext and tls servers in parallel
alfadur
parents:
14828
diff
changeset
|
757 |
} |