rust/hedgewars-server/src/server/handlers.rs
changeset 14785 a1077e8d26f4
parent 14784 8390d5e4e39c
child 14786 8ecdb5c6bb2a
equal deleted inserted replaced
14784:8390d5e4e39c 14785:a1077e8d26f4
     2 use std::{collections::HashMap, io, io::Write};
     2 use std::{collections::HashMap, io, io::Write};
     3 
     3 
     4 use super::{
     4 use super::{
     5     actions::{Destination, DestinationRoom},
     5     actions::{Destination, DestinationRoom},
     6     core::HWServer,
     6     core::HWServer,
     7     coretypes::{ClientId, RoomId},
     7     coretypes::{ClientId, Replay, RoomId},
     8     room::RoomSave,
     8     room::RoomSave,
     9 };
     9 };
    10 use crate::{
    10 use crate::{
    11     protocol::messages::{server_chat, HWProtocolMessage, HWServerMessage, HWServerMessage::*},
    11     protocol::messages::{server_chat, HWProtocolMessage, HWServerMessage, HWServerMessage::*},
    12     server::actions::PendingMessage,
    12     server::actions::PendingMessage,
    22 mod lobby;
    22 mod lobby;
    23 mod loggingin;
    23 mod loggingin;
    24 
    24 
    25 use self::loggingin::LoginResult;
    25 use self::loggingin::LoginResult;
    26 use crate::protocol::messages::global_chat;
    26 use crate::protocol::messages::global_chat;
       
    27 use crate::protocol::messages::HWProtocolMessage::EngineMessage;
       
    28 use crate::server::coretypes::{GameCfg, TeamInfo};
    27 use std::fmt::{Formatter, LowerHex};
    29 use std::fmt::{Formatter, LowerHex};
    28 
    30 
    29 #[derive(PartialEq)]
    31 #[derive(PartialEq)]
    30 pub struct Sha1Digest([u8; 20]);
    32 pub struct Sha1Digest([u8; 20]);
    31 
    33 
    56         nick: String,
    58         nick: String,
    57         protocol: u16,
    59         protocol: u16,
    58         password_hash: String,
    60         password_hash: String,
    59         client_salt: String,
    61         client_salt: String,
    60         server_salt: String,
    62         server_salt: String,
       
    63     },
       
    64     GetReplay {
       
    65         id: u32,
    61     },
    66     },
    62     SaveRoom {
    67     SaveRoom {
    63         room_id: RoomId,
    68         room_id: RoomId,
    64         filename: String,
    69         filename: String,
    65         contents: String,
    70         contents: String,
    70     },
    75     },
    71 }
    76 }
    72 
    77 
    73 pub enum IoResult {
    78 pub enum IoResult {
    74     Account(Option<AccountInfo>),
    79     Account(Option<AccountInfo>),
       
    80     Replay(Option<Replay>),
    75     SaveRoom(RoomId, bool),
    81     SaveRoom(RoomId, bool),
    76     LoadRoom(RoomId, Option<String>),
    82     LoadRoom(RoomId, Option<String>),
    77 }
    83 }
    78 
    84 
    79 pub struct Response {
    85 pub struct Response {
   214                         common::remove_client(server, response, "User quit: ".to_string() + &msg);
   220                         common::remove_client(server, response, "User quit: ".to_string() + &msg);
   215                     }
   221                     }
   216                     HWProtocolMessage::Quit(None) => {
   222                     HWProtocolMessage::Quit(None) => {
   217                         common::remove_client(server, response, "User quit".to_string());
   223                         common::remove_client(server, response, "User quit".to_string());
   218                     }
   224                     }
   219                     HWProtocolMessage::Global(msg) => response.add(global_chat(msg).send_all()),
   225                     HWProtocolMessage::Global(msg) => {
       
   226                         if !server.clients[client_id].is_admin() {
       
   227                             response.add(Warning("Access denied.".to_string()).send_self());
       
   228                         } else {
       
   229                             response.add(global_chat(msg).send_all())
       
   230                         }
       
   231                     }
       
   232                     HWProtocolMessage::Watch(id) => {
       
   233                         #[cfg(feature = "official-server")]
       
   234                         {
       
   235                             response.request_io(IoTask::GetReplay { id })
       
   236                         }
       
   237 
       
   238                         #[cfg(not(feature = "official-server"))]
       
   239                         {
       
   240                             response.add(
       
   241                                 Warning("This server does not support replays!".to_string())
       
   242                                     .send_self(),
       
   243                             );
       
   244                         }
       
   245                     }
   220                     _ => match server.clients[client_id].room_id {
   246                     _ => match server.clients[client_id].room_id {
   221                         None => lobby::handle(server, client_id, response, message),
   247                         None => lobby::handle(server, client_id, response, message),
   222                         Some(room_id) => {
   248                         Some(room_id) => {
   223                             inroom::handle(server, client_id, response, room_id, message)
   249                             inroom::handle(server, client_id, response, room_id, message)
   224                         }
   250                         }
   262         }
   288         }
   263         IoResult::Account(None) => {
   289         IoResult::Account(None) => {
   264             response.add(Error("Authentication failed.".to_string()).send_self());
   290             response.add(Error("Authentication failed.".to_string()).send_self());
   265             response.remove_client(client_id);
   291             response.remove_client(client_id);
   266         }
   292         }
       
   293         IoResult::Replay(Some(replay)) => {
       
   294             response.add(RoomJoined(vec![server.clients[client_id].nick.clone()]).send_self());
       
   295             common::get_room_config_impl(&replay.config, client_id, response);
       
   296             common::get_teams(replay.teams.iter(), client_id, response);
       
   297             response.add(RunGame.send_self());
       
   298             response.add(ForwardEngineMessage(replay.message_log).send_self());
       
   299             response.add(Kicked.send_self());
       
   300         }
       
   301         IoResult::Replay(None) => {
       
   302             response.add(Warning("Could't load the replay".to_string()).send_self())
       
   303         }
   267         IoResult::SaveRoom(_, true) => {
   304         IoResult::SaveRoom(_, true) => {
   268             response.add(server_chat("Room configs saved successfully.".to_string()).send_self());
   305             response.add(server_chat("Room configs saved successfully.".to_string()).send_self());
   269         }
   306         }
   270         IoResult::SaveRoom(_, false) => {
   307         IoResult::SaveRoom(_, false) => {
   271             response.add(Warning("Unable to save the room configs.".to_string()).send_self());
   308             response.add(Warning("Unable to save the room configs.".to_string()).send_self());