gameServer2/src/server/handlers/loggingin.rs
changeset 14420 06672690d71b
parent 14419 6843c4551cde
child 14421 96624a6cdb93
equal deleted inserted replaced
14419:6843c4551cde 14420:06672690d71b
     1 use mio;
       
     2 
       
     3 use crate::{
       
     4     server::{
       
     5         client::HWClient,
       
     6         core::HWServer,
       
     7         coretypes::ClientId,
       
     8         actions::{Action, Action::*}
       
     9     },
       
    10     protocol::messages::{
       
    11         HWProtocolMessage, HWServerMessage::*
       
    12     },
       
    13     utils::is_name_illegal
       
    14 };
       
    15 #[cfg(feature = "official-server")]
       
    16 use openssl::sha::sha1;
       
    17 use std::fmt::{Formatter, LowerHex};
       
    18 use log::*;
       
    19 
       
    20 #[derive(PartialEq)]
       
    21 struct Sha1Digest([u8; 20]);
       
    22 
       
    23 impl LowerHex for Sha1Digest {
       
    24     fn fmt(&self, f: &mut Formatter) -> Result<(), std::fmt::Error> {
       
    25         for byte in &self.0 {
       
    26             write!(f, "{:02x}", byte)?;
       
    27         }
       
    28         Ok(())
       
    29     }
       
    30 }
       
    31 
       
    32 #[cfg(feature = "official-server")]
       
    33 fn get_hash(client: &HWClient, salt1: &str, salt2: &str) -> Sha1Digest {
       
    34     let s = format!("{}{}{}{}{}", salt1, salt2,
       
    35                     client.web_password, client.protocol_number, "!hedgewars");
       
    36     Sha1Digest(sha1(s.as_bytes()))
       
    37 }
       
    38 
       
    39 pub fn handle(server: & mut HWServer, client_id: ClientId, message: HWProtocolMessage) {
       
    40     match message {
       
    41         HWProtocolMessage::Nick(nick) => {
       
    42             let client = &mut server.clients[client_id];
       
    43             debug!("{} {}", nick, is_name_illegal(&nick));
       
    44             let actions = if client.room_id != None {
       
    45                 unreachable!()
       
    46             }
       
    47             else if !client.nick.is_empty() {
       
    48                 vec![ProtocolError("Nickname already provided.".to_string())]
       
    49             }
       
    50             else if is_name_illegal(&nick) {
       
    51                 vec![ByeClient("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())]
       
    52             }
       
    53             else {
       
    54                 client.nick = nick.clone();
       
    55                 vec![Nick(nick).send_self().action(),
       
    56                      CheckRegistered]
       
    57             };
       
    58 
       
    59             server.react(client_id, actions);
       
    60         }
       
    61         HWProtocolMessage::Proto(proto) => {
       
    62             let client = &mut server.clients[client_id];
       
    63             let actions = if client.protocol_number != 0 {
       
    64                 vec![ProtocolError("Protocol already known.".to_string())]
       
    65             }
       
    66             else if proto == 0 {
       
    67                 vec![ProtocolError("Bad number.".to_string())]
       
    68             }
       
    69             else {
       
    70                 client.protocol_number = proto;
       
    71                 vec![Proto(proto).send_self().action(),
       
    72                      CheckRegistered]
       
    73             };
       
    74             server.react(client_id, actions);
       
    75         }
       
    76         #[cfg(feature = "official-server")]
       
    77         HWProtocolMessage::Password(hash, salt) => {
       
    78             let c = &server.clients[client_id];
       
    79 
       
    80             let client_hash = get_hash(c, &salt, &c.server_salt);
       
    81             let server_hash = get_hash(c, &c.server_salt, &salt);
       
    82             let actions = if client_hash == server_hash {
       
    83                 vec![ServerAuth(format!("{:x}", server_hash)).send_self().action(),
       
    84                      JoinLobby]
       
    85             } else {
       
    86                 vec![ByeClient("Authentication failed".to_string())]
       
    87             };
       
    88             server.react(client_id, actions);
       
    89         }
       
    90         #[cfg(feature = "official-server")]
       
    91         HWProtocolMessage::Checker(protocol, nick, password) => {
       
    92             let c = &mut server.clients[client_id];
       
    93             c.nick = nick;
       
    94             c.web_password = password;
       
    95             c.set_is_checker(true);
       
    96         }
       
    97         _ => warn!("Incorrect command in logging-in state"),
       
    98     }
       
    99 }