1 use mio; |
|
2 use std::{collections::HashMap, io, io::Write}; |
|
3 |
|
4 use super::{ |
|
5 actions::{Destination, DestinationGroup}, |
|
6 core::HWServer, |
|
7 coretypes::{ClientId, Replay, RoomId}, |
|
8 room::RoomSave, |
|
9 }; |
|
10 use crate::{ |
|
11 protocol::messages::{server_chat, HWProtocolMessage, HWServerMessage, HWServerMessage::*}, |
|
12 server::actions::PendingMessage, |
|
13 utils, |
|
14 }; |
|
15 use base64::encode; |
|
16 use log::*; |
|
17 use rand::{thread_rng, RngCore}; |
|
18 |
|
19 mod checker; |
|
20 mod common; |
|
21 mod inroom; |
|
22 mod lobby; |
|
23 mod loggingin; |
|
24 |
|
25 use self::loggingin::LoginResult; |
|
26 use crate::protocol::messages::global_chat; |
|
27 use crate::protocol::messages::HWProtocolMessage::EngineMessage; |
|
28 use crate::server::coretypes::{GameCfg, TeamInfo}; |
|
29 use std::fmt::{Formatter, LowerHex}; |
|
30 |
|
31 #[derive(PartialEq)] |
|
32 pub struct Sha1Digest([u8; 20]); |
|
33 |
|
34 impl Sha1Digest { |
|
35 pub fn new(digest: [u8; 20]) -> Self { |
|
36 Self(digest) |
|
37 } |
|
38 } |
|
39 |
|
40 impl LowerHex for Sha1Digest { |
|
41 fn fmt(&self, f: &mut Formatter) -> Result<(), std::fmt::Error> { |
|
42 for byte in &self.0 { |
|
43 write!(f, "{:02x}", byte)?; |
|
44 } |
|
45 Ok(()) |
|
46 } |
|
47 } |
|
48 |
|
49 pub struct AccountInfo { |
|
50 pub is_registered: bool, |
|
51 pub is_admin: bool, |
|
52 pub is_contributor: bool, |
|
53 pub server_hash: Sha1Digest, |
|
54 } |
|
55 |
|
56 pub enum IoTask { |
|
57 GetAccount { |
|
58 nick: String, |
|
59 protocol: u16, |
|
60 password_hash: String, |
|
61 client_salt: String, |
|
62 server_salt: String, |
|
63 }, |
|
64 GetReplay { |
|
65 id: u32, |
|
66 }, |
|
67 SaveRoom { |
|
68 room_id: RoomId, |
|
69 filename: String, |
|
70 contents: String, |
|
71 }, |
|
72 LoadRoom { |
|
73 room_id: RoomId, |
|
74 filename: String, |
|
75 }, |
|
76 } |
|
77 |
|
78 pub enum IoResult { |
|
79 Account(Option<AccountInfo>), |
|
80 Replay(Option<Replay>), |
|
81 SaveRoom(RoomId, bool), |
|
82 LoadRoom(RoomId, Option<String>), |
|
83 } |
|
84 |
|
85 pub struct Response { |
|
86 client_id: ClientId, |
|
87 messages: Vec<PendingMessage>, |
|
88 io_tasks: Vec<IoTask>, |
|
89 removed_clients: Vec<ClientId>, |
|
90 } |
|
91 |
|
92 impl Response { |
|
93 pub fn new(client_id: ClientId) -> Self { |
|
94 Self { |
|
95 client_id, |
|
96 messages: vec![], |
|
97 io_tasks: vec![], |
|
98 removed_clients: vec![], |
|
99 } |
|
100 } |
|
101 |
|
102 #[inline] |
|
103 pub fn is_empty(&self) -> bool { |
|
104 self.messages.is_empty() && self.removed_clients.is_empty() && self.io_tasks.is_empty() |
|
105 } |
|
106 |
|
107 #[inline] |
|
108 pub fn len(&self) -> usize { |
|
109 self.messages.len() |
|
110 } |
|
111 |
|
112 #[inline] |
|
113 pub fn client_id(&self) -> ClientId { |
|
114 self.client_id |
|
115 } |
|
116 |
|
117 #[inline] |
|
118 pub fn add(&mut self, message: PendingMessage) { |
|
119 self.messages.push(message) |
|
120 } |
|
121 |
|
122 #[inline] |
|
123 pub fn request_io(&mut self, task: IoTask) { |
|
124 self.io_tasks.push(task) |
|
125 } |
|
126 |
|
127 pub fn extract_messages<'a, 'b: 'a>( |
|
128 &'b mut self, |
|
129 server: &'a HWServer, |
|
130 ) -> impl Iterator<Item = (Vec<ClientId>, HWServerMessage)> + 'a { |
|
131 let client_id = self.client_id; |
|
132 self.messages.drain(..).map(move |m| { |
|
133 let ids = get_recipients(server, client_id, m.destination); |
|
134 (ids, m.message) |
|
135 }) |
|
136 } |
|
137 |
|
138 pub fn remove_client(&mut self, client_id: ClientId) { |
|
139 self.removed_clients.push(client_id); |
|
140 } |
|
141 |
|
142 pub fn extract_removed_clients(&mut self) -> impl Iterator<Item = ClientId> + '_ { |
|
143 self.removed_clients.drain(..) |
|
144 } |
|
145 |
|
146 pub fn extract_io_tasks(&mut self) -> impl Iterator<Item = IoTask> + '_ { |
|
147 self.io_tasks.drain(..) |
|
148 } |
|
149 } |
|
150 |
|
151 impl Extend<PendingMessage> for Response { |
|
152 fn extend<T: IntoIterator<Item = PendingMessage>>(&mut self, iter: T) { |
|
153 for msg in iter { |
|
154 self.add(msg) |
|
155 } |
|
156 } |
|
157 } |
|
158 |
|
159 fn get_recipients( |
|
160 server: &HWServer, |
|
161 client_id: ClientId, |
|
162 destination: Destination, |
|
163 ) -> Vec<ClientId> { |
|
164 match destination { |
|
165 Destination::ToSelf => vec![client_id], |
|
166 Destination::ToId(id) => vec![id], |
|
167 Destination::ToIds(ids) => ids, |
|
168 Destination::ToAll { group, skip_self } => { |
|
169 let mut ids: Vec<_> = match group { |
|
170 DestinationGroup::All => server.all_clients().collect(), |
|
171 DestinationGroup::Lobby => server.lobby_clients().collect(), |
|
172 DestinationGroup::Protocol(proto) => server.protocol_clients(proto).collect(), |
|
173 DestinationGroup::Room(id) => server.room_clients(id).collect(), |
|
174 }; |
|
175 |
|
176 if skip_self { |
|
177 if let Some(index) = ids.iter().position(|id| *id == client_id) { |
|
178 ids.remove(index); |
|
179 } |
|
180 } |
|
181 |
|
182 ids |
|
183 } |
|
184 } |
|
185 } |
|
186 |
|
187 pub fn handle( |
|
188 server: &mut HWServer, |
|
189 client_id: ClientId, |
|
190 response: &mut Response, |
|
191 message: HWProtocolMessage, |
|
192 ) { |
|
193 match message { |
|
194 HWProtocolMessage::Ping => response.add(Pong.send_self()), |
|
195 _ => { |
|
196 if server.anteroom.clients.contains(client_id) { |
|
197 match loggingin::handle(server, client_id, response, message) { |
|
198 LoginResult::Unchanged => (), |
|
199 LoginResult::Complete => { |
|
200 if let Some(client) = server.anteroom.remove_client(client_id) { |
|
201 server.add_client(client_id, client); |
|
202 common::join_lobby(server, response); |
|
203 } |
|
204 } |
|
205 LoginResult::Exit => { |
|
206 server.anteroom.remove_client(client_id); |
|
207 response.remove_client(client_id); |
|
208 } |
|
209 } |
|
210 } else if server.clients.contains(client_id) { |
|
211 match message { |
|
212 HWProtocolMessage::Quit(Some(msg)) => { |
|
213 common::remove_client(server, response, "User quit: ".to_string() + &msg); |
|
214 } |
|
215 HWProtocolMessage::Quit(None) => { |
|
216 common::remove_client(server, response, "User quit".to_string()); |
|
217 } |
|
218 HWProtocolMessage::Info(nick) => { |
|
219 if let Some(client) = server.find_client(&nick) { |
|
220 let admin_sign = if client.is_admin() { "@" } else { "" }; |
|
221 let master_sign = if client.is_master() { "+" } else { "" }; |
|
222 let room_info = match client.room_id { |
|
223 Some(room_id) => { |
|
224 let room = &server.rooms[room_id]; |
|
225 let status = match room.game_info { |
|
226 Some(_) if client.teams_in_game == 0 => "(spectating)", |
|
227 Some(_) => "(playing)", |
|
228 None => "", |
|
229 }; |
|
230 format!( |
|
231 "[{}{}room {}]{}", |
|
232 admin_sign, master_sign, room.name, status |
|
233 ) |
|
234 } |
|
235 None => format!("[{}lobby]", admin_sign), |
|
236 }; |
|
237 |
|
238 let info = vec![ |
|
239 client.nick.clone(), |
|
240 "[]".to_string(), |
|
241 utils::protocol_version_string(client.protocol_number).to_string(), |
|
242 room_info, |
|
243 ]; |
|
244 response.add(Info(info).send_self()) |
|
245 } else { |
|
246 response |
|
247 .add(server_chat("Player is not online.".to_string()).send_self()) |
|
248 } |
|
249 } |
|
250 HWProtocolMessage::ToggleServerRegisteredOnly => { |
|
251 if !server.clients[client_id].is_admin() { |
|
252 response.add(Warning("Access denied.".to_string()).send_self()); |
|
253 } else { |
|
254 server.set_is_registered_only(server.is_registered_only()); |
|
255 let msg = if server.is_registered_only() { |
|
256 "This server no longer allows unregistered players to join." |
|
257 } else { |
|
258 "This server now allows unregistered players to join." |
|
259 }; |
|
260 response.add(server_chat(msg.to_string()).send_all()); |
|
261 } |
|
262 } |
|
263 HWProtocolMessage::Global(msg) => { |
|
264 if !server.clients[client_id].is_admin() { |
|
265 response.add(Warning("Access denied.".to_string()).send_self()); |
|
266 } else { |
|
267 response.add(global_chat(msg).send_all()) |
|
268 } |
|
269 } |
|
270 HWProtocolMessage::SuperPower => { |
|
271 if !server.clients[client_id].is_admin() { |
|
272 response.add(Warning("Access denied.".to_string()).send_self()); |
|
273 } else { |
|
274 server.clients[client_id].set_has_super_power(true); |
|
275 response |
|
276 .add(server_chat("Super power activated.".to_string()).send_self()) |
|
277 } |
|
278 } |
|
279 HWProtocolMessage::Watch(id) => { |
|
280 #[cfg(feature = "official-server")] |
|
281 { |
|
282 response.request_io(IoTask::GetReplay { id }) |
|
283 } |
|
284 |
|
285 #[cfg(not(feature = "official-server"))] |
|
286 { |
|
287 response.add( |
|
288 Warning("This server does not support replays!".to_string()) |
|
289 .send_self(), |
|
290 ); |
|
291 } |
|
292 } |
|
293 _ => match server.clients[client_id].room_id { |
|
294 None => lobby::handle(server, client_id, response, message), |
|
295 Some(room_id) => { |
|
296 inroom::handle(server, client_id, response, room_id, message) |
|
297 } |
|
298 }, |
|
299 } |
|
300 } |
|
301 } |
|
302 } |
|
303 } |
|
304 |
|
305 pub fn handle_client_accept(server: &mut HWServer, client_id: ClientId, response: &mut Response) { |
|
306 let mut salt = [0u8; 18]; |
|
307 thread_rng().fill_bytes(&mut salt); |
|
308 |
|
309 server.anteroom.add_client(client_id, encode(&salt)); |
|
310 |
|
311 response.add(HWServerMessage::Connected(utils::SERVER_VERSION).send_self()); |
|
312 } |
|
313 |
|
314 pub fn handle_client_loss(server: &mut HWServer, client_id: ClientId, response: &mut Response) { |
|
315 if server.anteroom.remove_client(client_id).is_none() { |
|
316 common::remove_client(server, response, "Connection reset".to_string()); |
|
317 } |
|
318 } |
|
319 |
|
320 pub fn handle_io_result( |
|
321 server: &mut HWServer, |
|
322 client_id: ClientId, |
|
323 response: &mut Response, |
|
324 io_result: IoResult, |
|
325 ) { |
|
326 match io_result { |
|
327 IoResult::Account(Some(info)) => { |
|
328 if !info.is_registered && server.is_registered_only() { |
|
329 response.add( |
|
330 Bye("This server only allows registered users to join.".to_string()) |
|
331 .send_self(), |
|
332 ); |
|
333 response.remove_client(client_id); |
|
334 } else { |
|
335 response.add(ServerAuth(format!("{:x}", info.server_hash)).send_self()); |
|
336 if let Some(client) = server.anteroom.remove_client(client_id) { |
|
337 server.add_client(client_id, client); |
|
338 let client = &mut server.clients[client_id]; |
|
339 client.set_is_registered(info.is_registered); |
|
340 client.set_is_admin(info.is_admin); |
|
341 client.set_is_contributor(info.is_admin) |
|
342 } |
|
343 } |
|
344 } |
|
345 IoResult::Account(None) => { |
|
346 response.add(Error("Authentication failed.".to_string()).send_self()); |
|
347 response.remove_client(client_id); |
|
348 } |
|
349 IoResult::Replay(Some(replay)) => { |
|
350 let protocol = server.clients[client_id].protocol_number; |
|
351 let start_msg = if protocol < 58 { |
|
352 RoomJoined(vec![server.clients[client_id].nick.clone()]) |
|
353 } else { |
|
354 ReplayStart |
|
355 }; |
|
356 response.add(start_msg.send_self()); |
|
357 |
|
358 common::get_room_config_impl(&replay.config, client_id, response); |
|
359 common::get_teams(replay.teams.iter(), client_id, response); |
|
360 response.add(RunGame.send_self()); |
|
361 response.add(ForwardEngineMessage(replay.message_log).send_self()); |
|
362 |
|
363 if protocol < 58 { |
|
364 response.add(Kicked.send_self()); |
|
365 } |
|
366 } |
|
367 IoResult::Replay(None) => { |
|
368 response.add(Warning("Could't load the replay".to_string()).send_self()) |
|
369 } |
|
370 IoResult::SaveRoom(_, true) => { |
|
371 response.add(server_chat("Room configs saved successfully.".to_string()).send_self()); |
|
372 } |
|
373 IoResult::SaveRoom(_, false) => { |
|
374 response.add(Warning("Unable to save the room configs.".to_string()).send_self()); |
|
375 } |
|
376 IoResult::LoadRoom(room_id, Some(contents)) => { |
|
377 if let Some(ref mut room) = server.rooms.get_mut(room_id) { |
|
378 match room.set_saves(&contents) { |
|
379 Ok(_) => response.add( |
|
380 server_chat("Room configs loaded successfully.".to_string()).send_self(), |
|
381 ), |
|
382 Err(e) => { |
|
383 warn!("Error while deserializing the room configs: {}", e); |
|
384 response.add( |
|
385 Warning("Unable to deserialize the room configs.".to_string()) |
|
386 .send_self(), |
|
387 ); |
|
388 } |
|
389 } |
|
390 } |
|
391 } |
|
392 IoResult::LoadRoom(_, None) => { |
|
393 response.add(Warning("Unable to load the room configs.".to_string()).send_self()); |
|
394 } |
|
395 } |
|
396 } |
|