rust/hedgewars-server/src/server/network.rs
changeset 14671 455865ccd36c
parent 14457 98ef2913ec73
child 14672 6e6632068a33
equal deleted inserted replaced
14670:56831f466d1d 14671:455865ccd36c
    14     Poll, PollOpt, Ready, Token,
    14     Poll, PollOpt, Ready, Token,
    15 };
    15 };
    16 use netbuf;
    16 use netbuf;
    17 use slab::Slab;
    17 use slab::Slab;
    18 
    18 
    19 use super::{core::HWServer, coretypes::ClientId, io::FileServerIO};
    19 use super::{core::HWServer, coretypes::ClientId, handlers, io::FileServerIO};
    20 use crate::{
    20 use crate::{
    21     protocol::{messages::*, ProtocolDecoder},
    21     protocol::{messages::*, ProtocolDecoder},
    22     utils,
    22     utils,
    23 };
    23 };
    24 #[cfg(feature = "tls-connections")]
    24 #[cfg(feature = "tls-connections")]
   176 
   176 
   177     fn write_impl<W: Write>(buf_out: &mut netbuf::Buf, destination: &mut W) -> NetworkResult<()> {
   177     fn write_impl<W: Write>(buf_out: &mut netbuf::Buf, destination: &mut W) -> NetworkResult<()> {
   178         let result = loop {
   178         let result = loop {
   179             match buf_out.write_to(destination) {
   179             match buf_out.write_to(destination) {
   180                 Ok(bytes) if buf_out.is_empty() || bytes == 0 => {
   180                 Ok(bytes) if buf_out.is_empty() || bytes == 0 => {
   181                     break Ok(((), NetworkClientState::Idle))
   181                     break Ok(((), NetworkClientState::Idle));
   182                 }
   182                 }
   183                 Ok(_) => (),
   183                 Ok(_) => (),
   184                 Err(ref error)
   184                 Err(ref error)
   185                     if error.kind() == ErrorKind::Interrupted
   185                     if error.kind() == ErrorKind::Interrupted
   186                         || error.kind() == ErrorKind::WouldBlock =>
   186                         || error.kind() == ErrorKind::WouldBlock =>
   404         } else {
   404         } else {
   405             warn!("invalid readable client: {}", client_id);
   405             warn!("invalid readable client: {}", client_id);
   406             Ok((Vec::new(), NetworkClientState::Idle))
   406             Ok((Vec::new(), NetworkClientState::Idle))
   407         };
   407         };
   408 
   408 
       
   409         let mut response = handlers::Response::new(client_id);
       
   410 
   409         match messages {
   411         match messages {
   410             Ok((messages, state)) => {
   412             Ok((messages, state)) => {
   411                 for message in messages {
   413                 for message in messages {
   412                     self.server.handle_msg(client_id, message);
   414                     debug!("Handling message {:?} for client {}", message, client_id);
       
   415                     if self.server.clients.contains(client_id) {
       
   416                         handlers::handle(&mut self.server, client_id, &mut response, message);
       
   417                     }
   413                 }
   418                 }
   414                 match state {
   419                 match state {
   415                     NetworkClientState::NeedsRead => {
   420                     NetworkClientState::NeedsRead => {
   416                         self.pending.insert((client_id, state));
   421                         self.pending.insert((client_id, state));
   417                     }
   422                     }