24 }; |
24 }; |
25 |
25 |
26 #[cfg(feature = "official-server")] |
26 #[cfg(feature = "official-server")] |
27 use super::io::{IOThread, RequestId}; |
27 use super::io::{IOThread, RequestId}; |
28 |
28 |
|
29 use crate::protocol::messages::HWServerMessage::Redirect; |
29 use crate::server::handlers::{IoResult, IoTask}; |
30 use crate::server::handlers::{IoResult, IoTask}; |
30 #[cfg(feature = "tls-connections")] |
31 #[cfg(feature = "tls-connections")] |
31 use openssl::{ |
32 use openssl::{ |
32 error::ErrorStack, |
33 error::ErrorStack, |
33 ssl::{ |
34 ssl::{ |
333 TimerData(TimeoutEvent::DropClient, client_id), |
334 TimerData(TimeoutEvent::DropClient, client_id), |
334 ) |
335 ) |
335 } |
336 } |
336 |
337 |
337 impl NetworkLayer { |
338 impl NetworkLayer { |
338 #[cfg(feature = "tls-connections")] |
|
339 fn create_ssl_context(listener: TcpListener) -> ServerSsl { |
|
340 let mut builder = SslContextBuilder::new(SslMethod::tls()).unwrap(); |
|
341 builder.set_verify(SslVerifyMode::NONE); |
|
342 builder.set_read_ahead(true); |
|
343 builder |
|
344 .set_certificate_file("ssl/cert.pem", SslFiletype::PEM) |
|
345 .unwrap(); |
|
346 builder |
|
347 .set_private_key_file("ssl/key.pem", SslFiletype::PEM) |
|
348 .unwrap(); |
|
349 builder.set_options(SslOptions::NO_COMPRESSION); |
|
350 builder.set_cipher_list("DEFAULT:!LOW:!RC4:!EXP").unwrap(); |
|
351 ServerSsl { |
|
352 listener, |
|
353 context: builder.build(), |
|
354 } |
|
355 } |
|
356 |
|
357 pub fn register(&self, poll: &Poll) -> io::Result<()> { |
339 pub fn register(&self, poll: &Poll) -> io::Result<()> { |
358 register_read(poll, &self.listener, utils::SERVER_TOKEN)?; |
340 register_read(poll, &self.listener, utils::SERVER_TOKEN)?; |
359 #[cfg(feature = "tls-connections")] |
341 #[cfg(feature = "tls-connections")] |
360 register_read(poll, &self.listener, utils::SECURE_SERVER_TOKEN)?; |
342 register_read(poll, &self.ssl.listener, utils::SECURE_SERVER_TOKEN)?; |
361 register_read(poll, &self.timer, utils::TIMER_TOKEN)?; |
343 register_read(poll, &self.timer, utils::TIMER_TOKEN)?; |
362 |
344 |
363 #[cfg(feature = "official-server")] |
345 #[cfg(feature = "official-server")] |
364 self.io.io_thread.register_rx(poll, utils::IO_TOKEN)?; |
346 self.io.io_thread.register_rx(poll, utils::IO_TOKEN)?; |
365 |
347 |
495 Err(Error::new(ErrorKind::Other, "Connection failure")) |
477 Err(Error::new(ErrorKind::Other, "Connection failure")) |
496 } |
478 } |
497 } |
479 } |
498 } |
480 } |
499 |
481 |
|
482 fn init_client(&mut self, poll: &Poll, client_id: ClientId) { |
|
483 let mut response = handlers::Response::new(client_id); |
|
484 #[cfg(feature = "tls-connections")] |
|
485 response.add(Redirect(self.ssl.listener.local_addr().unwrap().port()).send_self()); |
|
486 |
|
487 handlers::handle_client_accept(&mut self.server, client_id, &mut response); |
|
488 self.handle_response(response, poll); |
|
489 } |
|
490 |
500 pub fn accept_client(&mut self, poll: &Poll, server_token: mio::Token) -> io::Result<()> { |
491 pub fn accept_client(&mut self, poll: &Poll, server_token: mio::Token) -> io::Result<()> { |
501 let (client_socket, addr) = self.listener.accept()?; |
492 let (client_socket, addr) = self.listener.accept()?; |
502 info!("Connected: {}", addr); |
493 info!("Connected: {}", addr); |
503 |
494 |
504 match server_token { |
495 match server_token { |
505 utils::SERVER_TOKEN => { |
496 utils::SERVER_TOKEN => { |
506 let client_id = |
497 let client_id = |
507 self.register_client(poll, self.create_client_socket(client_socket)?, addr); |
498 self.register_client(poll, self.create_client_socket(client_socket)?, addr); |
508 let mut response = handlers::Response::new(client_id); |
499 self.init_client(poll, client_id); |
509 handlers::handle_client_accept(&mut self.server, client_id, &mut response); |
|
510 self.handle_response(response, poll); |
|
511 } |
500 } |
512 #[cfg(feature = "tls-connections")] |
501 #[cfg(feature = "tls-connections")] |
513 utils::SECURE_SERVER_TOKEN => { |
502 utils::SECURE_SERVER_TOKEN => { |
514 self.register_client(poll, self.create_client_secure_socket(client_socket)?, addr); |
503 self.register_client(poll, self.create_client_secure_socket(client_socket)?, addr); |
515 } |
504 } |
561 NetworkClientState::NeedsRead => { |
550 NetworkClientState::NeedsRead => { |
562 self.pending.insert((client_id, state)); |
551 self.pending.insert((client_id, state)); |
563 } |
552 } |
564 NetworkClientState::Closed => self.client_error(&poll, client_id)?, |
553 NetworkClientState::Closed => self.client_error(&poll, client_id)?, |
565 #[cfg(feature = "tls-connections")] |
554 #[cfg(feature = "tls-connections")] |
566 NetworkClientState::Connected => { |
555 NetworkClientState::Connected => self.init_client(poll, client_id), |
567 let mut response = handlers::Response::new(client_id); |
|
568 handlers::handle_client_accept(&mut self.server, client_id, &mut response); |
|
569 self.handle_response(response, poll); |
|
570 } |
|
571 _ => {} |
556 _ => {} |
572 }; |
557 }; |
573 } |
558 } |
574 Err(e) => self.operation_failed( |
559 Err(e) => self.operation_failed( |
575 poll, |
560 poll, |
666 secure_listener: Some(listener), |
651 secure_listener: Some(listener), |
667 ..self |
652 ..self |
668 } |
653 } |
669 } |
654 } |
670 |
655 |
|
656 #[cfg(feature = "tls-connections")] |
|
657 fn create_ssl_context(listener: TcpListener) -> ServerSsl { |
|
658 let mut builder = SslContextBuilder::new(SslMethod::tls()).unwrap(); |
|
659 builder.set_verify(SslVerifyMode::NONE); |
|
660 builder.set_read_ahead(true); |
|
661 builder |
|
662 .set_certificate_file("ssl/cert.pem", SslFiletype::PEM) |
|
663 .expect("Cannot find certificate file"); |
|
664 builder |
|
665 .set_private_key_file("ssl/key.pem", SslFiletype::PEM) |
|
666 .expect("Cannot find private key file"); |
|
667 builder.set_options(SslOptions::NO_COMPRESSION); |
|
668 builder.set_cipher_list("DEFAULT:!LOW:!RC4:!EXP").unwrap(); |
|
669 ServerSsl { |
|
670 listener, |
|
671 context: builder.build(), |
|
672 } |
|
673 } |
|
674 |
671 pub fn build(self) -> NetworkLayer { |
675 pub fn build(self) -> NetworkLayer { |
672 let server = HWServer::new(self.clients_capacity, self.rooms_capacity); |
676 let server = HWServer::new(self.clients_capacity, self.rooms_capacity); |
673 let clients = Slab::with_capacity(self.clients_capacity); |
677 let clients = Slab::with_capacity(self.clients_capacity); |
674 let pending = HashSet::with_capacity(2 * self.clients_capacity); |
678 let pending = HashSet::with_capacity(2 * self.clients_capacity); |
675 let pending_cache = Vec::with_capacity(2 * self.clients_capacity); |
679 let pending_cache = Vec::with_capacity(2 * self.clients_capacity); |