rust/hedgewars-server/src/handlers/inanteroom.rs
changeset 15532 f1205f33bf5b
parent 15520 fd3a20e9d095
child 15536 a798e6441a36
equal deleted inserted replaced
15531:ede5f4ec48f3 15532:f1205f33bf5b
     1 use mio;
     1 use mio;
     2 
     2 
       
     3 use super::strings::*;
     3 use crate::{
     4 use crate::{
     4     core::{
     5     core::{
     5         anteroom::{HwAnteroom, HwAnteroomClient},
     6         anteroom::{HwAnteroom, HwAnteroomClient},
     6         client::HwClient,
     7         client::HwClient,
     7         server::HwServer,
     8         server::HwServer,
    31     response: &mut super::Response,
    32     response: &mut super::Response,
    32 ) -> LoginResult
    33 ) -> LoginResult
    33 where
    34 where
    34     I: Iterator<Item = &'a HwClient>,
    35     I: Iterator<Item = &'a HwClient>,
    35 {
    36 {
    36     let has_nick_clash =
    37     let has_nick_clash = other_clients.any(|c| c.nick == *client.nick.as_ref().unwrap());
    37         other_clients.any(|c| !c.is_checker() && c.nick == *client.nick.as_ref().unwrap());
       
    38 
    38 
    39     if has_nick_clash {
    39     if has_nick_clash {
    40         if client.protocol_number.unwrap().get() < 38 {
    40         client.nick = None;
    41             response.add(Bye("User quit: Nickname is already in use".to_string()).send_self());
    41         response.add(Notice("NickAlreadyInUse".to_string()).send_self());
    42             LoginResult::Exit
    42         LoginResult::Unchanged
    43         } else {
       
    44             client.nick = None;
       
    45             response.add(Notice("NickAlreadyInUse".to_string()).send_self());
       
    46             LoginResult::Unchanged
       
    47         }
       
    48     } else {
    43     } else {
    49         #[cfg(feature = "official-server")]
    44         #[cfg(feature = "official-server")]
    50         {
    45         {
    51             response.request_io(super::IoTask::CheckRegistered {
    46             response.request_io(super::IoTask::CheckRegistered {
    52                 nick: client.nick.as_ref().unwrap().clone(),
    47                 nick: client.nick.as_ref().unwrap().clone(),
    74         }
    69         }
    75         HwProtocolMessage::Nick(nick) => {
    70         HwProtocolMessage::Nick(nick) => {
    76             let client = &mut server_state.anteroom.clients[client_id];
    71             let client = &mut server_state.anteroom.clients[client_id];
    77 
    72 
    78             if client.nick.is_some() {
    73             if client.nick.is_some() {
    79                 response.add(Error("Nickname already provided.".to_string()).send_self());
    74                 response.error(NICKNAME_PROVIDED);
    80                 LoginResult::Unchanged
    75                 LoginResult::Unchanged
    81             } else if is_name_illegal(&nick) {
    76             } else if is_name_illegal(&nick) {
    82                 response.add(Bye("Illegal nickname! Nicknames must be between 1-40 characters long, must not have a trailing or leading space and must not have any of these characters: $()*+?[]^{|}".to_string()).send_self());
    77                 response.add(Bye(ILLEGAL_CLIENT_NAME.to_string()).send_self());
    83                 LoginResult::Exit
    78                 LoginResult::Exit
    84             } else {
    79             } else {
    85                 client.nick = Some(nick.clone());
    80                 client.nick = Some(nick.clone());
    86                 response.add(Nick(nick).send_self());
    81                 response.add(Nick(nick).send_self());
    87 
    82 
    93             }
    88             }
    94         }
    89         }
    95         HwProtocolMessage::Proto(proto) => {
    90         HwProtocolMessage::Proto(proto) => {
    96             let client = &mut server_state.anteroom.clients[client_id];
    91             let client = &mut server_state.anteroom.clients[client_id];
    97             if client.protocol_number.is_some() {
    92             if client.protocol_number.is_some() {
    98                 response.add(Error("Protocol already known.".to_string()).send_self());
    93                 response.error(PROTOCOL_PROVIDED);
    99                 LoginResult::Unchanged
    94                 LoginResult::Unchanged
   100             } else if proto == 0 {
    95             } else if proto < 48 {
   101                 response.add(Error("Bad number.".to_string()).send_self());
    96                 response.add(Bye(PROTOCOL_TOO_OLD.to_string()).send_self());
   102                 LoginResult::Unchanged
    97                 LoginResult::Exit
   103             } else {
    98             } else {
   104                 client.protocol_number = NonZeroU16::new(proto);
    99                 client.protocol_number = NonZeroU16::new(proto);
   105                 response.add(Proto(proto).send_self());
   100                 response.add(Proto(proto).send_self());
   106 
   101 
   107                 if client.nick.is_some() {
   102                 if client.nick.is_some() {
   129         }
   124         }
   130         #[cfg(feature = "official-server")]
   125         #[cfg(feature = "official-server")]
   131         HwProtocolMessage::Checker(protocol, nick, password) => {
   126         HwProtocolMessage::Checker(protocol, nick, password) => {
   132             let client = &mut server_state.anteroom.clients[client_id];
   127             let client = &mut server_state.anteroom.clients[client_id];
   133             if protocol == 0 {
   128             if protocol == 0 {
   134                 response.add(Error("Bad number.".to_string()).send_self());
   129                 response.error("Bad number.");
   135                 LoginResult::Unchanged
   130                 LoginResult::Unchanged
   136             } else {
   131             } else {
   137                 client.protocol_number = NonZeroU16::new(protocol);
   132                 client.protocol_number = NonZeroU16::new(protocol);
   138                 client.nick = Some(nick);
       
   139                 client.is_checker = true;
   133                 client.is_checker = true;
   140                 LoginResult::Complete
   134                 #[cfg(not(feature = "official-server"))]
       
   135                 {
       
   136                     response.request_io(super::IoTask::GetCheckerAccount {
       
   137                         nick: nick,
       
   138                         password: password,
       
   139                     });
       
   140                     LoginResult::Unchanged
       
   141                 }
       
   142 
       
   143                 #[cfg(feature = "official-server")]
       
   144                 {
       
   145                     response.add(LogonPassed.send_self());
       
   146                     LoginResult::Complete
       
   147                 }
   141             }
   148             }
   142         }
   149         }
   143         _ => {
   150         _ => {
   144             warn!("Incorrect command in logging-in state");
   151             warn!("Incorrect command in anteroom");
   145             LoginResult::Unchanged
   152             LoginResult::Unchanged
   146         }
   153         }
   147     }
   154     }
   148 }
   155 }