use std::net::SocketAddr; 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::oneshot::channel; use crate::core::player::{PlayerCommand, PlayerConnection, PlayerId, PlayerRegistry, Updates}; use crate::core::room::{RoomId, RoomInfo, RoomRegistry}; use crate::prelude::*; use crate::protos::irc::client::{client_message, ClientMessage}; use crate::protos::irc::server::{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: String, } #[derive(Debug)] struct RegisteredUser { nickname: Vec, username: Vec, realname: Vec, } async fn handle_socket( config: ServerConfig, mut stream: TcpStream, socket_addr: SocketAddr, mut players: PlayerRegistry, rooms: RoomRegistry, ) -> 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.as_bytes().to_vec()), body: ServerMessageBody::Notice { first_target: b"*".to_vec(), rest_targets: vec![], text: b"Welcome to my server!".to_vec(), }, } .write_async(&mut writer) .await?; writer.flush().await?; let registered_user: Result = handle_registration(&mut reader, &mut writer).await; match registered_user { Ok(user) => { handle_registered_socket( config, socket_addr, players, rooms, &mut reader, &mut writer, user, ) .await?; } Err(_) => {} } stream.shutdown().await?; Ok(()) } async fn handle_registration<'a>( reader: &mut BufReader>, writer: &mut BufWriter>, ) -> Result { let mut buffer = vec![]; let mut future_nickname: Option> = None; let mut future_username: Option<(Vec, Vec)> = None; loop { let res = reader.read_until(b'\n', &mut buffer).await; match res { Ok(len) => { if len == 0 { log::info!("Terminating socket"); break Err(anyhow::Error::msg("EOF")); } } Err(err) => { log::warn!("Failed to read from socket: {err}"); break Err(err.into()); } } let parsed = client_message(&buffer[..]); match parsed { Ok((rest, msg)) => { log::info!("Incoming IRC message: {msg:?}"); match msg { 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(); } } async fn handle_registered_socket<'a>( config: ServerConfig, socket_addr: SocketAddr, 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_bytes(user.nickname.clone())?; let mut connection = players.connect_to_player(player_id.clone()).await; ServerMessage { tags: vec![], sender: Some(config.server_name.as_bytes().to_vec()), body: ServerMessageBody::N001Welcome { client: user.nickname.clone(), text: b"Welcome to Kek Server".to_vec(), }, } .write_async(writer) .await?; ServerMessage { tags: vec![], sender: Some(config.server_name.as_bytes().to_vec()), body: ServerMessageBody::N002YourHost { client: user.nickname.clone(), text: b"Welcome to Kek Server".to_vec(), }, } .write_async(writer) .await?; ServerMessage { tags: vec![], sender: Some(config.server_name.as_bytes().to_vec()), body: ServerMessageBody::N003Created { client: user.nickname.clone(), text: b"Welcome to Kek Server".to_vec(), }, } .write_async(writer) .await?; ServerMessage { tags: vec![], sender: Some(config.server_name.as_bytes().to_vec()), body: ServerMessageBody::N004MyInfo { client: user.nickname.clone(), hostname: config.server_name.as_bytes().to_vec(), softname: b"kek-0.1.alpha.3".to_vec(), }, } .write_async(writer) .await?; ServerMessage { tags: vec![], sender: Some(config.server_name.as_bytes().to_vec()), body: ServerMessageBody::N005ISupport { client: user.nickname.clone(), params: b"CHANTYPES=#".to_vec(), }, } .write_async(writer) .await?; let (promise, deferred) = oneshot(); connection.send(PlayerCommand::GetRooms(promise)).await; let rooms_list = deferred.await?; for room in &rooms_list { produce_on_join_cmd_messages( &config, &user, &Chan::Global(room.id.as_bytes().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 }; handle_incoming_message(&buffer[0..len], &config, &user, &rooms, &mut connection, &player_id, writer).await?; buffer.clear(); }, update = connection.receiver.recv() => { match update.unwrap() { Updates::RoomJoined { new_member_id, room_id } => { if player_id == new_member_id { if let Some(room) = rooms.get_room(&room_id) { let room_info = room.get_room_info().await; let chan = Chan::Global(room_id.as_bytes().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_bytes().clone()), body: ServerMessageBody::Join(Chan::Global(room_id.as_bytes().clone())), }.write_async(writer).await?; writer.flush().await? } }, Updates::NewMessage { author_id, room_id, body } => { ServerMessage { tags: vec![], sender: Some(author_id.as_bytes().clone()), body: ServerMessageBody::PrivateMessage { target: Recipient::Chan(Chan::Global(room_id.as_bytes().clone())), body: body.as_bytes().to_vec() } }.write_async(writer).await?; writer.flush().await? }, Updates::RoomTopicChanged { room_id, new_topic } => { ServerMessage { tags: vec![], sender: Some(config.server_name.as_bytes().to_vec()), body: ServerMessageBody::N332Topic { client: user.nickname.clone(), chat: Chan::Global(room_id.as_bytes().clone()), topic: new_topic, }, }.write_async(writer).await?; writer.flush().await? }, } } } } Ok(()) } async fn handle_incoming_message( buffer: &[u8], config: &ServerConfig, user: &RegisteredUser, rooms: &RoomRegistry, user_handle: &mut PlayerConnection, player_id: &PlayerId, writer: &mut (impl AsyncWrite + Unpin), ) -> Result<()> { let parsed = client_message(buffer); match parsed { Ok((rest, msg)) => match msg { ClientMessage::Ping { token } => { ServerMessage { tags: vec![], sender: None, body: ServerMessageBody::Pong { from: config.server_name.as_bytes().to_vec(), token, }, } .write_async(writer) .await?; writer.flush().await?; } ClientMessage::Join(ref chan) => { handle_join(&config, &user, user_handle, chan, writer).await?; } ClientMessage::PrivateMessage { recipient, body } => match recipient { Recipient::Chan(Chan::Global(chan)) => match String::from_utf8(body) { Ok(body) => { let room_id = RoomId::from_bytes(chan)?; user_handle.send_message(room_id, body.clone()).await?; } Err(err) => log::warn!("failed to parse incoming message: {err}"), }, _ => log::warn!("Unsupported target type"), }, ClientMessage::Topic { chan, topic } => { match chan { Chan::Global(chan) => { let room_id = RoomId::from_bytes(chan)?; user_handle .change_topic(room_id.clone(), topic.clone()) .await?; ServerMessage { tags: vec![], sender: Some(config.server_name.as_bytes().to_vec()), body: ServerMessageBody::N332Topic { client: user.nickname.clone(), chat: Chan::Global(room_id.as_bytes().clone()), topic, }, } .write_async(writer) .await?; writer.flush().await?; } Chan::Local(_) => {} }; } cmd => { log::warn!("Not implemented handler for client command: {cmd:?}"); } }, Err(err) => { log::warn!("Failed to parse IRC message: {err}"); } } Ok(()) } 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_bytes(chan_name.clone())?; let room_info = user_handle.join_room(room_id).await?; produce_on_join_cmd_messages(&config, &user, chan, &room_info, writer).await?; writer.flush().await?; } Chan::Local(_) => {} }; 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.as_bytes().to_vec()), body: ServerMessageBody::N332Topic { client: user.nickname.clone(), chat: chan.clone(), topic: room_info.topic.clone(), }, } .write_async(writer) .await?; let mut members = if let Some(head) = room_info.members.first() { head.as_bytes().clone() } else { user.nickname.clone() }; for i in &room_info.members[1..] { members.push(b' '); members.extend(i.as_bytes()); } ServerMessage { tags: vec![], sender: Some(config.server_name.as_bytes().to_vec()), body: ServerMessageBody::N353NamesReply { client: user.nickname.clone(), chan: chan.clone(), members, }, } .write_async(writer) .await?; ServerMessage { tags: vec![], sender: Some(config.server_name.as_bytes().to_vec()), 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, ) -> Result { log::info!("Starting IRC projection"); let (signal, mut rx) = channel(); 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?; log::debug!("Listener started"); let handle = tokio::task::spawn(async move { loop { select! { biased; _ = &mut rx => break, 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}"); let players = players.clone(); let rooms = rooms.clone(); let current_connections_clone = current_connections.clone(); let handle = tokio::task::spawn(async move { match handle_socket(config, stream, socket_addr, players, rooms).await { Ok(_) => log::info!("Connection terminated"), Err(err) => log::warn!("Connection failed: {err}"), } current_connections_clone.dec(); }); }, Err(err) => log::warn!("Failed to accept new connection: {err}"), } }, } } log::info!("Stopping IRC projection"); Ok(()) }); let terminator = Terminator::from_raw(signal, handle); Ok(terminator) }