use std::collections::HashMap; use std::net::SocketAddr; use futures_util::future::join_all; use prometheus::{IntCounter, IntGauge, Registry as MetricsRegistry}; use serde::Deserialize; use tokio::io::{AsyncBufReadExt, AsyncWrite, AsyncWriteExt, BufReader, BufWriter}; use tokio::net::tcp::{ReadHalf, WriteHalf}; use tokio::net::{TcpListener, TcpStream}; use tokio::sync::mpsc::channel; use crate::core::player::*; use crate::core::repo::Storage; use crate::core::room::{RoomId, RoomInfo, RoomRegistry}; use crate::prelude::*; use crate::protos::irc::client::{client_message, ClientMessage}; use crate::protos::irc::server::{AwayStatus, ServerMessage, ServerMessageBody}; use crate::protos::irc::{Chan, Recipient}; use crate::util::Terminator; #[cfg(test)] mod test; #[derive(Deserialize, Debug, Clone)] pub struct ServerConfig { pub listen_on: SocketAddr, pub server_name: Str, } #[derive(Debug)] struct RegisteredUser { nickname: Str, /** * Username is mostly unused in modern IRC. * * [https://stackoverflow.com/questions/31666247/what-is-the-difference-between-the-nick-username-and-real-name-in-irc-and-wha] */ username: Str, realname: Str, } async fn handle_socket( config: ServerConfig, mut stream: TcpStream, socket_addr: &SocketAddr, players: PlayerRegistry, rooms: RoomRegistry, termination: Deferred<()>, // TODO use it to stop the connection gracefully mut storage: Storage, ) -> Result<()> { let (reader, writer) = stream.split(); let mut reader: BufReader = BufReader::new(reader); let mut writer = BufWriter::new(writer); ServerMessage { tags: vec![], sender: Some(config.server_name.clone().into()), body: ServerMessageBody::Notice { first_target: "*".into(), rest_targets: vec![], text: "Welcome to my server!".into(), }, } .write_async(&mut writer) .await?; writer.flush().await?; let registered_user: Result = handle_registration(&mut reader, &mut writer, &mut storage).await; match registered_user { Ok(user) => { handle_registered_socket(config, players, rooms, &mut reader, &mut writer, user) .await?; } Err(_) => {} } stream.shutdown().await?; Ok(()) } async fn handle_registration<'a>( reader: &mut BufReader>, writer: &mut BufWriter>, storage: &mut Storage, ) -> Result { let mut buffer = vec![]; let mut future_nickname: Option = None; let mut future_username: Option<(Str, Str)> = None; let mut pass: Option = None; let user = loop { let res = reader.read_until(b'\n', &mut buffer).await; let res = match res { Ok(len) => { if len == 0 { log::info!("Terminating socket"); break Err(anyhow::Error::msg("EOF")); } match std::str::from_utf8(&buffer[..len]) { Ok(res) => res, Err(e) => break Err(e.into()), } } Err(err) => { log::warn!("Failed to read from socket: {err}"); break Err(err.into()); } }; log::debug!("Incoming raw IRC message: '{res}'"); let parsed = client_message(res); match parsed { Ok((_, msg)) => { log::debug!("Incoming IRC message: {msg:?}"); match msg { ClientMessage::Pass { password } => { pass = Some(password); } ClientMessage::Nick { nickname } => { if let Some((username, realname)) = future_username { break Ok(RegisteredUser { nickname, username, realname, }); } else { future_nickname = Some(nickname); } } ClientMessage::User { username, realname } => { if let Some(nickname) = future_nickname { break Ok(RegisteredUser { nickname, username, realname, }); } else { future_username = Some((username, realname)); } } _ => {} } } Err(err) => { log::warn!("Failed to parse IRC message: {err}"); } } buffer.clear(); }?; let stored_user = storage.retrieve_user_by_name(&*user.nickname).await?; let stored_user = match stored_user { Some(u) => u, None => { log::info!("User '{}' not found", user.nickname); return Err(fail("no user found")); } }; if stored_user.password.is_none() { log::info!("Password not defined for user '{}'", user.nickname); return Err(fail("password is not defined")); } if stored_user.password.as_deref() != pass.as_deref() { log::info!("Incorrect password supplied for user '{}'", user.nickname); return Err(fail("passwords do not match")); } // TODO properly implement session temination Ok(user) } async fn handle_registered_socket<'a>( config: ServerConfig, mut players: PlayerRegistry, rooms: RoomRegistry, reader: &mut BufReader>, writer: &mut BufWriter>, user: RegisteredUser, ) -> Result<()> { let mut buffer = vec![]; log::info!("Handling registered user: {user:?}"); let player_id = PlayerId::from(user.nickname.clone())?; let mut connection = players.connect_to_player(player_id.clone()).await; ServerMessage { tags: vec![], sender: Some(config.server_name.clone()), body: ServerMessageBody::N001Welcome { client: user.nickname.clone(), text: "Welcome to Kek Server".into(), }, } .write_async(writer) .await?; ServerMessage { tags: vec![], sender: Some(config.server_name.clone()), body: ServerMessageBody::N002YourHost { client: user.nickname.clone(), text: "Welcome to Kek Server".into(), }, } .write_async(writer) .await?; ServerMessage { tags: vec![], sender: Some(config.server_name.clone()), body: ServerMessageBody::N003Created { client: user.nickname.clone(), text: "Welcome to Kek Server".into(), }, } .write_async(writer) .await?; ServerMessage { tags: vec![], sender: Some(config.server_name.clone()), body: ServerMessageBody::N004MyInfo { client: user.nickname.clone(), hostname: config.server_name.clone(), softname: "kek-0.1.alpha.3".into(), }, } .write_async(writer) .await?; ServerMessage { tags: vec![], sender: Some(config.server_name.clone()), body: ServerMessageBody::N005ISupport { client: user.nickname.clone(), params: "CHANTYPES=#".into(), }, } .write_async(writer) .await?; let rooms_list = connection.get_rooms().await?; for room in &rooms_list { produce_on_join_cmd_messages( &config, &user, &Chan::Global(room.id.as_inner().clone()), room, writer, ) .await?; } writer.flush().await?; loop { select! { biased; len = reader.read_until(b'\n', &mut buffer) => { let len = len?; let len = if len == 0 { log::info!("EOF, Terminating socket"); break; } else { len }; let incoming = std::str::from_utf8(&buffer[0..len])?; if let HandleResult::Leave = handle_incoming_message(incoming, &config, &user, &rooms, &mut connection, writer).await? { break; } buffer.clear(); }, update = connection.receiver.recv() => { if let Some(update) = update { handle_update(&config, &user, &player_id, writer, &rooms, update).await?; } else { log::warn!("Player is terminated, must terminate the connection"); break; } } } } ServerMessage { tags: vec![], sender: Some(config.server_name.clone()), body: ServerMessageBody::Error { reason: "Leaving the server".into(), }, } .write_async(writer) .await?; writer.flush().await?; connection.terminate().await; Ok(()) } async fn handle_update( config: &ServerConfig, user: &RegisteredUser, player_id: &PlayerId, writer: &mut (impl AsyncWrite + Unpin), rooms: &RoomRegistry, update: Updates, ) -> Result<()> { log::debug!("Sending irc message to player {player_id:?} on update {update:?}"); match update { Updates::RoomJoined { new_member_id, room_id, } => { if player_id == &new_member_id { if let Some(room) = rooms.get_room(&room_id).await { let room_info = room.get_room_info().await; let chan = Chan::Global(room_id.as_inner().clone()); produce_on_join_cmd_messages(&config, &user, &chan, &room_info, writer).await?; writer.flush().await?; } else { log::warn!("Received join to a non-existant room"); } } else { ServerMessage { tags: vec![], sender: Some(new_member_id.as_inner().clone()), body: ServerMessageBody::Join(Chan::Global(room_id.as_inner().clone())), } .write_async(writer) .await?; writer.flush().await? } } Updates::RoomLeft { room_id, former_member_id, } => { ServerMessage { tags: vec![], sender: Some(former_member_id.as_inner().clone()), body: ServerMessageBody::Part(Chan::Global(room_id.as_inner().clone())), } .write_async(writer) .await?; writer.flush().await? } Updates::NewMessage { author_id, room_id, body, } => { ServerMessage { tags: vec![], sender: Some(author_id.as_inner().clone()), body: ServerMessageBody::PrivateMessage { target: Recipient::Chan(Chan::Global(room_id.as_inner().clone())), body: body.clone(), }, } .write_async(writer) .await?; writer.flush().await? } Updates::RoomTopicChanged { room_id, new_topic } => { ServerMessage { tags: vec![], sender: Some(config.server_name.clone()), body: ServerMessageBody::N332Topic { client: user.nickname.clone(), chat: Chan::Global(room_id.as_inner().clone()), topic: new_topic, }, } .write_async(writer) .await?; writer.flush().await? } Updates::BannedFrom(room_id) => { // TODO think about the case when the user was banned, but was not in the room - no need to send PART in this case ServerMessage { tags: vec![], sender: Some(player_id.as_inner().clone()), body: ServerMessageBody::Part(Chan::Global(room_id.as_inner().clone())), } .write_async(writer) .await?; writer.flush().await? } } Ok(()) } enum HandleResult { Continue, Leave, } async fn handle_incoming_message( buffer: &str, config: &ServerConfig, user: &RegisteredUser, rooms: &RoomRegistry, user_handle: &mut PlayerConnection, writer: &mut (impl AsyncWrite + Unpin), ) -> Result { log::debug!("Incoming raw IRC message: '{buffer}'"); let parsed = client_message(buffer); log::debug!("Incoming IRC message: {parsed:?}"); match parsed { Ok((_, msg)) => match msg { ClientMessage::Ping { token } => { ServerMessage { tags: vec![], sender: Some(config.server_name.clone()), body: ServerMessageBody::Pong { from: config.server_name.clone(), token, }, } .write_async(writer) .await?; writer.flush().await?; } ClientMessage::Join(ref chan) => { handle_join(&config, &user, user_handle, chan, writer).await?; } ClientMessage::Part { chan, message } => { handle_part(config, user, user_handle, &chan, writer).await?; } ClientMessage::PrivateMessage { recipient, body } => match recipient { Recipient::Chan(Chan::Global(chan)) => { let room_id = RoomId::from(chan)?; user_handle.send_message(room_id, body).await?; }, _ => log::warn!("Unsupported target type"), }, ClientMessage::Topic { chan, topic } => { match chan { Chan::Global(chan) => { let room_id = RoomId::from(chan)?; user_handle .change_topic(room_id.clone(), topic.clone()) .await?; ServerMessage { tags: vec![], sender: Some(config.server_name.clone()), body: ServerMessageBody::N332Topic { client: user.nickname.clone(), chat: Chan::Global(room_id.as_inner().clone()), topic, }, } .write_async(writer) .await?; writer.flush().await?; } Chan::Local(_) => {} }; } ClientMessage::Who { target } => match &target { Recipient::Nick(nick) => { // TODO handle non-existing user let mut username = format!("~{nick}"); let mut host = format!("user/{nick}"); ServerMessage { tags: vec![], sender: Some(config.server_name.clone()), body: user_to_who_msg(config, user, nick), } .write_async(writer) .await?; ServerMessage { tags: vec![], sender: Some(config.server_name.clone()), body: ServerMessageBody::N315EndOfWho { client: user.nickname.clone(), mask: target.clone(), msg: "End of WHO list".into(), }, } .write_async(writer) .await?; writer.flush().await?; } Recipient::Chan(Chan::Global(chan)) => { let room = rooms.get_room(&RoomId::from(chan.clone())?).await; if let Some(room) = room { let room_info = room.get_room_info().await; for member in room_info.members { ServerMessage { tags: vec![], sender: Some(config.server_name.clone()), body: user_to_who_msg(config, user, member.as_inner()), } .write_async(writer) .await?; } } ServerMessage { tags: vec![], sender: Some(config.server_name.clone()), body: ServerMessageBody::N315EndOfWho { client: user.nickname.clone(), mask: target.clone(), msg: "End of WHO list".into(), }, } .write_async(writer) .await?; writer.flush().await?; } Recipient::Chan(Chan::Local(_)) => { log::warn!("Local chans not supported"); } }, ClientMessage::Mode { target } => { match target { Recipient::Nick(nickname) => { if nickname == user.nickname { ServerMessage { tags: vec![], sender: Some(config.server_name.clone()), body: ServerMessageBody::N221UserModeIs { client: user.nickname.clone(), modes: "+r".into(), }, } .write_async(writer) .await?; writer.flush().await?; } else { ServerMessage { tags: vec![], sender: Some(config.server_name.clone()), body: ServerMessageBody::N502UsersDontMatch { client: user.nickname.clone(), message: "Cant change mode for other users".into(), }, } .write_async(writer) .await?; writer.flush().await?; } } Recipient::Chan(_) => { // TODO handle chan mode handling } } } ClientMessage::Quit { reason } => { log::info!("Received QUIT"); return Ok(HandleResult::Leave); } cmd => { log::warn!("Not implemented handler for client command: {cmd:?}"); } }, Err(err) => { log::warn!("Failed to parse IRC message: {err}"); } } Ok(HandleResult::Continue) } fn user_to_who_msg( config: &ServerConfig, requestor: &RegisteredUser, target_user_nickname: &Str, ) -> ServerMessageBody { // Username is equal to nickname let username = format!("~{target_user_nickname}").into(); // User's host is not public, replace it with `user/` pattern let mut host = format!("user/{target_user_nickname}").into(); ServerMessageBody::N352WhoReply { client: requestor.nickname.clone(), username, host, server: config.server_name.clone(), flags: AwayStatus::Here, nickname: target_user_nickname.clone(), hops: 0, // TODO Realname is not available yet, should be matched to a future core's player field realname: target_user_nickname.clone(), } } async fn handle_join( config: &ServerConfig, user: &RegisteredUser, user_handle: &mut PlayerConnection, chan: &Chan, writer: &mut (impl AsyncWrite + Unpin), ) -> Result<()> { match chan { Chan::Global(chan_name) => { let room_id = RoomId::from(chan_name.clone())?; if let JoinResult::Success(room_info) = user_handle.join_room(room_id).await? { produce_on_join_cmd_messages(&config, &user, chan, &room_info, writer).await?; } else { ServerMessage { tags: vec![], sender: Some(config.server_name.clone()), body: ServerMessageBody::N474BannedFromChan { client: user.nickname.clone(), chan: chan.clone(), message: "U dun goofed".into(), }, } .write_async(writer) .await?; } writer.flush().await?; } Chan::Local(_) => {} }; Ok(()) } async fn handle_part( config: &ServerConfig, user: &RegisteredUser, user_handle: &mut PlayerConnection, chan: &Chan, writer: &mut (impl AsyncWrite + Unpin), ) -> Result<()> { if let Chan::Global(chan_name) = chan { let room_id = RoomId::from(chan_name.clone())?; user_handle.leave_room(room_id).await?; ServerMessage { tags: vec![], sender: Some(user.nickname.clone()), body: ServerMessageBody::Part(Chan::Global(chan_name.clone())), } .write_async(writer) .await?; writer.flush().await?; } else { log::warn!("Local chans unsupported"); } Ok(()) } async fn produce_on_join_cmd_messages( config: &ServerConfig, user: &RegisteredUser, chan: &Chan, room_info: &RoomInfo, writer: &mut (impl AsyncWrite + Unpin), ) -> Result<()> { ServerMessage { tags: vec![], sender: Some(user.nickname.clone()), body: ServerMessageBody::Join(chan.clone()), } .write_async(writer) .await?; ServerMessage { tags: vec![], sender: Some(config.server_name.clone()), body: ServerMessageBody::N332Topic { client: user.nickname.clone(), chat: chan.clone(), topic: room_info.topic.clone(), }, } .write_async(writer) .await?; let mut members: String = if let Some(head) = room_info.members.first() { head.as_inner().clone() } else { user.nickname.clone() }.as_ref().into(); for i in &room_info.members[1..] { members.push(' '); members.push_str(i.as_inner()); } ServerMessage { tags: vec![], sender: Some(config.server_name.clone()), body: ServerMessageBody::N353NamesReply { client: user.nickname.clone(), chan: chan.clone(), members: members.into(), }, } .write_async(writer) .await?; ServerMessage { tags: vec![], sender: Some(config.server_name.clone()), body: ServerMessageBody::N366NamesReplyEnd { client: user.nickname.clone(), chan: chan.clone(), }, } .write_async(writer) .await?; Ok(()) } pub async fn launch( config: ServerConfig, players: PlayerRegistry, rooms: RoomRegistry, metrics: MetricsRegistry, storage: Storage, ) -> Result { log::info!("Starting IRC projection"); let (stopped_tx, mut stopped_rx) = channel(32); let current_connections = IntGauge::new("irc_current_connections", "Open and alive TCP connections")?; let total_connections = IntCounter::new( "irc_total_connections", "Total number of opened connections", )?; metrics.register(Box::new(current_connections.clone()))?; metrics.register(Box::new(total_connections.clone()))?; let listener = TcpListener::bind(config.listen_on).await?; let terminator = Terminator::spawn(|mut rx| async move { // TODO probably should separate logic for accepting new connection and storing them // into two tasks so that they don't block each other let mut actors = HashMap::new(); loop { select! { biased; _ = &mut rx => break, stopped = stopped_rx.recv() => match stopped { Some(stopped) => { let _ = actors.remove(&stopped); }, None => unreachable!(), }, new_conn = listener.accept() => { match new_conn { Ok((stream, socket_addr)) => { let config = config.clone(); total_connections.inc(); current_connections.inc(); log::debug!("Incoming connection from {socket_addr}"); if actors.contains_key(&socket_addr) { log::warn!("Already contains connection form {socket_addr}"); // TODO kill the older connection and restart it continue; } let terminator = Terminator::spawn(|termination| { let players = players.clone(); let rooms = rooms.clone(); let current_connections_clone = current_connections.clone(); let stopped_tx = stopped_tx.clone(); let storage = storage.clone(); async move { match handle_socket(config, stream, &socket_addr, players, rooms, termination, storage).await { Ok(_) => log::info!("Connection terminated"), Err(err) => log::warn!("Connection failed: {err}"), } current_connections_clone.dec(); stopped_tx.send(socket_addr).await?; Ok(()) } }); actors.insert(socket_addr, terminator); }, Err(err) => log::warn!("Failed to accept new connection: {err}"), } }, } } log::info!("Stopping IRC projection"); join_all(actors.into_iter().map(|(socket_addr, terminator)| async move { log::debug!("Stopping IRC connection at {socket_addr}"); match terminator.terminate().await { Ok(_) => log::debug!("Stopped IRC connection at {socket_addr}"), Err(err) => { log::warn!("IRC connection to {socket_addr} finished with error: {err}") } } })).await; log::info!("Stopped IRC projection"); Ok(()) }); log::info!("Started IRC projection"); Ok(terminator) }